d

adapters/bukkit/nms/v26_2_R1/src/main/java/art/arcane/iris/core/nms/v26_2_R1/CustomBiomeSource.java

@@ -5,9 +5,12 @@ import com.mojang.serialization.MapCodec;
 import art.arcane.iris.spi.IrisLogging;
 import art.arcane.iris.engine.data.cache.AtomicCache;
 import art.arcane.iris.engine.framework.Engine;
+import art.arcane.iris.engine.framework.GenerationSessionException;
+import art.arcane.iris.engine.framework.GenerationSessionLease;
 import art.arcane.iris.engine.object.IrisBiome;
 import art.arcane.iris.engine.object.IrisBiomeCustom;
 import art.arcane.iris.engine.object.IrisDimension;
+import art.arcane.iris.util.project.context.IrisContext;
 import art.arcane.volmlib.util.collection.KMap;
 import art.arcane.volmlib.util.math.RNG;
 import net.minecraft.core.Holder;
@@ -148,17 +151,26 @@ public class CustomBiomeSource extends BiomeSource {
     }
 
     Set<Holder<Biome>> possibleStructureBiomes() {
-        ensureCachesCurrent();
-        World world = BukkitWorldBinding.world(engine.getWorld());
-        if (world == null) {
-            throw new IllegalStateException("Iris biome source has no bound Bukkit world");
+        GenerationSessionLease lease = tryAcquireGenerationLease("bukkit_possible_biomes");
+        if (lease == null) {
+            throw new IllegalStateException("Iris possible biome lookup was rejected during an engine transition");
+        }
+        try (lease; IrisContext.Scope ignored = IrisContext.open(engine, lease.sessionId(), null)) {
+            if (!isRuntimeAvailable()) {
+                throw new IllegalStateException("Iris possible biome lookup has no active engine runtime");
+            }
+            ensureCachesCurrent();
+            World world = BukkitWorldBinding.world(engine.getWorld());
+            if (world == null) {
+                throw new IllegalStateException("Iris biome source has no bound Bukkit world");
+            }
+            Registry<Biome> customRegistry = ((RegistryAccess) getFor(
+                    RegistryAccess.Frozen.class, ((CraftServer) Bukkit.getServer()).getHandle().getServer()))
+                    .lookup(Registries.BIOME).orElse(null);
+            Registry<Biome> worldRegistry = ((CraftWorld) world).getHandle().registryAccess()
+                    .lookup(Registries.BIOME).orElse(null);
+            return Set.copyOf(getAllBiomes(customRegistry, worldRegistry, engine));
         }
-        Registry<Biome> customRegistry = ((RegistryAccess) getFor(
-                RegistryAccess.Frozen.class, ((CraftServer) Bukkit.getServer()).getHandle().getServer()))
-                .lookup(Registries.BIOME).orElse(null);
-        Registry<Biome> worldRegistry = ((CraftWorld) world).getHandle().registryAccess()
-                .lookup(Registries.BIOME).orElse(null);
-        return Set.copyOf(getAllBiomes(customRegistry, worldRegistry, engine));
     }
 
     private KMap<String, Holder<Biome>> fillCustomBiomes(Registry<Biome> customRegistry, Engine engine, Holder<Biome> fallback) {
@@ -212,11 +224,20 @@ public class CustomBiomeSource extends BiomeSource {
     }
 
     Holder<Biome> getVanillaSpawnBiome(Holder<Biome> biome) {
-        ensureCachesCurrent();
         if (biome == null) {
             return null;
         }
-        return vanillaSpawnBiomes.get(biome.value());
+        GenerationSessionLease lease = tryAcquireGenerationLease("bukkit_spawn_biome");
+        if (lease == null) {
+            throw new IllegalStateException("Iris spawn biome lookup was rejected during an engine transition");
+        }
+        try (lease; IrisContext.Scope ignored = IrisContext.open(engine, lease.sessionId(), null)) {
+            if (!isRuntimeAvailable()) {
+                throw new IllegalStateException("Iris spawn biome lookup has no active engine runtime");
+            }
+            ensureCachesCurrent();
+            return vanillaSpawnBiomes.get(biome.value());
+        }
     }
 
     private RegistryAccess registry() {
@@ -230,51 +251,69 @@ public class CustomBiomeSource extends BiomeSource {
 
     @Override
     public Holder<Biome> getNoiseBiome(int x, int y, int z, Climate.Sampler sampler) {
-        ensureCachesCurrent();
-        if (isGuaranteedSurfaceBiome(y)) {
-            return getSurfaceStructureBiomeHolder(x, z);
+        GenerationSessionLease lease = tryAcquireGenerationLease("bukkit_structure_biome");
+        if (lease == null) {
+            throw new IllegalStateException("Iris structure biome lookup was rejected during an engine transition");
         }
+        try (lease; IrisContext.Scope ignored = IrisContext.open(engine, lease.sessionId(), null)) {
+            if (!isRuntimeAvailable()) {
+                throw new IllegalStateException("Iris structure biome lookup has no active engine runtime");
+            }
+            ensureCachesCurrent();
+            if (isGuaranteedSurfaceBiome(y)) {
+                return getSurfaceStructureBiomeHolder(x, z);
+            }
 
-        long cacheKey = packNoiseKey(x, y, z);
-        Holder<Biome> cachedHolder = structureBiomeCache.get(cacheKey);
-        if (cachedHolder != null) {
-            return cachedHolder;
+            long cacheKey = packNoiseKey(x, y, z);
+            Holder<Biome> cachedHolder = structureBiomeCache.get(cacheKey);
+            if (cachedHolder != null) {
+                return cachedHolder;
+            }
+
+            Holder<Biome> resolvedHolder = resolveStructureBiomeHolder(x, y, z);
+            Holder<Biome> existingHolder = structureBiomeCache.putIfAbsent(cacheKey, resolvedHolder);
+            if (existingHolder != null) {
+                return existingHolder;
+            }
+
+            if (structureBiomeCache.size() > NOISE_BIOME_CACHE_MAX) {
+                structureBiomeCache.clear();
+            }
+
+            return resolvedHolder;
         }
-
-        Holder<Biome> resolvedHolder = resolveStructureBiomeHolder(x, y, z);
-        Holder<Biome> existingHolder = structureBiomeCache.putIfAbsent(cacheKey, resolvedHolder);
-        if (existingHolder != null) {
-            return existingHolder;
-        }
-
-        if (structureBiomeCache.size() > NOISE_BIOME_CACHE_MAX) {
-            structureBiomeCache.clear();
-        }
-
-        return resolvedHolder;
     }
 
     @Override
     public Set<Holder<Biome>> getBiomesWithin(int x, int y, int z, int radius, Climate.Sampler sampler) {
-        ensureCachesCurrent();
-        int minQuartY = QuartPos.fromBlock(y - radius);
-        boolean monumentQuery = radius == 29
-                && y == engine.getMinHeight() + engine.getDimension().getFluidHeight();
-        if (!monumentQuery && !isGuaranteedSurfaceBiome(minQuartY)) {
-            return super.getBiomesWithin(x, y, z, radius, sampler);
+        GenerationSessionLease lease = tryAcquireGenerationLease("bukkit_biomes_within");
+        if (lease == null) {
+            throw new IllegalStateException("Iris biome radius lookup was rejected during an engine transition");
         }
-        int minQuartX = QuartPos.fromBlock(x - radius);
-        int maxQuartX = QuartPos.fromBlock(x + radius);
-        int minQuartZ = QuartPos.fromBlock(z - radius);
-        int maxQuartZ = QuartPos.fromBlock(z + radius);
-        int columns = (maxQuartX - minQuartX + 1) * (maxQuartZ - minQuartZ + 1);
-        Set<Holder<Biome>> biomes = new HashSet<>(columns);
-        for (int quartZ = minQuartZ; quartZ <= maxQuartZ; quartZ++) {
-            for (int quartX = minQuartX; quartX <= maxQuartX; quartX++) {
-                biomes.add(getSurfaceStructureBiomeHolder(quartX, quartZ));
+        try (lease; IrisContext.Scope ignored = IrisContext.open(engine, lease.sessionId(), null)) {
+            if (!isRuntimeAvailable()) {
+                throw new IllegalStateException("Iris biome radius lookup has no active engine runtime");
             }
+            ensureCachesCurrent();
+            int minQuartY = QuartPos.fromBlock(y - radius);
+            boolean monumentQuery = radius == 29
+                    && y == engine.getMinHeight() + engine.getDimension().getFluidHeight();
+            if (!monumentQuery && !isGuaranteedSurfaceBiome(minQuartY)) {
+                return super.getBiomesWithin(x, y, z, radius, sampler);
+            }
+            int minQuartX = QuartPos.fromBlock(x - radius);
+            int maxQuartX = QuartPos.fromBlock(x + radius);
+            int minQuartZ = QuartPos.fromBlock(z - radius);
+            int maxQuartZ = QuartPos.fromBlock(z + radius);
+            int columns = (maxQuartX - minQuartX + 1) * (maxQuartZ - minQuartZ + 1);
+            Set<Holder<Biome>> biomes = new HashSet<>(columns);
+            for (int quartZ = minQuartZ; quartZ <= maxQuartZ; quartZ++) {
+                for (int quartX = minQuartX; quartX <= maxQuartX; quartX++) {
+                    biomes.add(getSurfaceStructureBiomeHolder(quartX, quartZ));
+                }
+            }
+            return biomes;
         }
-        return biomes;
     }
 
     private Holder<Biome> getSurfaceStructureBiomeHolder(int x, int z) {
@@ -322,24 +361,52 @@ public class CustomBiomeSource extends BiomeSource {
     }
 
     public Holder<Biome> getVisibleNoiseBiome(int x, int y, int z, Climate.Sampler sampler) {
-        ensureCachesCurrent();
-        long cacheKey = packNoiseKey(x, y, z);
-        Holder<Biome> cachedHolder = noiseBiomeCache.get(cacheKey);
-        if (cachedHolder != null) {
-            return cachedHolder;
+        GenerationSessionLease lease = tryAcquireGenerationLease("bukkit_visible_biome");
+        if (lease == null) {
+            throw new IllegalStateException("Iris visible biome lookup was rejected during an engine transition");
         }
+        try (lease; IrisContext.Scope ignored = IrisContext.open(engine, lease.sessionId(), null)) {
+            if (!isRuntimeAvailable()) {
+                throw new IllegalStateException("Iris visible biome lookup has no active engine runtime");
+            }
+            ensureCachesCurrent();
+            long cacheKey = packNoiseKey(x, y, z);
+            Holder<Biome> cachedHolder = noiseBiomeCache.get(cacheKey);
+            if (cachedHolder != null) {
+                return cachedHolder;
+            }
 
-        Holder<Biome> resolvedHolder = resolveVisibleBiomeHolder(x, y, z);
-        Holder<Biome> existingHolder = noiseBiomeCache.putIfAbsent(cacheKey, resolvedHolder);
-        if (existingHolder != null) {
-            return existingHolder;
+            Holder<Biome> resolvedHolder = resolveVisibleBiomeHolder(x, y, z);
+            Holder<Biome> existingHolder = noiseBiomeCache.putIfAbsent(cacheKey, resolvedHolder);
+            if (existingHolder != null) {
+                return existingHolder;
+            }
+
+            if (noiseBiomeCache.size() > NOISE_BIOME_CACHE_MAX) {
+                noiseBiomeCache.clear();
+            }
+
+            return resolvedHolder;
         }
+    }
 
-        if (noiseBiomeCache.size() > NOISE_BIOME_CACHE_MAX) {
-            noiseBiomeCache.clear();
+    private GenerationSessionLease tryAcquireGenerationLease(String operation) {
+        if (engine.isClosed()) {
+            return null;
         }
+        try {
+            return engine.acquireGenerationLease(operation);
+        } catch (GenerationSessionException e) {
+            if (engine.isClosing() || e.isExpectedTeardown()) {
+                return null;
+            }
+            throw new IllegalStateException("Iris biome source could not acquire generation session for "
+                    + operation + ".", e);
+        }
+    }
 
-        return resolvedHolder;
+    private boolean isRuntimeAvailable() {
+        return !engine.isClosed() && engine.getComplex() != null;
     }
 
     private void ensureCachesCurrent() {

adapters/bukkit/nms/v26_2_R1/src/main/java/art/arcane/iris/core/nms/v26_2_R1/IrisChunkGenerator.java

@@ -1,6 +1,8 @@
 package art.arcane.iris.core.nms.v26_2_R1;
 
 import art.arcane.iris.engine.framework.Engine;
+import art.arcane.iris.engine.framework.GenerationSessionException;
+import art.arcane.iris.engine.framework.GenerationSessionLease;
 import art.arcane.iris.engine.framework.IrisStructureLocator;
 import art.arcane.iris.engine.framework.NativeStructureGenerationPolicy;
 import art.arcane.iris.engine.object.IrisDimension;
@@ -14,6 +16,7 @@ import art.arcane.iris.spi.PlatformBlockState;
 import art.arcane.iris.util.common.data.IrisCustomData;
 import art.arcane.iris.util.common.reflect.WrappedField;
 import art.arcane.iris.util.common.reflect.WrappedReturningMethod;
+import art.arcane.iris.util.project.context.IrisContext;
 import art.arcane.volmlib.util.math.RNG;
 import com.mojang.datafixers.util.Pair;
 import com.mojang.serialization.MapCodec;
@@ -90,6 +93,7 @@ public class IrisChunkGenerator extends CustomChunkGenerator {
     private final CustomBiomeSource customBiomeSource;
     private final int runtimeMinY;
     private final int runtimeHeight;
+    private final int runtimeSeaLevel;
     private final ConcurrentHashMap<SpawnTableKey, WeightedList<MobSpawnSettings.SpawnerData>> mergedSpawnTables = new ConcurrentHashMap<>();
     private volatile ReachableStructureCache reachableStructureCache;
     private volatile StructureStepCache structureStepCache;
@@ -106,17 +110,21 @@ public class IrisChunkGenerator extends CustomChunkGenerator {
         ServerLevel level = ((CraftWorld) world).getHandle();
         this.runtimeMinY = level.getMinY();
         this.runtimeHeight = level.getHeight();
+        this.runtimeSeaLevel = runtimeMinY + engine.getDimension().getFluidHeight();
     }
 
     @Override
     public @Nullable Pair<BlockPos, Holder<Structure>> findNearestMapStructure(ServerLevel level, HolderSet<Structure> holders, BlockPos pos, int radius, boolean findUnexplored) {
-        Pair<BlockPos, Holder<Structure>> irisPlaced = findNearestIrisStructure(
-                level, holders, pos, Math.max(1, radius), findUnexplored);
-        HolderSet<Structure> reachable = filterReachableStructures(level, holders);
-        Pair<BlockPos, Holder<Structure>> nativeLocated = reachable == null || reachable.size() == 0
-                ? null
-                : delegate.findNearestMapStructure(level, reachable, pos, radius, findUnexplored);
-        return NativeStructureLocateResults.nearest(pos, irisPlaced, nativeLocated);
+        try (GenerationSessionLease lease = requireGenerationLease("bukkit_nms_structure_locate");
+             IrisContext.Scope ignored = IrisContext.open(engine, lease.sessionId(), null)) {
+            Pair<BlockPos, Holder<Structure>> irisPlaced = findNearestIrisStructure(
+                    level, holders, pos, Math.max(1, radius), findUnexplored);
+            HolderSet<Structure> reachable = filterReachableStructures(level, holders);
+            Pair<BlockPos, Holder<Structure>> nativeLocated = reachable == null || reachable.size() == 0
+                    ? null
+                    : delegate.findNearestMapStructure(level, reachable, pos, radius, findUnexplored);
+            return NativeStructureLocateResults.nearest(pos, irisPlaced, nativeLocated);
+        }
     }
 
     private Pair<BlockPos, Holder<Structure>> findNearestIrisStructure(ServerLevel level,
@@ -231,14 +239,17 @@ public class IrisChunkGenerator extends CustomChunkGenerator {
 
     @Override
     public int getSeaLevel() {
-        return runtimeMinY + engine.getDimension().getFluidHeight();
+        return runtimeSeaLevel;
     }
 
     @Override
     public void createStructures(RegistryAccess registryAccess, ChunkGeneratorStructureState structureState, StructureManager structureManager, ChunkAccess access, StructureTemplateManager templateManager, ResourceKey<Level> levelKey) {
-        Map<Structure, StructureStart> previousStarts = new HashMap<>(access.getAllStarts());
-        super.createStructures(registryAccess, structureState, structureManager, access, templateManager, levelKey);
-        adjustGeneratedStructures(registryAccess, access, previousStarts);
+        try (GenerationSessionLease lease = requireGenerationLease("bukkit_nms_create_structures");
+             IrisContext.Scope ignored = IrisContext.open(engine, lease.sessionId(), null)) {
+            Map<Structure, StructureStart> previousStarts = new HashMap<>(access.getAllStarts());
+            super.createStructures(registryAccess, structureState, structureManager, access, templateManager, levelKey);
+            adjustGeneratedStructures(registryAccess, access, previousStarts);
+        }
     }
 
     private void adjustGeneratedStructures(RegistryAccess registryAccess, ChunkAccess access, Map<Structure, StructureStart> previousStarts) {
@@ -298,8 +309,11 @@ public class IrisChunkGenerator extends CustomChunkGenerator {
 
     @Override
     public CompletableFuture<ChunkAccess> createBiomes(RandomState randomstate, Blender blender, StructureManager structuremanager, ChunkAccess ichunkaccess) {
-        ichunkaccess.fillBiomesFromNoise(customBiomeSource::getVisibleNoiseBiome, randomstate.sampler());
-        return CompletableFuture.completedFuture(ichunkaccess);
+        try (GenerationSessionLease lease = requireGenerationLease("bukkit_nms_create_biomes");
+             IrisContext.Scope ignored = IrisContext.open(engine, lease.sessionId(), null)) {
+            ichunkaccess.fillBiomesFromNoise(customBiomeSource::getVisibleNoiseBiome, randomstate.sampler());
+            return CompletableFuture.completedFuture(ichunkaccess);
+        }
     }
 
     @Override
@@ -355,9 +369,12 @@ public class IrisChunkGenerator extends CustomChunkGenerator {
 
     @Override
     public void applyBiomeDecoration(WorldGenLevel generatoraccessseed, ChunkAccess ichunkaccess, StructureManager structuremanager, boolean vanilla) {
-        addVanillaDecorations(generatoraccessseed, ichunkaccess, structuremanager);
-        placeVanillaStructures(generatoraccessseed, ichunkaccess, structuremanager);
-        delegate.applyBiomeDecoration(generatoraccessseed, ichunkaccess, structuremanager, false);
+        try (GenerationSessionLease lease = requireGenerationLease("bukkit_nms_biome_decoration");
+             IrisContext.Scope ignored = IrisContext.open(engine, lease.sessionId(), null)) {
+            addVanillaDecorations(generatoraccessseed, ichunkaccess, structuremanager);
+            placeVanillaStructures(generatoraccessseed, ichunkaccess, structuremanager);
+            delegate.applyBiomeDecoration(generatoraccessseed, ichunkaccess, structuremanager, false);
+        }
     }
 
     private void placeVanillaStructures(WorldGenLevel world, ChunkAccess chunk, StructureManager structureManager) {
@@ -525,29 +542,35 @@ public class IrisChunkGenerator extends CustomChunkGenerator {
 
     @Override
     public void addVanillaDecorations(WorldGenLevel level, ChunkAccess chunkAccess, StructureManager structureManager) {
-        SectionPos sectionPos = SectionPos.of(chunkAccess.getPos(), level.getMinSectionY());
-        BlockPos blockPos = sectionPos.origin();
+        try (GenerationSessionLease lease = engine.acquireGenerationLease("bukkit_nms_heightmaps");
+             IrisContext.Scope ignored = IrisContext.open(engine, lease.sessionId(), null)) {
+            SectionPos sectionPos = SectionPos.of(chunkAccess.getPos(), level.getMinSectionY());
+            BlockPos blockPos = sectionPos.origin();
 
-        Heightmap surface = chunkAccess.getOrCreateHeightmapUnprimed(Heightmap.Types.WORLD_SURFACE_WG);
-        Heightmap ocean = chunkAccess.getOrCreateHeightmapUnprimed(Heightmap.Types.OCEAN_FLOOR_WG);
-        Heightmap motion = chunkAccess.getOrCreateHeightmapUnprimed(Heightmap.Types.MOTION_BLOCKING);
-        Heightmap motionNoLeaves = chunkAccess.getOrCreateHeightmapUnprimed(Heightmap.Types.MOTION_BLOCKING_NO_LEAVES);
+            Heightmap surface = chunkAccess.getOrCreateHeightmapUnprimed(Heightmap.Types.WORLD_SURFACE_WG);
+            Heightmap ocean = chunkAccess.getOrCreateHeightmapUnprimed(Heightmap.Types.OCEAN_FLOOR_WG);
+            Heightmap motion = chunkAccess.getOrCreateHeightmapUnprimed(Heightmap.Types.MOTION_BLOCKING);
+            Heightmap motionNoLeaves = chunkAccess.getOrCreateHeightmapUnprimed(Heightmap.Types.MOTION_BLOCKING_NO_LEAVES);
+            int minHeight = engine.getMinHeight();
 
-        for (int x = 0; x < 16; x++) {
-            for (int z = 0; z < 16; z++) {
-                int wX = x + blockPos.getX();
-                int wZ = z + blockPos.getZ();
+            for (int x = 0; x < 16; x++) {
+                for (int z = 0; z < 16; z++) {
+                    int wX = x + blockPos.getX();
+                    int wZ = z + blockPos.getZ();
 
-                int terrainTop = engine.getHeight(wX, wZ, false) + engine.getMinHeight() + 1;
-                int terrainNoFluid = engine.getHeight(wX, wZ, true) + engine.getMinHeight() + 1;
-                SET_HEIGHT.invoke(ocean, x, z, terrainNoFluid);
-                SET_HEIGHT.invoke(surface, x, z, terrainTop);
-                SET_HEIGHT.invoke(motion, x, z, terrainTop);
-                SET_HEIGHT.invoke(motionNoLeaves, x, z, terrainTop);
+                    int terrainTop = engine.getHeight(wX, wZ, false) + minHeight + 1;
+                    int terrainNoFluid = engine.getHeight(wX, wZ, true) + minHeight + 1;
+                    SET_HEIGHT.invoke(ocean, x, z, terrainNoFluid);
+                    SET_HEIGHT.invoke(surface, x, z, terrainTop);
+                    SET_HEIGHT.invoke(motion, x, z, terrainTop);
+                    SET_HEIGHT.invoke(motionNoLeaves, x, z, terrainTop);
+                }
             }
-        }
 
-        Heightmap.primeHeightmaps(chunkAccess, ChunkStatus.FINAL_HEIGHTMAPS);
+            Heightmap.primeHeightmaps(chunkAccess, ChunkStatus.FINAL_HEIGHTMAPS);
+        } catch (GenerationSessionException e) {
+            throw new IllegalStateException("Iris heightmap generation could not acquire its engine runtime.", e);
+        }
     }
 
     @Override
@@ -585,20 +608,44 @@ public class IrisChunkGenerator extends CustomChunkGenerator {
 
     @Override
     public int getBaseHeight(int i, int j, Heightmap.Types heightmap_type, LevelHeightAccessor levelheightaccessor, RandomState randomstate) {
-        return levelheightaccessor.getMinY() + engine.getHeight(i, j, !heightmap_type.isOpaque().test(Blocks.WATER.defaultBlockState())) + 1;
+        try (GenerationSessionLease lease = engine.acquireGenerationLease("bukkit_nms_base_height");
+             IrisContext.Scope ignored = IrisContext.open(engine, lease.sessionId(), null)) {
+            return levelheightaccessor.getMinY()
+                    + engine.getHeight(i, j, !heightmap_type.isOpaque().test(Blocks.WATER.defaultBlockState()))
+                    + 1;
+        } catch (GenerationSessionException e) {
+            throw new IllegalStateException("Iris base height query could not acquire its engine runtime.", e);
+        }
     }
 
     @Override
     public NoiseColumn getBaseColumn(int i, int j, LevelHeightAccessor levelheightaccessor, RandomState randomstate) {
-        int block = engine.getHeight(i, j, true);
-        int water = engine.getHeight(i, j, false);
-        BlockState[] column = new BlockState[levelheightaccessor.getHeight()];
-        for (int k = 0; k < column.length; k++) {
-            if (k <= block) column[k] = Blocks.STONE.defaultBlockState();
-            else if (k <= water) column[k] = Blocks.WATER.defaultBlockState();
-            else column[k] = Blocks.AIR.defaultBlockState();
+        try (GenerationSessionLease lease = engine.acquireGenerationLease("bukkit_nms_base_column");
+             IrisContext.Scope ignored = IrisContext.open(engine, lease.sessionId(), null)) {
+            int block = engine.getHeight(i, j, true);
+            int water = engine.getHeight(i, j, false);
+            BlockState[] column = new BlockState[levelheightaccessor.getHeight()];
+            for (int k = 0; k < column.length; k++) {
+                if (k <= block) {
+                    column[k] = Blocks.STONE.defaultBlockState();
+                } else if (k <= water) {
+                    column[k] = Blocks.WATER.defaultBlockState();
+                } else {
+                    column[k] = Blocks.AIR.defaultBlockState();
+                }
+            }
+            return new NoiseColumn(levelheightaccessor.getMinY(), column);
+        } catch (GenerationSessionException e) {
+            throw new IllegalStateException("Iris base column query could not acquire its engine runtime.", e);
+        }
+    }
+
+    private GenerationSessionLease requireGenerationLease(String operation) {
+        try {
+            return engine.acquireGenerationLease(operation);
+        } catch (GenerationSessionException exception) {
+            throw new IllegalStateException("Iris " + operation + " could not acquire its engine runtime.", exception);
         }
-        return new NoiseColumn(levelheightaccessor.getMinY(), column);
     }
 
     @Override

adapters/bukkit/nms/v26_2_R1/src/test/java/art/arcane/iris/core/nms/v26_2_R1/CustomBiomeSourceStructureContractTest.java

@@ -19,4 +19,21 @@ public class CustomBiomeSourceStructureContractTest {
         assertTrue(source.contains("resolution.irisBiome.getStructureDerivativeKey()"));
         assertFalse(source.contains("resolution.irisBiome.getVanillaDerivative()"));
     }
+
+    @Test
+    public void biomeRuntimeReadsAreGenerationLeased() throws IOException {
+        String source = Files.readString(Path.of(System.getProperty("iris.customBiomeSource")));
+
+        assertTrue(source.contains("tryAcquireGenerationLease(\"bukkit_possible_biomes\")"));
+        assertTrue(source.contains("tryAcquireGenerationLease(\"bukkit_spawn_biome\")"));
+        assertTrue(source.contains("Iris spawn biome lookup was rejected during an engine transition"));
+        assertTrue(source.contains("Iris spawn biome lookup has no active engine runtime"));
+        assertTrue(source.contains("tryAcquireGenerationLease(\"bukkit_structure_biome\")"));
+        assertTrue(source.contains("tryAcquireGenerationLease(\"bukkit_biomes_within\")"));
+        assertTrue(source.contains("tryAcquireGenerationLease(\"bukkit_visible_biome\")"));
+        assertTrue(source.contains("if (engine.isClosed())"));
+        assertTrue(source.contains("engine.isClosing() || e.isExpectedTeardown()"));
+        assertTrue(source.contains("catch (GenerationSessionException e)"));
+        assertTrue(source.contains("e.isExpectedTeardown()"));
+    }
 }

adapters/bukkit/nms/v26_2_R1/src/test/java/art/arcane/iris/core/nms/v26_2_R1/IrisChunkGeneratorFailureContractTest.java

@@ -54,4 +54,14 @@ public class IrisChunkGeneratorFailureContractTest {
                 < placement.indexOf("for (NativePlacementGroup group"));
         assertFalse(placement.contains("IrisLogging.reportError"));
     }
+
+    @Test
+    public void heightmapRuntimeReadsAreGenerationLeased() throws IOException {
+        String source = Files.readString(Path.of(System.getProperty("iris.nmsChunkGeneratorSource")));
+
+        assertTrue(source.contains("engine.acquireGenerationLease(\"bukkit_nms_heightmaps\")"));
+        assertTrue(source.contains("engine.acquireGenerationLease(\"bukkit_nms_base_height\")"));
+        assertTrue(source.contains("engine.acquireGenerationLease(\"bukkit_nms_base_column\")"));
+        assertTrue(source.contains("catch (GenerationSessionException e)"));
+    }
 }