d

d

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

@@ -61,6 +61,7 @@ public class CustomBiomeSource extends BiomeSource {
     private final ConcurrentHashMap<Long, Holder<Biome>> noiseBiomeCache = new ConcurrentHashMap<>();
     private final ConcurrentHashMap<Long, Holder<Biome>> structureBiomeCache = new ConcurrentHashMap<>();
     private final ConcurrentHashMap<Long, Holder<Biome>> surfaceStructureBiomeCache = new ConcurrentHashMap<>();
+    private final ConcurrentHashMap<Long, Holder<Biome>> naturalSurfaceStructureBiomeCache = new ConcurrentHashMap<>();
     private volatile KMap<String, Holder<Biome>> customBiomes;
     private volatile Map<Biome, Holder<Biome>> vanillaSpawnBiomes;
     private volatile IrisDimension cacheDimension;
@@ -330,8 +331,18 @@ public class CustomBiomeSource extends BiomeSource {
         if (quartStep == 1) {
             return super.findBiomeHorizontal(x, y, z, searchRadius, allowed, random, sampler);
         }
-        return super.findBiomeHorizontal(
-                x, y, z, searchRadius, quartStep, allowed, random, false, sampler);
+        GenerationSessionLease lease = tryAcquireGenerationLease("bukkit_structure_ring_biome");
+        if (lease == null) {
+            throw new IllegalStateException("Iris structure ring 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 ring biome lookup has no active engine runtime");
+            }
+            ensureCachesCurrent();
+            return findNaturalSurfaceBiomeHorizontal(
+                    x, y, z, searchRadius, quartStep, allowed, random);
+        }
     }
 
     static int horizontalBiomeSearchQuartStep(int blockY, int searchRadius) {
@@ -389,6 +400,60 @@ public class CustomBiomeSource extends BiomeSource {
         return resolvedSurfaceHolder;
     }
 
+    private Pair<BlockPos, Holder<Biome>> findNaturalSurfaceBiomeHorizontal(
+            int x,
+            int y,
+            int z,
+            int searchRadius,
+            int quartStep,
+            Predicate<Holder<Biome>> allowed,
+            RandomSource random
+    ) {
+        int centerQuartX = QuartPos.fromBlock(x);
+        int centerQuartZ = QuartPos.fromBlock(z);
+        int quartRadius = QuartPos.fromBlock(searchRadius);
+        Pair<BlockPos, Holder<Biome>> selected = null;
+        int matches = 0;
+        for (int radius = 0; radius <= quartRadius; radius += quartStep) {
+            for (int offsetZ = -radius; offsetZ <= radius; offsetZ += quartStep) {
+                for (int offsetX = -radius; offsetX <= radius; offsetX += quartStep) {
+                    int quartX = centerQuartX + offsetX;
+                    int quartZ = centerQuartZ + offsetZ;
+                    Holder<Biome> holder = getNaturalSurfaceStructureBiomeHolder(quartX, quartZ);
+                    if (!allowed.test(holder)) {
+                        continue;
+                    }
+                    if (selected == null || random.nextInt(matches + 1) == 0) {
+                        selected = Pair.of(new BlockPos(
+                                QuartPos.toBlock(quartX),
+                                y,
+                                QuartPos.toBlock(quartZ)), holder);
+                    }
+                    matches++;
+                }
+            }
+        }
+        return selected;
+    }
+
+    private Holder<Biome> getNaturalSurfaceStructureBiomeHolder(int x, int z) {
+        long columnKey = packColumnKey(x, z);
+        Holder<Biome> cachedHolder = naturalSurfaceStructureBiomeCache.get(columnKey);
+        if (cachedHolder != null) {
+            return cachedHolder;
+        }
+        Holder<Biome> resolvedHolder = resolveNaturalSurfaceStructureBiomeHolder(x, z);
+        Holder<Biome> existingHolder = naturalSurfaceStructureBiomeCache.putIfAbsent(
+                columnKey, resolvedHolder);
+        if (existingHolder != null) {
+            return existingHolder;
+        }
+        if (naturalSurfaceStructureBiomeCache.size() > NOISE_BIOME_CACHE_MAX) {
+            naturalSurfaceStructureBiomeCache.clear();
+        }
+        return resolvedHolder;
+    }
+
     private boolean isGuaranteedSurfaceBiome(int quartY) {
         if (engine == null || engine.isClosed() || engine.getComplex() == null) {
             return false;
@@ -416,36 +481,66 @@ public class CustomBiomeSource extends BiomeSource {
         return holder;
     }
 
+    private Holder<Biome> resolveNaturalSurfaceStructureBiomeHolder(int x, int z) {
+        int blockX = x << 2;
+        int blockZ = z << 2;
+        IrisBiome irisBiome = engine.getComplex().getNaturalTrueBiomeStream().get(blockX, blockZ);
+        if (irisBiome == null) {
+            throw new IllegalStateException("Iris returned no natural structure biome at block "
+                    + blockX + "," + blockZ);
+        }
+        Holder<Biome> holder = resolveBiomeHolder(biomeRegistry, irisBiome.getStructureDerivativeKey());
+        if (holder == null) {
+            throw new IllegalStateException("Iris natural structure biome derivative '"
+                    + irisBiome.getStructureDerivativeKey() + "' is not registered at block "
+                    + blockX + "," + blockZ);
+        }
+        return holder;
+    }
+
     public Holder<Biome> getVisibleNoiseBiome(int x, int y, int z, Climate.Sampler sampler) {
         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;
-            }
-
-            if (noiseBiomeCache.size() > NOISE_BIOME_CACHE_MAX) {
-                noiseBiomeCache.clear();
-            }
-
-            return resolvedHolder;
+            prepareVisibleBiomeBatch();
+            return getVisibleNoiseBiomeWithActiveGenerationLease(x, y, z, sampler);
         }
     }
 
+    void prepareVisibleBiomeBatch() {
+        if (!isRuntimeAvailable()) {
+            throw new IllegalStateException("Iris visible biome lookup has no active engine runtime");
+        }
+        ensureCachesCurrent();
+    }
+
+    Holder<Biome> getVisibleNoiseBiomeWithActiveGenerationLease(
+            int x,
+            int y,
+            int z,
+            Climate.Sampler sampler
+    ) {
+        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;
+        }
+
+        if (noiseBiomeCache.size() > NOISE_BIOME_CACHE_MAX) {
+            noiseBiomeCache.clear();
+        }
+
+        return resolvedHolder;
+    }
+
     private GenerationSessionLease tryAcquireGenerationLease(String operation) {
         if (engine.isClosed()) {
             return null;
@@ -482,6 +577,7 @@ public class CustomBiomeSource extends BiomeSource {
             noiseBiomeCache.clear();
             structureBiomeCache.clear();
             surfaceStructureBiomeCache.clear();
+            naturalSurfaceStructureBiomeCache.clear();
             customBiomes = refreshedCustomBiomes;
             vanillaSpawnBiomes = refreshedSpawnBiomes;
             cacheDimension = dimension;
@@ -573,11 +669,20 @@ public class CustomBiomeSource extends BiomeSource {
             return null;
         }
 
+        return createBiomeResolution(irisBiome, underground, blockX, blockY, blockZ);
+    }
+
+    private BiomeResolution createBiomeResolution(
+            IrisBiome irisBiome,
+            boolean underground,
+            int blockX,
+            int blockY,
+            int blockZ
+    ) {
         RNG noiseRng = new RNG(seed
                 ^ (((long) blockX) * 341873128712L)
                 ^ (((long) blockY) * 132897987541L)
                 ^ (((long) blockZ) * 42317861L));
-
         return new BiomeResolution(irisBiome, underground, blockX, blockY, blockZ, noiseRng);
     }
 

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

@@ -642,7 +642,10 @@ public class IrisChunkGenerator extends CustomChunkGenerator {
         try (BukkitChunkGenerator.GenerationStagePermit stage = requireGenerationStage("bukkit_nms_create_biomes");
              GenerationSessionLease lease = requireGenerationLease("bukkit_nms_create_biomes");
              IrisContext.Scope ignored = IrisContext.open(engine, lease.sessionId(), null)) {
-            ichunkaccess.fillBiomesFromNoise(customBiomeSource::getVisibleNoiseBiome, randomstate.sampler());
+            customBiomeSource.prepareVisibleBiomeBatch();
+            ichunkaccess.fillBiomesFromNoise(
+                    customBiomeSource::getVisibleNoiseBiomeWithActiveGenerationLease,
+                    randomstate.sampler());
             return CompletableFuture.completedFuture(ichunkaccess);
         }
     }

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

@@ -168,6 +168,7 @@ import java.util.Map;
 import java.util.Optional;
 import java.util.List;
 import java.util.Set;
+import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.Executor;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.AtomicBoolean;
@@ -1295,16 +1296,16 @@ public class NMSBinding implements INMSBinding {
     }
 
     @Override
-    public void completeStudioStructureBootstrap(World world) throws NoSuchFieldException, IllegalAccessException {
+    public CompletableFuture<Void> completeStudioStructureBootstrap(World world) throws NoSuchFieldException, IllegalAccessException {
         ServerLevel level = ((CraftWorld) world).getHandle();
         ChunkMap chunkMap = level.getChunkSource().chunkMap;
         IrisChunkGenerator generator = requireIrisGenerator(level.getChunkSource().getGenerator());
         IrisChunkGenerator.StudioStructureState retained =
                 generator.retainedStudioStructureState(level, chunkMap);
         if (retained == null) {
-            return;
+            return CompletableFuture.completedFuture(null);
         }
-        generator.activateStudioStructureState(retained);
+        return generator.activateStudioStructureState(retained);
     }
 
     @Override

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

@@ -45,8 +45,53 @@ public class CustomBiomeSourceStructureContractTest {
         assertTrue(source.contains("private static final int STRONGHOLD_RING_SEARCH_Y = 0"));
         assertTrue(source.contains("private static final int STRONGHOLD_RING_SEARCH_RADIUS = 112"));
         assertTrue(source.contains("private static final int STRONGHOLD_RING_SEARCH_QUART_STEP = 4"));
-        assertTrue(source.contains("x, y, z, searchRadius, quartStep, allowed, random, false, sampler"));
         assertTrue(source.contains(
                 "return super.findBiomeHorizontal(x, y, z, searchRadius, allowed, random, sampler)"));
+        assertTrue(source.contains("tryAcquireGenerationLease(\"bukkit_structure_ring_biome\")"));
+        assertTrue(source.contains("findNaturalSurfaceBiomeHorizontal("));
+        assertTrue(source.contains("radius += quartStep"));
+        assertTrue(source.contains("offsetZ += quartStep"));
+        assertTrue(source.contains("offsetX += quartStep"));
+        assertTrue(source.contains("random.nextInt(matches + 1) == 0"));
+    }
+
+    @Test
+    public void onlyConcentricRingSuitabilityUsesTheNaturalTerrainStream() throws IOException {
+        String source = Files.readString(Path.of(System.getProperty("iris.customBiomeSource")));
+        int realResolutionStart = source.indexOf("private Holder<Biome> resolveSurfaceStructureBiomeHolder(");
+        int naturalResolutionStart = source.indexOf(
+                "private Holder<Biome> resolveNaturalSurfaceStructureBiomeHolder(");
+        int resolutionEnd = source.indexOf("public Holder<Biome> getVisibleNoiseBiome(", naturalResolutionStart);
+
+        assertTrue(realResolutionStart >= 0);
+        assertTrue(naturalResolutionStart > realResolutionStart);
+        assertTrue(resolutionEnd > naturalResolutionStart);
+        String realResolution = source.substring(realResolutionStart, naturalResolutionStart);
+        String naturalResolution = source.substring(naturalResolutionStart, resolutionEnd);
+
+        assertTrue(realResolution.contains("engine.getComplex().getTrueBiomeStream().get(blockX, blockZ)"));
+        assertFalse(realResolution.contains("getNaturalTrueBiomeStream()"));
+        assertTrue(naturalResolution.contains(
+                "engine.getComplex().getNaturalTrueBiomeStream().get(blockX, blockZ)"));
+        assertFalse(naturalResolution.contains("getTrueBiomeStream()"));
+        assertFalse(source.contains("studioBootstrapSurfaceStructureBiomeCache"));
+    }
+
+    @Test
+    public void visibleBiomeBatchReusesTheCallersGenerationLease() throws IOException {
+        String source = Files.readString(Path.of(System.getProperty("iris.customBiomeSource")));
+        int lookupStart = source.indexOf("public Holder<Biome> getVisibleNoiseBiome(");
+        int lookupEnd = source.indexOf("private GenerationSessionLease tryAcquireGenerationLease(", lookupStart);
+
+        assertTrue(lookupStart >= 0);
+        assertTrue(lookupEnd > lookupStart);
+        String lookup = source.substring(lookupStart, lookupEnd);
+
+        assertTrue(lookup.contains("tryAcquireGenerationLease(\"bukkit_visible_biome\")"));
+        assertTrue(lookup.contains("prepareVisibleBiomeBatch()"));
+        assertTrue(lookup.contains("getVisibleNoiseBiomeWithActiveGenerationLease(x, y, z, sampler)"));
+        assertTrue(lookup.indexOf("prepareVisibleBiomeBatch()")
+                < lookup.indexOf("getVisibleNoiseBiomeWithActiveGenerationLease(x, y, z, sampler)"));
+        assertFalse(source.contains("studioBootstrapNoiseBiomeCache"));
     }
 }

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

@@ -219,30 +219,89 @@ public class IrisChunkGeneratorFailureContractTest {
         assertTrue(source.contains("int minY = chunk.getMinY() + 1;"));
     }
 
+    @Test
+    public void everyChunkUsesTheProductionGenerationStages() throws IOException {
+        String source = Files.readString(Path.of(System.getProperty("iris.nmsChunkGeneratorSource")))
+                .replace("\r\n", "\n");
+        String createBiomes = method(
+                source,
+                "public CompletableFuture<ChunkAccess> createBiomes",
+                "public void buildSurface");
+        String buildSurface = method(
+                source,
+                "public void buildSurface",
+                "public void applyCarvers");
+        String carvers = method(
+                source,
+                "public void applyCarvers",
+                "public CompletableFuture<ChunkAccess> fillFromNoise");
+        String noise = method(
+                source,
+                "public CompletableFuture<ChunkAccess> fillFromNoise",
+                "private static boolean isCancellationFailure");
+        String decoration = method(
+                source,
+                "public void applyBiomeDecoration(WorldGenLevel generatoraccessseed, ChunkAccess ichunkaccess, StructureManager structuremanager, boolean vanilla)",
+                "public BiomeGenerationSettings getBiomeGenerationSettings");
+        String spawning = method(
+                source,
+                "public void spawnOriginalMobs",
+                "private static WeightedList<MobSpawnSettings.SpawnerData> mergeSpawnTables");
+        String baseHeight = method(
+                source,
+                "public int getBaseHeight",
+                "public NoiseColumn getBaseColumn");
+        String baseColumn = method(
+                source,
+                "public NoiseColumn getBaseColumn",
+                "private GenerationSessionLease requireGenerationLease");
+
+        assertTrue(createBiomes.contains("requireGenerationStage(\"bukkit_nms_create_biomes\")"));
+        assertTrue(createBiomes.contains("customBiomeSource.prepareVisibleBiomeBatch()"));
+        assertTrue(createBiomes.contains("customBiomeSource::getVisibleNoiseBiomeWithActiveGenerationLease"));
+        assertTrue(buildSurface.contains("delegate.buildSurface("));
+        assertTrue(carvers.contains("delegate.applyCarvers("));
+        assertTrue(noise.contains("requireNoiseGenerationStage("));
+        assertTrue(noise.contains("\"bukkit_nms_chunk_pipeline\""));
+        assertTrue(noise.contains("stage.close()"));
+        assertTrue(noise.contains("completion.cancel(false)"));
+        assertTrue(decoration.contains("requireGenerationStage(\"bukkit_nms_biome_decoration\")"));
+        assertTrue(spawning.contains("NaturalSpawner.spawnMobsForChunkGeneration("));
+        assertTrue(baseHeight.contains("engine.getHeight("));
+        assertTrue(baseColumn.contains("engine.getHeight("));
+        assertFalse(source.contains("synthetic_entry"));
+        assertFalse(source.contains("StudioEntryChunkGenerator"));
+    }
+
     @Test
     public void fillFromNoiseLeaseSpansTheDelegateAndHeightmapPipeline() throws IOException {
         String source = Files.readString(Path.of(System.getProperty("iris.nmsChunkGeneratorSource"))).replace("\r\n", "\n");
         int fillStart = source.indexOf("public CompletableFuture<ChunkAccess> fillFromNoise");
         int fillEnd = source.indexOf("private static boolean isCancellationFailure", fillStart);
         String fill = source.substring(fillStart, fillEnd);
-        int completionStart = fill.indexOf("pipeline.whenComplete(");
-        int completionEnd = fill.indexOf("            return completion;", completionStart);
+        int productionStart = fill.indexOf(
+                "        BukkitChunkGenerator.GenerationStagePermit stage = requireNoiseGenerationStage(",
+                0);
+        assertTrue(productionStart >= 0);
+        String productionFill = fill.substring(productionStart);
+        int completionStart = productionFill.indexOf("pipeline.whenComplete(");
+        int completionEnd = productionFill.indexOf("            return completion;", completionStart);
         assertTrue(completionStart >= 0);
         assertTrue(completionEnd > completionStart);
-        String completion = fill.substring(completionStart, completionEnd);
+        String completion = productionFill.substring(completionStart, completionEnd);
 
-        assertBefore(fill,
+        assertBefore(productionFill,
                 "BukkitChunkGenerator.GenerationStagePermit stage = requireNoiseGenerationStage(",
                 "GenerationSessionLease lease");
-        assertBefore(fill,
+        assertBefore(productionFill,
                 "requireNoiseGenerationStage(",
                 "\"bukkit_nms_chunk_pipeline\")");
-        assertBefore(fill,
+        assertBefore(productionFill,
                 "lease = requireGenerationLease(\"bukkit_nms_chunk_pipeline\")",
                 ".fillFromNoise(blender, randomstate, structuremanager, ichunkaccess)");
-        assertTrue(fill.contains("IrisContext.open(engine, lease.sessionId(), null)"));
-        assertBefore(fill, "primeWorldgenHeightmaps(filled)", "pipeline.whenComplete(");
-        assertTrue(fill.contains("CompletableFuture<ChunkAccess> completion = new CompletableFuture<>()"));
+        assertTrue(productionFill.contains("IrisContext.open(engine, lease.sessionId(), null)"));
+        assertBefore(productionFill, "primeWorldgenHeightmaps(filled)", "pipeline.whenComplete(");
+        assertTrue(productionFill.contains("CompletableFuture<ChunkAccess> completion = new CompletableFuture<>()"));
         assertBefore(completion, "boolean cancelled = isCancellationFailure(failure);", "lease.close();");
         assertBefore(completion, "lease.close();", "stage.close();");
         assertBefore(completion, "stage.close();", "completion.complete(filled)");
@@ -251,12 +310,12 @@ public class IrisChunkGeneratorFailureContractTest {
         assertTrue(completion.contains("else if (cancelled)"));
         assertFalse(completion.contains("pipeline.isCancelled()"));
         assertFalse(completion.contains("finally"));
-        assertTrue(fill.contains("catch (RuntimeException | Error failure)"));
-        assertTrue(fill.contains("lease.close();\n            stage.close();\n            throw failure;"));
-        assertTrue(fill.contains("return completion;"));
-        assertFalse(fill.contains("return pipeline;"));
-        assertFalse(fill.contains("pipeline.cancel("));
-        assertFalse(fill.contains("bukkit_nms_worldgen_heightmaps"));
+        assertTrue(productionFill.contains("catch (RuntimeException | Error failure)"));
+        assertTrue(productionFill.contains("lease.close();\n            stage.close();\n            throw failure;"));
+        assertTrue(productionFill.contains("return completion;"));
+        assertFalse(productionFill.contains("return pipeline;"));
+        assertFalse(productionFill.contains("pipeline.cancel("));
+        assertFalse(productionFill.contains("bukkit_nms_worldgen_heightmaps"));
     }
 
     @Test

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

@@ -356,7 +356,9 @@ public class NMSBindingDatapackStructureScopeTest {
         Path chunkGeneratorSource = Path.of(System.getProperty("iris.nmsChunkGeneratorSource"));
         String source = Files.readString(chunkGeneratorSource.resolveSibling("NMSBinding.java")).replace("\r\n", "\n");
         int methodStart = source.indexOf("public DatapackStructureScopeResult scopeDatapackStructures(");
-        int methodEnd = source.indexOf("\n    @Override\n    public void completeStudioStructureBootstrap", methodStart);
+        int methodEnd = source.indexOf(
+                "\n    @Override\n    public CompletableFuture<Void> completeStudioStructureBootstrap",
+                methodStart);
 
         assertTrue(methodStart >= 0);
         assertTrue(methodEnd > methodStart);
@@ -390,19 +392,21 @@ public class NMSBindingDatapackStructureScopeTest {
     }
 
     @Test
-    public void standardCompletionActivatesTheAlreadyPublishedStateWithoutReplacingIt() throws IOException {
+    public void standardCompletionReturnsTheExactActivationFutureWithoutReplacingState() throws IOException {
         Path chunkGeneratorSource = Path.of(System.getProperty("iris.nmsChunkGeneratorSource"));
         String source = Files.readString(chunkGeneratorSource.resolveSibling("NMSBinding.java")).replace("\r\n", "\n");
-        int methodStart = source.indexOf("public void completeStudioStructureBootstrap(World world)");
+        int methodStart = source.indexOf("public CompletableFuture<Void> completeStudioStructureBootstrap(World world)");
         int methodEnd = source.indexOf("\n    @Override\n    public void abandonStudioStructureBootstrap", methodStart);
 
         assertTrue(methodStart >= 0);
         assertTrue(methodEnd > methodStart);
         String method = source.substring(methodStart, methodEnd);
         int retained = method.indexOf("generator.retainedStudioStructureState(level, chunkMap)");
-        int activation = method.indexOf("generator.activateStudioStructureState(retained);");
+        int emptyCompletion = method.indexOf("return CompletableFuture.completedFuture(null);");
+        int activation = method.indexOf("return generator.activateStudioStructureState(retained);");
 
         assertTrue(retained >= 0);
+        assertTrue(emptyCompletion > retained);
         assertTrue(activation > retained);
         assertFalse(method.contains("stateField.set("));
         assertFalse(method.contains("retained.fullState()"));