f

core/src/test/java/art/arcane/iris/core/IrisStartupValidationTest.java

@@ -107,6 +107,20 @@ public class IrisStartupValidationTest {
         );
     }
 
+    @Test
+    public void forceAllowsOnlyStudioAtACompletedRestartBoundary() {
+        IrisStartupValidation.begin();
+        IrisStartupValidation.markDatapacksReady();
+        IrisStartupValidation.markPacksReady();
+        IrisStartupValidation.requireRestart("restart boundary");
+
+        assertTrue(IrisStartupValidation.studioDenialReason(true).isEmpty());
+        assertThrows(IllegalStateException.class, IrisStartupValidation::requireWorldCreationReady);
+
+        IrisStartupValidation.markPacksInvalid(List.of("pack validation failed"));
+        assertFalse(IrisStartupValidation.studioDenialReason(true).isEmpty());
+    }
+
     @Test
     public void packValidationInfrastructureFailureDeniesCreation() {
         IrisStartupValidation.begin();

core/src/test/java/art/arcane/iris/core/runtime/StudioOpenCoordinatorOpenKindTest.java

@@ -27,14 +27,29 @@ public class StudioOpenCoordinatorOpenKindTest {
     }
 
     @Test
-    public void allStudioKindsReuseOnlyAnUnchangedLoadedRuntime() {
+    public void ordinaryStudioKindsReuseOnlyAnUnchangedLoadedRuntime() {
         for (StudioOpenCoordinator.StudioOpenKind kind : StudioOpenCoordinator.StudioOpenKind.values()) {
+            if (kind == StudioOpenCoordinator.StudioOpenKind.FORCED_STANDARD) {
+                continue;
+            }
             assertEquals(
                     IrisCreator.DatapackPreparation.REUSE_LOADED_RUNTIME_IF_READY,
                     kind.datapackPreparation());
         }
     }
 
+    @Test
+    public void forcedStandardStudioAttemptsTheLoadedRuntime() {
+        StudioOpenCoordinator.StudioOpenKind kind = StudioOpenCoordinator.StudioOpenKind.FORCED_STANDARD;
+
+        assertTrue(kind.openWorkspace());
+        assertTrue(kind.teleportThroughStandardEntry());
+        assertTrue(kind.prepareGeneratorState());
+        assertEquals(
+                IrisCreator.DatapackPreparation.FORCE_REUSE_LOADED_RUNTIME,
+                kind.datapackPreparation());
+    }
+
     @Test
     public void objectStudioOwnsWorkspaceWithoutUsingTheStandardEntry() {
         StudioOpenCoordinator.StudioOpenKind kind = StudioOpenCoordinator.StudioOpenKind.OBJECT;
@@ -115,7 +130,7 @@ public class StudioOpenCoordinatorOpenKindTest {
         assertTrue(coordinatorMethod.contains(
                 "WorldRuntimeControlService.get().resolveEntryAnchor(world, provider)"));
         assertTrue(coordinatorMethod.contains(
-                "project.getActiveOpenKind() == StudioOpenKind.STANDARD"));
+                "project.getActiveOpenKind().teleportThroughStandardEntry()"));
         assertFalse(coordinatorMethod.contains("requestChunkAsync("));
         assertFalse(coordinatorMethod.contains("getHighestBlockYAt("));
         assertTrue(nativeDelegation >= 0);

core/src/test/java/art/arcane/iris/core/service/StudioSVCPackAdmissionTest.java

@@ -1,16 +1,27 @@
 package art.arcane.iris.core.service;
 
+import art.arcane.iris.core.IrisStartupValidation;
+import art.arcane.iris.core.ServerConfigurator;
 import art.arcane.iris.core.pack.BrokenPackException;
+import art.arcane.iris.core.pack.PackDownloader;
 import art.arcane.iris.core.pack.PackValidationResult;
+import org.junit.After;
 import org.junit.Test;
 
+import java.lang.reflect.Field;
 import java.util.List;
 import java.util.Optional;
 
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
 
 public class StudioSVCPackAdmissionTest {
+    @After
+    public void disableStartupValidation() {
+        IrisStartupValidation.disable();
+    }
+
     @Test
     public void loadablePackIsAdmitted() {
         PackValidationResult validation = new PackValidationResult(
@@ -57,4 +68,25 @@ public class StudioSVCPackAdmissionTest {
 
         assertEquals(List.of(denial), failure.getReasons());
     }
+
+    @Test
+    public void completedPackDownloadRetainsTheCreationGateWithoutDenyingLogin() throws Exception {
+        Field restartRequired = ServerConfigurator.class.getDeclaredField("loadedDatapackRestartRequired");
+        restartRequired.setAccessible(true);
+        boolean previous = restartRequired.getBoolean(null);
+        IrisStartupValidation.begin();
+        IrisStartupValidation.markDatapacksReady();
+        IrisStartupValidation.markPacksReady();
+
+        try {
+            StudioSVC.retainPackRestartRequirement(
+                    new PackDownloader.PackInstallResult("overworld", true, true));
+
+            assertTrue(ServerConfigurator.worldCreationDenialReason(false).isPresent());
+            assertTrue(ServerConfigurator.worldCreationDenialReason(true).isEmpty());
+            assertTrue(IrisStartupValidation.denialReason().isEmpty());
+        } finally {
+            restartRequired.setBoolean(null, previous);
+        }
+    }
 }

core/src/test/java/art/arcane/iris/core/tools/IrisCreatorDatapackPreparationTest.java

@@ -17,4 +17,11 @@ public class IrisCreatorDatapackPreparationTest {
         assertTrue(IrisCreator.DatapackPreparation.REUSE_LOADED_RUNTIME_IF_READY.requiresInstall(false));
         assertFalse(IrisCreator.DatapackPreparation.REUSE_LOADED_RUNTIME_IF_READY.requiresInstall(true));
     }
+
+    @Test
+    public void forcedStudioCreationNeverInstallsDatapacks() {
+        assertFalse(IrisCreator.DatapackPreparation.FORCE_REUSE_LOADED_RUNTIME.requiresInstall(false));
+        assertFalse(IrisCreator.DatapackPreparation.FORCE_REUSE_LOADED_RUNTIME.requiresInstall(true));
+        assertTrue(IrisCreator.DatapackPreparation.FORCE_REUSE_LOADED_RUNTIME.forcesLoadedRuntime());
+    }
 }