feat(strate): passages aim at open space -- for half the archetypes, measurably

Tier 1. GeneratePassages placed every passage at a random angle, distance and
reach, never consulting the destination strate. The carved tube is air by
construction, so nothing looked wrong -- but whether the lower mouth joined the
destination's connected cave space was luck. A player could descend and arrive
in a sealed pocket. The primordial law was a hope.

VF_SuggestOpenPointZ is a pure free function of (archetype, params, seed, XY):
no operator stack, no StrateManager, no cache. That is deliberate. This runs
inside Initialize, where the layout is half-built and LayoutVersion is in
flight, so anything holding a manager pointer there is a re-entrancy trap.

Coverage is four archetypes of eight, and the number is the deliverable:
7 passages, 3 aimed at generator-confirmed open space with 48/48 ring samples
air, 4 falling back. The hole is not closed. It is measured, where this morning
it was invisible.

Two corrections from Codex, both mine and both would have shipped confident
nonsense: room placement is seeded by MakeStrateSeed, not the passage salt, so
my version would have queried a cave graph that does not exist; and slabs need
the world seed because that is what GetSlabDensity uses.

And one of mine caught in review: the first test sampled GetDensityAt at the
mouth and asserted air, which is true by construction because the passage carve
is a structural-post invariant. It could not fail. Replaced with a 16-point
ring outside the carve radius requiring 8/16 air -- a proxy for connectivity,
not a proof. The proof is a flood fill, which is Tier 2.

Logging: my first spec asked for a per-passage warning on fallback. It fired
572 times and turned 14 clean tests yellow, which is precisely the anti-pattern
OPSTACK-HANDOFF.md warns about -- a warning that always means "this is fine"
teaches people to ignore warnings. Now one sorted Log line per layout build.

Built clean, suite green: 17 succeeded, 0 with warnings, 0 failed.

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

ARCHITECTURE.md

@@ -290,6 +290,16 @@ is a simple straight tube. Placement, reach, and shape draws for inter-strate pa
 connection count cannot shift any later passage. Global passage settings were removed from
 `VoxelSettings`.
 
+After a passage's XY is selected, `GeneratePassages` asks the **destination** strate for a lower-mouth
+height through the pure free function `VF_SuggestOpenPointZ` (`VoxelCaveMorphology`). TunnelNetwork and
+Underwater use the nearest hash-placed room centre, with `MakeStrateSeed(world-seed, strate-index)`
+matching the room graph's existing identity; FlatPlain and CrystalChamber recompute their slab void
+band and reject column-overlap points. Maze, SurfaceWorld, VerticalShafts, and FloatingIslands remain
+explicitly unanswerable for this tier: they keep the historical random reach and emit a warning. This
+query is source-level only — it does not construct an operator stack, touch a cache, or call back into
+`UVoxelStrateManager` while `Initialize` is building the layout. The resulting lower endpoint is
+clamped to the destination's seal-free interior.
+
 ### 8.9 Carving — brush shapes + editor controls
 `FVoxelModification` has `EVoxelBrushShape {Sphere,Box,Capsule}` + `BoxExtent`/`CapsuleEnd`/
 `Falloff` + `GetWorldBounds`. `UVoxelDiffLayer::GetDensityOffset` switches per shape; chunk

CODEMAP.md

@@ -318,6 +318,12 @@ Header is rich with inline docs. Two namespaces + a per-chunk cache system.
   | `EvaluateSDFCached` | 757 | **Phase 2** (per voxel): SmoothMin over cached rooms/tunnels; returns nearest room idx for terrain-op lookup. **Signature changed (perf pass 2): `RoomShapeVariety` param REMOVED** — the shape roll + capsule trig are pre-baked into `FCachedRoom` (`ShapeType/ShapeA/ShapeB/ShapeR`) by `BuildChunkCache`, bit-identical. |
   | `EvaluateSDF` | 738 | Convenience wrapper (builds temp cache) for one-off queries. |
 
+`MakeStrateSeed` (h:~477) is the shared pure world-seed/strate-index salt used by both
+`BuildChunkCache` and destination landing queries. `VF_SuggestOpenPointZ` (h:~550, implemented in
+`VoxelCaveMorphology.cpp`) is the pure landing-site query: nearest hash room centre for
+TunnelNetwork/Underwater, slab void midpoint for FlatPlain/CrystalChamber, and `false` for the other
+archetypes. It never touches a generator, operator stack, manager, cache, or mutable state.
+
   Performance note (h:209-220): caching rooms/tunnels once per chunk instead of per
   voxel is the single biggest CPU win.
 
@@ -354,7 +360,7 @@ Maps depth→strate at runtime; owns passages.
 | Method | .cpp line | Role |
 |--------|-----------|------|
 | `Initialize` | 10 | Builds the stacked layout from settings+seed (fixed slots + pool sorted by soft-asset path, then unchanged Fisher-Yates shuffle), logs every **cave** slot whose operator-stack opt-in is disabled, then `GeneratePassages`. SurfaceWorld is deliberately excluded from that diagnostic because its exact-lattice T1.d path does not depend on the flag. |
-| `GeneratePassages` | 146 | Deterministic passages between consecutive strates (per-strate `PassageConfig::Style` control points; auto passages retain the existing `EVoxelPassageType` default); placement and shape values are independently salted hashes of seed + boundary slot + connection index. |
+| `GeneratePassages` | 247 | Deterministic passages between consecutive strates (per-strate `PassageConfig::Style` control points; auto passages retain the existing `EVoxelPassageType` default); placement and shape values are independently salted hashes of seed + boundary slot + connection index. After XY placement, the destination's pure `VF_SuggestOpenPointZ` targets the lower mouth and the result is clamped outside the destination seal bands; unsupported answers warn and preserve the old random reach. |
 | `EvaluateModifierSDF` | 357 | SDF of passages at a point (for carving). Per-chunk `thread_local` shortlist (`PassagesVersion`-stamped) → far chunks return `FLT_MAX` without walking `Passages`. §8.10. |
 | `AnyPassageNearBox` | — | Conservative sphere-vs-AABB test of every passage's bound against a voxel box (+carve blend pad). Per TILE (ClassifyTile guard), never per voxel. |
 | `FindSlotIndexForChunkZ` | 427 | Z → layout index. |
@@ -454,6 +460,7 @@ The plugin's first tests (`OPSTACK-PLAN.md` Phase 0.5). Run them from the editor
 | `VoxelForgeOpStackMazeTest.cpp` | `VoxelForge.OpStack.MazeEquivalence` | **Phase 1's load-bearing test.** The 7-op Maze stack vs `GetMazeDensity` over 20k points (aiming for bit-identity; a side-of-iso disagreement is the hard fail), plus purity across workers and brute force on every box verdict the stack emits. Reports how many tiles the stack can prove uniform — today's `ClassifyTile` proves **zero** for any cave archetype. |
 | `VoxelForgeStrateParamCoverageTest.cpp` | `VoxelForge.Determinism.StrateParamBlendCoverage` | **The X-macro guard** (added 2026-08-17). `FStrateGenerationParams::Lerp` blends the hand-written `VF_STRATE_PARAM_FIELDS` list, **not** the struct — so a field added to one and not the other compiles, tests green, and silently takes its **default** inside every Gradient/Interleaved transition band. This expands the X-macro a **third** way (after LERP and SNAP), into a name list, and diffs it against the struct's UObject reflection. Pure shape test: no fixture, no world, instant. `GExemptFieldNames` is **empty** — every reflected field is covered today, and any exemption must be written down as a decision. Stakes rise with the world composer, which intends to invent parameter sets through this same `Lerp` (`COMPOSER-NOTES.md`). |
 | `VoxelForgeLayoutOrderIndependenceTest.cpp` | `VoxelForge.Determinism.LayoutOrderIndependence` | Builds a known transient soft-pointer pool, then rebuilds it in original, reversed, and swapped orders. Requires a non-empty layout and passage set, and compares every slot's definition/Z/height plus passage endpoints, radius, type, control geometry, and bounds bit-for-bit. |
+| `VoxelForgePassageOpenSpaceTest.cpp` | `VoxelForge.Determinism.PassageLandsInOpenSpace` | Uses the real fixture density path to check every generated inter-strate passage whose destination query answers: a 16-point ring outside the mouth's carve/blend band has at least half its samples in destination air, and the endpoint matches the pure open-point result within the mouth's float envelope. This is a connectivity proxy, not a flood-fill proof. Reports checked passages and false/unanswerable archetypes; fails if it inspects zero passages. |
 
 ## 4. The density pipeline (most-edited hot path)
 

COMPOSER-NOTES.md

@@ -343,7 +343,7 @@ the parameter named "max".
 It proves anything below `TerrainZ` solid and skips meshing. Any future 3D generation inside mountains
 needs a guard, or the caves vanish with no error.
 
-### ⚠️ 6.4 The primordial law has a real hole TODAY
+### 🔨 6.4 The primordial law hole — HALF FIXED (4 of 8 archetypes), built + green
 
 `UVoxelStrateManager::GeneratePassages` places every inter-strate passage as independently salted
 hashes of `(seed, upper-strate index, connection index)` → random angle around the (0,0) spine →
@@ -561,3 +561,51 @@ acceptance conditions. Both now met:
 
 ⚠️ **Read the PROVED counts as measurements, never as contracts.** What is asserted is that none of
 them is *wrong* — a false verdict leaves no geometry and no collision behind it.
+
+---
+
+## 11. Tier 1 status — passages aim at real open space (PARTIAL, built + green)
+
+**Landed 2026-08-17.** `VF_SuggestOpenPointZ` (in `VoxelCaveMorphology`) is a **pure free function** of
+(archetype, params, seed, XY) — it touches no operator stack, no `UVoxelStrateManager`, no cache. That
+matters: `GeneratePassages` runs inside `Initialize`, when the layout is half-built and `LayoutVersion`
+is mid-flight, so constructing anything holding a manager pointer there is a re-entrancy trap.
+
+`GeneratePassages` now asks the **destination** strate for an open Z near the chosen XY and aims the
+lower mouth there, clamped strictly inside the interior (never into a seal band). Where the archetype
+cannot answer, **today's random reach is preserved unchanged**.
+
+### ⚠️ Coverage is PARTIAL and the number is the point
+Measured by `VoxelForge.Determinism.PassageLandsInOpenSpace`:
+
+> *7 inter-strate passages, 3 checked, 48/48 ring samples air, 4 query-false (4 unique archetypes;
+> 4 unsupported, 0 supported-but-no-point).*
+
+✅ **Answering:** TunnelNetwork · Underwater · FlatPlain · CrystalChamber.
+❌ **Not answering:** Maze · VerticalShafts · SurfaceWorld (and by extension FloatingIslands).
+
+⇒ **The primordial law is guaranteed for four archetypes of eight.** The improvement over this morning
+is not that the hole is closed — it is that the gap is now **measured instead of invisible**. Follow-on
+work: Maze can answer from its lattice nodes, VerticalShafts from its shafts, SurfaceWorld from just
+above `TerrainZ`, FloatingIslands from just above a blob top.
+
+### Two seed contracts, do not mix them
+- **TunnelNetwork / Underwater** → `VoxelCaveMorphology::MakeStrateSeed` (the strate's own room seed).
+- **Slab archetypes** → the generator **world** seed, which is what `GetSlabDensity` uses.
+
+Seeding the query from the passage salt hash — which my spec originally asked for — would inspect a
+cave graph that **does not exist** and return confident answers about imaginary rooms. Codex caught it.
+
+### The test is a proxy, and says so
+The first version sampled `GetDensityAt` at the mouth and asserted air — **vacuous**, because
+`VF_ApplyPassageCarving` is a structural-post invariant, so the tube is air *at its own mouth by
+construction*. It passed whether the aiming worked or not. Replaced with a **16-point lateral ring** at
+`MouthRadius + 2 × PassageBlend` (~14 voxels at defaults), requiring ≥ 8/16 air. A mouth in a real room
+has open space around it; a mouth in bedrock has only the tube it dug itself.
+⚠️ **It is a proxy for connectivity, not a proof.** The proof is a flood fill — Tier 2.
+
+### ⚠️ A forked placement envelope, guarded by that test
+`VF_FindNearestHashRoomZ` re-derives the room vertical placement envelope that `BuildChunkCache` also
+computes. Calling the per-chunk cache builder from `Initialize` is impractical, so this is a deliberate
+second copy. **Both sites now carry a PLACEMENT CONTRACT comment naming the other**, and the ring test
+is the only thing standing between a placement change and silent bedrock passages.

Source/VoxelForge/Private/Tests/VoxelForgePassageOpenSpaceTest.cpp

@@ -0,0 +1,275 @@
+// VoxelForgePassageOpenSpaceTest.cpp
+// Vérifie que les bouches basses des passages ciblées tombent dans l'air de leur strate destination.
+// Verifies that targeted lower passage mouths land in air in their destination strate.
+
+#if WITH_DEV_AUTOMATION_TESTS
+
+#include "Misc/AutomationTest.h"
+
+#include "VoxelCaveMorphology.h"
+#include "VoxelDensityPrimitives.h"
+#include "VoxelForgeTestFixture.h"
+
+IMPLEMENT_SIMPLE_AUTOMATION_TEST(
+    FVoxelForgePassageLandsInOpenSpaceTest,
+    "VoxelForge.Determinism.PassageLandsInOpenSpace",
+    EAutomationTestFlags_ApplicationContextMask | EAutomationTestFlags::EngineFilter)
+
+namespace
+{
+    // The query and production density path use different seed identities for room graphs and
+    // slabs. Keep the test's oracle explicit so a future seed change cannot silently inspect a
+    // different room layout. / La requête et la densité utilisent des identités de seed différentes
+    // pour les graphes de salles et les slabs ; garder l'oracle explicite évite une dérive silencieuse.
+    int32 OpenPointSeedFor(
+        const UVoxelStrateDefinition& Definition,
+        const FStrateSlot& Destination,
+        int32 WorldSeed)
+    {
+        const bool bUsesCaveRooms =
+            Definition.GeneratorType == ECaveGeneratorType::TunnelNetwork
+            || Definition.GeneratorType == ECaveGeneratorType::Underwater;
+        return bUsesCaveRooms
+            ? static_cast<int32>(VoxelCaveMorphology::MakeStrateSeed(
+                static_cast<uint32>(WorldSeed), Destination.StrateIndex))
+            : WorldSeed;
+    }
+
+    FString ArchetypeName(ECaveGeneratorType Archetype)
+    {
+        if (const UEnum* ArchetypeEnum = StaticEnum<ECaveGeneratorType>())
+        {
+            return ArchetypeEnum->GetNameStringByValue(static_cast<int64>(Archetype));
+        }
+        return FString::Printf(TEXT("Value_%d"), static_cast<int32>(Archetype));
+    }
+}
+
+bool FVoxelForgePassageLandsInOpenSpaceTest::RunTest(const FString& Parameters)
+{
+    using namespace VoxelForgeTest;
+
+    FTestWorld World;
+    // Seed 4468 deliberately gives the supported Underwater destination a mouth near the centre
+    // of a real hash room, while the old random lower reach places that same mouth well outside
+    // the room's vertical extent. That makes disabling the Z aiming fail deterministically instead
+    // of relying on a lucky seed.
+    World.Build(/*InSeed=*/4468);
+    if (!World.IsValid())
+    {
+        AddError(World.WhyInvalid());
+        return false;
+    }
+
+    const TArray<FStrateSlot>& Layout = World.StrateManager->GetLayout();
+    const TArray<FVoxelPassage>& Passages = World.StrateManager->GetPassages();
+    const int32 WorldSeed = World.Settings->Seed;
+
+    int32 NumInterStratePassages = 0;
+    int32 NumChecked = 0;
+    int32 NumQueryFalse = 0;
+    int32 NumUnsupported = 0;
+    int32 NumSupportedWithoutPoint = 0;
+    int32 NumRingAirSamples = 0;
+    int32 NumRingSamples = 0;
+    TSet<uint8> FalseArchetypes;
+    bool bAllAnswerableMouthRingsHaveAir = true;
+    bool bAllAnswerableEndpointsMatchQuery = true;
+
+    for (const FVoxelPassage& Passage : Passages)
+    {
+        // The surface entry is a same-strate shaft and is not an inter-strate destination query.
+        // Le puits de surface relie la même strate ; ce n'est pas un passage inter-strates à tester.
+        if (Passage.UpperStrateIndex == Passage.LowerStrateIndex)
+        {
+            continue;
+        }
+
+        ++NumInterStratePassages;
+        if (!Layout.IsValidIndex(Passage.LowerStrateIndex))
+        {
+            AddError(FString::Printf(
+                TEXT("Passage lower endpoint references invalid destination strate index %d."),
+                Passage.LowerStrateIndex));
+            continue;
+        }
+
+        const FStrateSlot& Destination = Layout[Passage.LowerStrateIndex];
+        const UVoxelStrateDefinition* Definition = Destination.Definition;
+        if (!Definition)
+        {
+            AddError(FString::Printf(
+                TEXT("Passage destination strate %d has no definition."),
+                Destination.StrateIndex));
+            continue;
+        }
+
+        if (!Layout.IsValidIndex(Passage.UpperStrateIndex))
+        {
+            AddError(FString::Printf(
+                TEXT("Passage to strate %d references invalid source strate index %d."),
+                Destination.StrateIndex,
+                Passage.UpperStrateIndex));
+            continue;
+        }
+
+        const FStrateSlot& Source = Layout[Passage.UpperStrateIndex];
+        const UVoxelStrateDefinition* SourceDefinition = Source.Definition;
+        if (!SourceDefinition)
+        {
+            AddError(FString::Printf(
+                TEXT("Passage source strate %d has no definition."),
+                Source.StrateIndex));
+            continue;
+        }
+
+        const FStratePassageConfig& PassageConfig = SourceDefinition->PassageConfig;
+        if (!FMath::IsFinite(PassageConfig.MouthRadius) || PassageConfig.MouthRadius <= 0.0f)
+        {
+            AddError(FString::Printf(
+                TEXT("Passage to strate %d (%s) has invalid mouth radius %.9g."),
+                Destination.StrateIndex,
+                *ArchetypeName(Definition->GeneratorType),
+                PassageConfig.MouthRadius));
+            continue;
+        }
+
+        const float StrateTopZ = (float)(Destination.TopChunkZ + 1) * CHUNK_SIZE;
+        const float StrateBottomZ = (float)Destination.BottomChunkZ * CHUNK_SIZE;
+        const int32 QuerySeed = OpenPointSeedFor(*Definition, Destination, WorldSeed);
+
+        float SuggestedZ = 0.0f;
+        const bool bCanAnswer = VF_SuggestOpenPointZ(
+            Definition->GeneratorType,
+            Definition->GenerationParams,
+            Definition->SlabParams,
+            QuerySeed,
+            StrateTopZ,
+            StrateBottomZ,
+            Passage.LowerPoint.X,
+            Passage.LowerPoint.Y,
+            SuggestedZ);
+
+        if (!bCanAnswer)
+        {
+            ++NumQueryFalse;
+            FalseArchetypes.Add(static_cast<uint8>(Definition->GeneratorType));
+
+            const bool bExpectedToBeSupported =
+                Definition->GeneratorType == ECaveGeneratorType::TunnelNetwork
+                || Definition->GeneratorType == ECaveGeneratorType::Underwater
+                || Definition->GeneratorType == ECaveGeneratorType::FlatPlain
+                || Definition->GeneratorType == ECaveGeneratorType::CrystalChamber;
+            if (bExpectedToBeSupported)
+            {
+                ++NumSupportedWithoutPoint;
+            }
+            else
+            {
+                ++NumUnsupported;
+            }
+            continue;
+        }
+
+        ++NumChecked;
+
+        // Control-point endpoints are anchored (vertical wobble has a zero envelope at a mouth),
+        // so the generated endpoint must be exactly the query result.
+        // Les extrémités sont ancrées (la wobble verticale vaut zéro à une bouche) : l'endpoint
+        // généré doit donc être exactement le résultat de la requête.
+        // A mouth's sine envelope is intentionally zero; allow only the tiny float envelope
+        // produced by evaluating that zero at PI, never a meaningful targeting miss.
+        // L'enveloppe de bouche est intentionnellement nulle ; tolérer seulement l'infime erreur
+        // flottante de son évaluation à PI, jamais un échec de visée significatif.
+        if (!FMath::IsNearlyEqual(Passage.LowerPoint.Z, SuggestedZ, 0.01f))
+        {
+            bAllAnswerableEndpointsMatchQuery = false;
+            AddError(FString::Printf(
+                TEXT("Passage to strate %d (%s) missed its suggested open Z: endpoint %.9g, query %.9g."),
+                Destination.StrateIndex,
+                *ArchetypeName(Definition->GeneratorType),
+                Passage.LowerPoint.Z,
+                SuggestedZ));
+        }
+
+        // A center sample is VACUOUS: VF_ApplyPassageCarving deliberately makes the mouth air,
+        // even when the destination archetype is solid there. Probe a lateral ring instead.
+        // The ring is Cfg.MouthRadius + two complete PassageBlend bands (4 voxels each): the
+        // first clears the passage's carve/blend reach, and the second is a safety margin beyond
+        // EvaluateModifierSDF's 3-voxel junction smoothing. At this radius the passage itself
+        // cannot supply the air being counted; a nearby destination room/void must do so.
+        // Require 8 of 16 samples (50%): that is a meaningful open circumference for a mouth,
+        // while a mouth in bedrock has zero air once its own tube is outside the ring. This is a
+        // connectivity PROXY, not proof that the mouth is connected to the room: a disconnected
+        // pocket can pass it. A real proof needs a flood fill (Tier 2).
+        // Un échantillon au centre serait VACU : le carve structurel force la bouche à l'air.
+        // L'anneau latéral doit donc trouver de l'air dans la strate de destination elle-même.
+        constexpr int32 RingSampleCount = 16;
+        constexpr int32 MinimumAirSamples = 8;
+        const float RingRadius = PassageConfig.MouthRadius
+            + 2.0f * VoxelDensityReach::PassageBlend;
+
+        int32 AirSamples = 0;
+        for (int32 RingSample = 0; RingSample < RingSampleCount; ++RingSample)
+        {
+            const float Angle = 2.0f * PI * (float)RingSample / (float)RingSampleCount;
+            const float SampleX = Passage.LowerPoint.X + FMath::Cos(Angle) * RingRadius;
+            const float SampleY = Passage.LowerPoint.Y + FMath::Sin(Angle) * RingRadius;
+            const float Density = World.Generator->GetDensityAt(
+                SampleX,
+                SampleY,
+                Passage.LowerPoint.Z);
+
+            ++NumRingSamples;
+            if (Density >= 0.0f)
+            {
+                ++AirSamples;
+                ++NumRingAirSamples;
+            }
+        }
+
+        if (AirSamples < MinimumAirSamples)
+        {
+            bAllAnswerableMouthRingsHaveAir = false;
+            AddError(FString::Printf(
+                TEXT("Passage to strate %d (%s) has too little destination air around its mouth: %d/%d ring samples at radius %.3f are air; mouth (%.3f, %.3f, %.3f)."),
+                Destination.StrateIndex,
+                *ArchetypeName(Definition->GeneratorType),
+                AirSamples,
+                RingSampleCount,
+                RingRadius,
+                Passage.LowerPoint.X,
+                Passage.LowerPoint.Y,
+                Passage.LowerPoint.Z));
+        }
+    }
+
+    AddInfo(FString::Printf(
+        TEXT("Passage open-space check: %d inter-strate passages, %d checked, %d/%d ring samples air, %d query-false (%d unique archetypes; %d unsupported, %d supported-but-no-point)."),
+        NumInterStratePassages,
+        NumChecked,
+        NumRingAirSamples,
+        NumRingSamples,
+        NumQueryFalse,
+        FalseArchetypes.Num(),
+        NumUnsupported,
+        NumSupportedWithoutPoint));
+
+    // A test that inspected nothing is not evidence of the invariant. Fail loudly in both cases.
+    // Un test qui n'a rien inspecté ne prouve pas l'invariant : échouer explicitement dans les deux cas.
+    if (NumInterStratePassages == 0)
+    {
+        AddError(TEXT("VACUOUS: the fixture generated zero inter-strate passages."));
+    }
+    if (NumChecked == 0)
+    {
+        AddError(TEXT("VACUOUS: zero answerable passage mouths were checked; the passage invariant was not exercised."));
+    }
+
+    return NumInterStratePassages > 0
+        && NumChecked > 0
+        && bAllAnswerableMouthRingsHaveAir
+        && bAllAnswerableEndpointsMatchQuery;
+}
+
+#endif // WITH_DEV_AUTOMATION_TESTS

Source/VoxelForge/Private/VoxelCaveMorphology.cpp

@@ -30,6 +30,7 @@
 #include "VoxelCaveMorphology.h"
 #include "VoxelTypes.h"          // Pour VOXEL_NOISE_SCALE, SmoothStep01
 #include "VoxelStrateTypes.h"
+#include "VoxelNoise.h"           // Pure FBM used by the slab landing query
 #include "VoxelTerrainOpDefinition.h"
 
 //=============================================================================
@@ -87,6 +88,313 @@ static void BakeRoomFeature(
     }
 }
 
+namespace
+{
+    // Find the nearest hash room's vertical centre without constructing a cache. The search is
+    // deliberately bounded: an empty neighbourhood is an honest "no answer", not a guessed Z.
+    // Cherche le centre vertical de la salle hachée la plus proche sans construire de cache. La
+    // recherche est bornée : un voisinage vide signifie "pas de réponse", jamais un Z inventé.
+    bool VF_FindNearestHashRoomZ(
+        const FStrateGenerationParams& Params,
+        int32 Seed,
+        float StrateTopZ,
+        float StrateBottomZ,
+        float WorldX,
+        float WorldY,
+        float& OutZ)
+    {
+        if (!FMath::IsFinite(StrateTopZ) || !FMath::IsFinite(StrateBottomZ)
+            || !FMath::IsFinite(WorldX) || !FMath::IsFinite(WorldY)
+            || StrateTopZ <= StrateBottomZ)
+        {
+            return false;
+        }
+
+        const float CellSize = Params.RoomSpacing;
+        const float RadiusEnvelope = FMath::Max(Params.MinRoomRadius, Params.MaxRoomRadius);
+        if (!FMath::IsFinite(CellSize) || !FMath::IsFinite(Params.RoomDensity)
+            || !FMath::IsFinite(Params.MinRoomRadius) || !FMath::IsFinite(Params.MaxRoomRadius)
+            || !FMath::IsFinite(Params.RoomHeightRatio)
+            || !FMath::IsFinite(Params.BoundarySealThickness)
+            || !FMath::IsFinite(Params.MaxTunnelLength)
+            || CellSize <= 0.0f || Params.RoomDensity <= 0.0f
+            || Params.MaxTunnelLength <= 0.0f
+            || RadiusEnvelope <= 0.0f || Params.RoomHeightRatio <= 0.0f
+            || Params.BoundarySealThickness < 0.0f)
+        {
+            return false;
+        }
+
+        // PLACEMENT CONTRACT: this envelope MUST remain identical to the room-center placement
+        // code in VoxelCaveMorphology::BuildChunkCache below. The pure query deliberately does
+        // not call that per-chunk cache builder during Initialize, so this is intentionally a
+        // second copy.
+        // VoxelForge.Determinism.PassageLandsInOpenSpace is the fixed ring test that catches drift.
+        // The extra room-height buffer keeps the generated room body away from both seal bands.
+        const float RoomZBuffer = RadiusEnvelope * Params.RoomHeightRatio;
+        const float StrateMinZ = StrateBottomZ + Params.BoundarySealThickness + RoomZBuffer;
+        const float StrateMaxZ = StrateTopZ - Params.BoundarySealThickness - RoomZBuffer;
+        const float StrateRangeZ = StrateMaxZ - StrateMinZ;
+        if (!FMath::IsFinite(StrateRangeZ) || StrateRangeZ <= 0.0f)
+        {
+            return false;
+        }
+
+        // A passage is placed within the configured reach from the spine. Start the search a little
+        // farther than that reach, then expand deterministic rings until the nearest candidate is
+        // proven; cap pathological asset values so Initialize cannot become an unbounded grid scan.
+        const float SearchDistance = FMath::Max(CellSize * 2.0f,
+            FMath::Max(Params.MaxTunnelLength, 0.0f));
+        const float SearchCells = SearchDistance / CellSize;
+        const int32 InitialSearchRadius = FMath::Min(
+            32,
+            FMath::Max(2, FMath::CeilToInt(SearchCells) + 1));
+        constexpr int32 MaxSearchRadius = 32;
+
+        const int32 BaseCellX = FMath::FloorToInt(WorldX / CellSize);
+        const int32 BaseCellY = FMath::FloorToInt(WorldY / CellSize);
+
+        float BestDistSq = FLT_MAX;
+        float BestZ = 0.0f;
+        int32 BestCellX = 0;
+        int32 BestCellY = 0;
+        bool bFound = false;
+
+        auto ConsiderCell = [&](int32 CellX, int32 CellY)
+        {
+            // Keep this roll byte-for-byte aligned with BuildChunkCache's room placement.
+            const uint32 CellHash = VoxelHash::Cell(CellX, CellY, (uint32)Seed);
+            if (VoxelHash::ToFloat01(CellHash) >= Params.RoomDensity) return;
+
+            const float JitterX = VoxelHash::ToFloat01(VoxelHash::Mix(CellHash ^ 0x12345678u));
+            const float JitterY = VoxelHash::ToFloat01(VoxelHash::Mix(CellHash ^ 0x9ABCDEF0u));
+            const float JitterZ = VoxelHash::ToFloat01(VoxelHash::Mix(CellHash ^ 0x55AA55AAu));
+
+            const float RoomX = (CellX + 0.15f + JitterX * 0.7f) * CellSize;
+            const float RoomY = (CellY + 0.15f + JitterY * 0.7f) * CellSize;
+            const float RoomZ = StrateMinZ + JitterZ * FMath::Max(StrateRangeZ, 1.0f);
+            const float DX = RoomX - WorldX;
+            const float DY = RoomY - WorldY;
+            const float DistSq = DX * DX + DY * DY;
+
+            const bool bCloser = DistSq < BestDistSq;
+            const bool bTie = DistSq == BestDistSq
+                && (CellX < BestCellX || (CellX == BestCellX && CellY < BestCellY));
+            if (!bCloser && !bTie) return;
+
+            BestDistSq = DistSq;
+            BestZ = RoomZ;
+            BestCellX = CellX;
+            BestCellY = CellY;
+            bFound = true;
+        };
+
+        auto ScanRing = [&](int32 Radius)
+        {
+            for (int32 CellY = BaseCellY - Radius; CellY <= BaseCellY + Radius; ++CellY)
+            {
+                for (int32 CellX = BaseCellX - Radius; CellX <= BaseCellX + Radius; ++CellX)
+                {
+                    if (FMath::Max(FMath::Abs(CellX - BaseCellX), FMath::Abs(CellY - BaseCellY)) != Radius)
+                    {
+                        continue;
+                    }
+                    ConsiderCell(CellX, CellY);
+                }
+            }
+        };
+
+        // The nearest possible room centre in any cell outside this square is at least this far
+        // from the query point (the placement jitter is bounded to [0.15, 0.85] cell).
+        auto IsNearestProven = [&](int32 Radius)
+        {
+            if (!bFound) return false;
+            const float OutsideDistance = ((float)Radius + 0.15f) * CellSize;
+            return BestDistSq < OutsideDistance * OutsideDistance;
+        };
+
+        for (int32 CellY = BaseCellY - InitialSearchRadius;
+             CellY <= BaseCellY + InitialSearchRadius;
+             ++CellY)
+        {
+            for (int32 CellX = BaseCellX - InitialSearchRadius;
+                 CellX <= BaseCellX + InitialSearchRadius;
+                 ++CellX)
+            {
+                ConsiderCell(CellX, CellY);
+            }
+        }
+
+        bool bNearestProven = IsNearestProven(InitialSearchRadius);
+        for (int32 Radius = InitialSearchRadius + 1;
+             Radius <= MaxSearchRadius && !bNearestProven;
+             ++Radius)
+        {
+            ScanRing(Radius);
+            bNearestProven = IsNearestProven(Radius);
+        }
+
+        if (!bFound || !bNearestProven) return false;
+
+        // The placement envelope above normally makes this automatic. Keep the explicit check so
+        // malformed but finite parameters never turn a boundary value into an open-point claim.
+        const float InnerTop = StrateTopZ - Params.BoundarySealThickness;
+        const float InnerBottom = StrateBottomZ + Params.BoundarySealThickness;
+        if (!FMath::IsFinite(BestZ) || BestZ <= InnerBottom || BestZ >= InnerTop)
+        {
+            return false;
+        }
+
+        OutZ = BestZ;
+        return true;
+    }
+
+    // The slab source is an XY height band. Evaluate the same two pure height fields as
+    // GetSlabDensity, then choose their midpoint after intersecting the seal-free interior.
+    // La source slab est une bande de hauteurs XY : on recalcule les deux champs purs comme
+    // GetSlabDensity, puis on prend leur milieu après intersection avec l'intérieur sans seal.
+    bool VF_SuggestSlabOpenPointZ(
+        const FSlabGenerationParams& Params,
+        int32 Seed,
+        float StrateTopZ,
+        float StrateBottomZ,
+        float WorldX,
+        float WorldY,
+        float& OutZ)
+    {
+        if (!FMath::IsFinite(StrateTopZ) || !FMath::IsFinite(StrateBottomZ)
+            || !FMath::IsFinite(WorldX) || !FMath::IsFinite(WorldY)
+            || StrateTopZ <= StrateBottomZ)
+        {
+            return false;
+        }
+
+        if (!FMath::IsFinite(Params.FloorRelativeHeight)
+            || !FMath::IsFinite(Params.CeilingRelativeHeight)
+            || !FMath::IsFinite(Params.FloorRoughness)
+            || !FMath::IsFinite(Params.FloorRoughnessFrequency)
+            || !FMath::IsFinite(Params.CeilingRoughness)
+            || !FMath::IsFinite(Params.CeilingRoughnessFrequency)
+            || !FMath::IsFinite(Params.ColumnDensity)
+            || !FMath::IsFinite(Params.ColumnMinRadius)
+            || !FMath::IsFinite(Params.ColumnMaxRadius)
+            || !FMath::IsFinite(Params.ColumnSpacing)
+            || !FMath::IsFinite(Params.BoundarySealThickness)
+            || !FMath::IsFinite(Params.BaseDensity)
+            || Params.BoundarySealThickness < 0.0f)
+        {
+            return false;
+        }
+
+        const float StrateHeight = StrateTopZ - StrateBottomZ;
+        const uint32 SeedU = (uint32)Seed;
+
+        const float FloorZ = StrateBottomZ + StrateHeight * Params.FloorRelativeHeight;
+        float FloorNoise = 0.0f;
+        if (Params.FloorRoughness > 0.0f)
+        {
+            const float FF = Params.FloorRoughnessFrequency;
+            FloorNoise = VoxelNoise::FBM(
+                WorldX * FF + VoxelHash::SeedOffset(SeedU, 7.3f),
+                WorldY * FF + VoxelHash::SeedOffset(SeedU, 11.1f),
+                0.0f, 3
+            ) * VOXEL_NOISE_SCALE * Params.FloorRoughness;
+        }
+        const float FloorSurface = FloorZ + FloorNoise;
+
+        const float CeilZ = StrateBottomZ + StrateHeight * Params.CeilingRelativeHeight;
+        float CeilNoise = 0.0f;
+        if (Params.CeilingRoughness > 0.0f)
+        {
+            const float CF = Params.CeilingRoughnessFrequency;
+            const float RawNoise = VoxelNoise::FBM(
+                WorldX * CF + VoxelHash::SeedOffset(SeedU, 17.3f) + 1000.0f,
+                WorldY * CF + VoxelHash::SeedOffset(SeedU, 19.7f) + 2000.0f,
+                3000.0f, 3
+            ) * VOXEL_NOISE_SCALE;
+            CeilNoise = FMath::Abs(RawNoise) * Params.CeilingRoughness;
+        }
+        const float CeilSurface = FMath::Max(CeilZ - CeilNoise, FloorSurface + 2.0f);
+
+        // VF_ApplyBoundarySeal's bands are [Top-Thickness, Top) and
+        // (Bottom, Bottom+Thickness]. The midpoint below stays strictly inside both limits.
+        const float InnerTop = StrateTopZ - Params.BoundarySealThickness;
+        const float InnerBottom = StrateBottomZ + Params.BoundarySealThickness;
+        const float OpenBottom = FMath::Max(FloorSurface, InnerBottom);
+        const float OpenTop = FMath::Min(CeilSurface, InnerTop);
+        if (!FMath::IsFinite(OpenBottom) || !FMath::IsFinite(OpenTop) || OpenTop <= OpenBottom)
+        {
+            return false;
+        }
+
+        // Slab columns are infinite-height. If one reaches this XY, no Z in the slab void is a
+        // confident pre-passage landing point, so report "unanswerable" instead of guessing.
+        if (Params.ColumnDensity > 0.0f && Params.ColumnSpacing > 0.0f)
+        {
+            const float Spacing = Params.ColumnSpacing;
+            const int32 ColumnCellX = FMath::FloorToInt(WorldX / Spacing);
+            const int32 ColumnCellY = FMath::FloorToInt(WorldY / Spacing);
+
+            for (int32 DY = -1; DY <= 1; ++DY)
+            {
+                for (int32 DX = -1; DX <= 1; ++DX)
+                {
+                    const int32 CellX = ColumnCellX + DX;
+                    const int32 CellY = ColumnCellY + DY;
+                    const uint32 H = VoxelHash::Cell(CellX, CellY, SeedU ^ 0xC01C01u);
+                    if (VoxelHash::ToFloat01(H) > Params.ColumnDensity) continue;
+
+                    const float JX = VoxelHash::ToFloat01(VoxelHash::Mix(H ^ 0x12345678u));
+                    const float JY = VoxelHash::ToFloat01(VoxelHash::Mix(H ^ 0x9ABCDEF0u));
+                    const float ColumnX = (CellX + 0.15f + JX * 0.7f) * Spacing;
+                    const float ColumnY = (CellY + 0.15f + JY * 0.7f) * Spacing;
+                    const float Radius = FMath::Lerp(Params.ColumnMinRadius, Params.ColumnMaxRadius,
+                        VoxelHash::ToFloat01(VoxelHash::Mix(H ^ 0xBEEFu)));
+                    const float ColumnDX = WorldX - ColumnX;
+                    const float ColumnDY = WorldY - ColumnY;
+                    if (FMath::Sqrt(ColumnDX * ColumnDX + ColumnDY * ColumnDY) - Radius < 2.0f)
+                    {
+                        return false;
+                    }
+                }
+            }
+        }
+
+        OutZ = (OpenBottom + OpenTop) * 0.5f;
+        return FMath::IsFinite(OutZ);
+    }
+}
+
+bool VF_SuggestOpenPointZ(
+    ECaveGeneratorType Archetype,
+    const FStrateGenerationParams& CaveParams,
+    const FSlabGenerationParams& SlabParams,
+    int32 Seed,
+    float StrateTopZ,
+    float StrateBottomZ,
+    float WorldX,
+    float WorldY,
+    float& OutZ)
+{
+    switch (Archetype)
+    {
+    case ECaveGeneratorType::TunnelNetwork:
+    case ECaveGeneratorType::Underwater:
+        return VF_FindNearestHashRoomZ(CaveParams, Seed, StrateTopZ, StrateBottomZ,
+                                       WorldX, WorldY, OutZ);
+
+    case ECaveGeneratorType::FlatPlain:
+    case ECaveGeneratorType::CrystalChamber:
+        return VF_SuggestSlabOpenPointZ(SlabParams, Seed, StrateTopZ, StrateBottomZ,
+                                        WorldX, WorldY, OutZ);
+
+    default:
+        // No confident source-level answer for Maze, SurfaceWorld, shafts, or islands yet.
+        // Pas de réponse source sûre pour Maze, SurfaceWorld, shafts ou islands pour le moment.
+        return false;
+    }
+}
+
 //=============================================================================
 // PHASE 1: BUILD CHUNK CACHE
 //=============================================================================
@@ -113,7 +421,7 @@ void VoxelCaveMorphology::BuildChunkCache(
     OutCache.Columns.Reset();
 
     // Combine world seed with strate index so each strate gets unique caves
-    const uint32 StrateSeed = VoxelHash::Mix(Seed ^ (uint32)(StrateIndex * 7919 + 104729));
+    const uint32 StrateSeed = VoxelCaveMorphology::MakeStrateSeed(Seed, StrateIndex);
 
     const float CellSize = Params.RoomSpacing;
     if (CellSize <= 0.0f) return;
@@ -167,6 +475,11 @@ void VoxelCaveMorphology::BuildChunkCache(
 
     //=========================================================================
     // Vertical range for room CENTER placement.
+    // PLACEMENT CONTRACT: this formula MUST remain identical to
+    // VF_FindNearestHashRoomZ above. The pure landing query deliberately does not call this
+    // per-chunk cache builder during Initialize, so the fixed
+    // VoxelForge.Determinism.PassageLandsInOpenSpace ring test is the guard that catches drift
+    // between the two sites.
     //=========================================================================
     // Buffer = seal thickness + max room half-height.
     // This guarantees the tallest possible room (RoomRadiusEnvelope * RoomHeightRatio)

Source/VoxelForge/Private/VoxelStrateManager.cpp

@@ -266,6 +266,19 @@ void UVoxelStrateManager::GeneratePassages()
     constexpr uint32 PassageSaltPhase      = 0xA1100009u;
     constexpr uint32 PassageSaltBendFreq   = 0xA110000Au;
 
+    int32 TotalPassages = 0;
+    int32 NumAimedAtOpenPoint = 0;
+    TSet<FString> NoQueryArchetypes;
+
+    const auto ArchetypeName = [](ECaveGeneratorType Archetype)
+    {
+        if (const UEnum* ArchetypeEnum = StaticEnum<ECaveGeneratorType>())
+        {
+            return ArchetypeEnum->GetNameStringByValue(static_cast<int64>(Archetype));
+        }
+        return FString::Printf(TEXT("Value_%d"), static_cast<int32>(Archetype));
+    };
+
     //=========================================================================
     // INTER-STRATE PASSAGES: tunnels connecting consecutive strates.
     // Each passage is randomly assigned one of 5 types, which determines
@@ -317,13 +330,92 @@ void UVoxelStrateManager::GeneratePassages()
             const float PX = FMath::Cos(Angle) * Distance;
             const float PY = FMath::Sin(Angle) * Distance;
 
+            ++TotalPassages;
+
+            // Ask the destination archetype for a source-level open Z at this XY. This is pure
+            // and safe during Initialize: it does not construct an operator stack or call back
+            // into the manager. Cave room graphs use the same strate seed as BuildChunkCache;
+            // slab fields use the world seed consumed by GetSlabDensity.
+            float SuggestedLowerZ = 0.0f;
+            bool bAimedAtOpenPoint = false;
+            const UVoxelStrateDefinition* LowerDef = Lower.Definition;
+            if (LowerDef)
+            {
+                const bool bUsesRoomSeed =
+                    LowerDef->GeneratorType == ECaveGeneratorType::TunnelNetwork
+                    || LowerDef->GeneratorType == ECaveGeneratorType::Underwater;
+                const int32 LowerQuerySeed = bUsesRoomSeed
+                    ? static_cast<int32>(VoxelCaveMorphology::MakeStrateSeed(
+                        static_cast<uint32>(CachedSeed), Lower.StrateIndex))
+                    : CachedSeed;
+
+                bAimedAtOpenPoint = VF_SuggestOpenPointZ(
+                    LowerDef->GeneratorType,
+                    LowerDef->GenerationParams,
+                    LowerDef->SlabParams,
+                    LowerQuerySeed,
+                    LowerTopZ,
+                    (float)(Lower.BottomChunkZ) * CHUNK_SIZE,
+                    PX,
+                    PY,
+                    SuggestedLowerZ);
+
+                if (bAimedAtOpenPoint)
+                {
+                    ++NumAimedAtOpenPoint;
+                }
+                else
+                {
+                    NoQueryArchetypes.Add(ArchetypeName(LowerDef->GeneratorType));
+                }
+            }
+
             // LENGTH: reach into each strate, capped to the interior.
             const float UpperReach = FMath::Min(
                 PassageRandomRange(Cfg.ReachMin, Cfg.ReachMax, PassageSaltUpperReach), UpperMax);
             const float LowerReach = FMath::Min(
                 PassageRandomRange(Cfg.ReachMin, Cfg.ReachMax, PassageSaltLowerReach), LowerMax);
             const float TopZ = UpperBottomZ + UpperReach;
-            const float BottomZ = LowerTopZ - LowerReach;
+            float BottomZ = LowerTopZ - LowerReach;
+
+            if (bAimedAtOpenPoint)
+            {
+                float LowerSealThickness = 0.0f;
+                switch (LowerDef->GeneratorType)
+                {
+                case ECaveGeneratorType::TunnelNetwork:
+                case ECaveGeneratorType::Underwater:
+                    LowerSealThickness = LowerDef->GenerationParams.BoundarySealThickness;
+                    break;
+
+                case ECaveGeneratorType::FlatPlain:
+                case ECaveGeneratorType::CrystalChamber:
+                    LowerSealThickness = LowerDef->SlabParams.BoundarySealThickness;
+                    break;
+
+                default:
+                    break;
+                }
+
+                const float LowerBottomZ = (float)(Lower.BottomChunkZ) * CHUNK_SIZE;
+                const float InnerBottomZ = LowerBottomZ + LowerSealThickness;
+                const float InnerTopZ = LowerTopZ - LowerSealThickness;
+                if (FMath::IsFinite(SuggestedLowerZ)
+                    && FMath::IsFinite(InnerBottomZ)
+                    && FMath::IsFinite(InnerTopZ)
+                    && InnerBottomZ < InnerTopZ)
+                {
+                    // VF_SuggestOpenPointZ already guarantees a strict interior answer. Keep a
+                    // tiny margin in the final clamp so a future source query cannot land on a
+                    // seal boundary through rounding.
+                    const float StrictMargin = FMath::Min(
+                        KINDA_SMALL_NUMBER, (InnerTopZ - InnerBottomZ) * 0.25f);
+                    BottomZ = FMath::Clamp(
+                        SuggestedLowerZ,
+                        InnerBottomZ + StrictMargin,
+                        InnerTopZ - StrictMargin);
+                }
+            }
 
             const int32 Segments = FMath::Clamp(Cfg.Segments, 1, 48);
             Passage.ControlPoints.Reset();
@@ -422,6 +514,25 @@ void UVoxelStrateManager::GeneratePassages()
         }
     }
 
+    TArray<FString> SortedNoQueryArchetypes;
+    for (const FString& Archetype : NoQueryArchetypes)
+    {
+        SortedNoQueryArchetypes.Add(Archetype);
+    }
+    SortedNoQueryArchetypes.Sort();
+    FString NoQueryList = TEXT("none");
+    if (SortedNoQueryArchetypes.Num() > 0)
+    {
+        NoQueryList = FString::Join(SortedNoQueryArchetypes, TEXT(", "));
+    }
+
+    UE_LOG(LogTemp, Log,
+        TEXT("[StrateManager] Passage landing sites: %d/%d aimed at generator-confirmed open space, %d fell back to random reach (archetypes with no query: %s)."),
+        NumAimedAtOpenPoint,
+        TotalPassages,
+        TotalPassages - NumAimedAtOpenPoint,
+        *NoQueryList);
+
     //=========================================================================
     // SURFACE ENTRY SHAFT — the one auto-opened (0,0) connection.
     // A straight vertical shaft at (0,0) piercing the TOP seal of the topmost

Source/VoxelForge/Public/VoxelCaveMorphology.h

@@ -33,8 +33,10 @@
 
 // Forward declarations
 struct FStrateGenerationParams;
+struct FSlabGenerationParams;
 struct FStrateTerrainOpEntry;
 class UVoxelTerrainOpDefinition;
+enum class ECaveGeneratorType : uint8;
 
 //=============================================================================
 // SDF PRIMITIVES
@@ -468,6 +470,15 @@ struct FChunkSDFCache
 
 namespace VoxelCaveMorphology
 {
+    // The room graph's seed is the world seed salted by the strate index. Keep this formula
+    // shared by BuildChunkCache and landing-site queries so a query cannot inspect another
+    // strate's room layout. / La seed du graphe des salles est la seed monde salée par l'index
+    // de strate. La formule est partagée entre BuildChunkCache et les requêtes d'atterrissage.
+    FORCEINLINE uint32 MakeStrateSeed(uint32 WorldSeed, int32 StrateIndex)
+    {
+        return VoxelHash::Mix(WorldSeed ^ (uint32)(StrateIndex * 7919 + 104729));
+    }
+
     // PHASE 1: Build the SDF cache for a rectangular region.
     // Collects all rooms, computes nearest-neighbor backbone, decides tunnel
     // connections, and pre-computes all tunnel geometry (radii, offsets, midpoints).
@@ -523,3 +534,30 @@ namespace VoxelCaveMorphology
         uint32 Seed, int32 StrateIndex
     );
 }
+
+/**
+ * Suggest a deterministic open-space Z for an inter-strate passage mouth.
+ *
+ * This is deliberately a pure source query: it does not touch a generator, an operator stack,
+ * a strate manager, a cache, or mutable state. For TunnelNetwork/Underwater, Seed must be the
+ * strate-specific room seed returned by VoxelCaveMorphology::MakeStrateSeed; for slab archetypes,
+ * Seed is the generator world seed used by GetSlabDensity.
+ *
+ * Propose un Z d'espace ouvert déterministe pour la bouche d'un passage inter-strates. Cette
+ * requête ne touche ni générateur, ni pile d'opérateurs, ni StrateManager, ni cache, ni état
+ * mutable. Pour TunnelNetwork/Underwater, Seed est la seed de salles de la strate; pour les
+ * archétypes slab, c'est la seed monde utilisée par GetSlabDensity.
+ *
+ * @return true when the archetype can provide a confident point; false when it cannot.
+ */
+VOXELFORGE_API bool VF_SuggestOpenPointZ(
+    ECaveGeneratorType Archetype,
+    const FStrateGenerationParams& CaveParams,
+    const FSlabGenerationParams& SlabParams,
+    int32 Seed,
+    float StrateTopZ,
+    float StrateBottomZ,
+    float WorldX,
+    float WorldY,
+    float& OutZ
+);