restructure the shared kts classloader to be more consistent

core/src/main/java/com/volmit/iris/core/loader/IrisData.java

@@ -58,8 +58,8 @@ public class IrisData implements ExclusionStrategy, TypeAdapterFactory {
     private static final KMap<File, IrisData> dataLoaders = new KMap<>();
     private final File dataFolder;
     private final int id;
-    private final PackEnvironment environment;
     private boolean closed = false;
+    private PackEnvironment environment;
     private ResourceLoader<IrisBiome> biomeLoader;
     private ResourceLoader<IrisLootTable> lootLoader;
     private ResourceLoader<IrisRegion> regionLoader;
@@ -92,7 +92,6 @@ public class IrisData implements ExclusionStrategy, TypeAdapterFactory {
         this.engine = null;
         this.dataFolder = dataFolder;
         this.id = RNG.r.imax();
-        this.environment = PackEnvironment.create(this);
         hotloaded();
     }
 
@@ -350,7 +349,6 @@ public class IrisData implements ExclusionStrategy, TypeAdapterFactory {
 
     public synchronized void hotloaded() {
         closed = false;
-        environment.close();
         possibleSnippets = new KMap<>();
         builder = new GsonBuilder()
                 .addDeserializationExclusionStrategy(this)
@@ -382,6 +380,7 @@ public class IrisData implements ExclusionStrategy, TypeAdapterFactory {
         this.imageLoader = registerLoader(IrisImage.class);
         this.scriptLoader = registerLoader(IrisScript.class);
         this.matterObjectLoader = registerLoader(IrisMatterObject.class);
+        this.environment = PackEnvironment.create(this);
         builder.registerTypeAdapterFactory(KeyedType::createTypeAdapter);
 
         gson = builder.create();
@@ -389,6 +388,10 @@ public class IrisData implements ExclusionStrategy, TypeAdapterFactory {
                 .map(IrisDimension::getDataScripts)
                 .flatMap(KList::stream)
                 .forEach(environment::execute);
+
+        if (engine != null) {
+            engine.hotload();
+        }
     }
 
     public void dump() {

core/src/main/java/com/volmit/iris/core/scripting/environment/PackEnvironment.java

@@ -2,6 +2,7 @@ package com.volmit.iris.core.scripting.environment;
 
 import com.volmit.iris.core.loader.IrisData;
 import com.volmit.iris.core.scripting.kotlin.environment.IrisPackExecutionEnvironment;
+import com.volmit.iris.engine.framework.Engine;
 import com.volmit.iris.util.math.RNG;
 import lombok.NonNull;
 import org.jetbrains.annotations.Nullable;
@@ -16,4 +17,6 @@ public interface PackEnvironment extends SimpleEnvironment {
 
     @Nullable
     Object createNoise(@NonNull String script, @NonNull RNG rng);
+
+    EngineEnvironment with(@NonNull Engine engine);
 }

core/src/main/java/com/volmit/iris/core/scripting/environment/SimpleEnvironment.java

@@ -27,8 +27,4 @@ public interface SimpleEnvironment {
 
     @Nullable
     Object evaluate(@NonNull String script, @NonNull Class<?> type, @Nullable Map<@NonNull String, Object> vars);
-
-    default void close() {
-
-    }
 }

core/src/main/java/com/volmit/iris/engine/IrisEngine.java

@@ -125,7 +125,7 @@ public class IrisEngine implements Engine {
         mantle = new IrisEngineMantle(this);
         context = new IrisContext(this);
         cleaning = new AtomicBoolean(false);
-        execution = EngineEnvironment.create(this);
+        execution = getData().getEnvironment().with(this);
         if (studio) {
             getData().dump();
             getData().clearLists();
@@ -163,10 +163,9 @@ public class IrisEngine implements Engine {
     private void prehotload() {
         worldManager.close();
         complex.close();
-        execution.close();
         effects.close();
         mode.close();
-        execution = EngineEnvironment.create(this);
+        execution = getData().getEnvironment().with(this);
 
         J.a(() -> new IrisProject(getData().getDataFolder()).updateWorkspace());
     }

core/src/main/kotlin/com/volmit/iris/core/scripting/kotlin/environment/IrisExecutionEnvironment.kt

@@ -9,15 +9,20 @@ import com.volmit.iris.core.scripting.kotlin.base.EngineScript
 import com.volmit.iris.core.scripting.kotlin.base.MobSpawningScript
 import com.volmit.iris.core.scripting.kotlin.base.PostMobSpawningScript
 import com.volmit.iris.core.scripting.kotlin.base.PreprocessorScript
+import com.volmit.iris.core.scripting.kotlin.environment.IrisSimpleExecutionEnvironment
+import com.volmit.iris.core.scripting.kotlin.runner.ScriptRunner
 import com.volmit.iris.engine.framework.Engine
 import com.volmit.iris.util.mantle.MantleChunk
 import org.bukkit.Chunk
 import org.bukkit.Location
 import org.bukkit.entity.Entity
+import java.io.File
 
-data class IrisExecutionEnvironment(
+class IrisExecutionEnvironment internal constructor(
-    private val engine: Engine
+    private val engine: Engine,
-) : IrisPackExecutionEnvironment(engine.data), EngineEnvironment {
+    parent: ScriptRunner?,
+) : IrisPackExecutionEnvironment(engine.data, parent), EngineEnvironment {
+    constructor(engine: Engine) : this(engine, null)
     override fun getEngine() = engine
 
     override fun execute(script: String) =

core/src/main/kotlin/com/volmit/iris/core/scripting/kotlin/environment/IrisPackExecutionEnvironment.kt

@@ -1,17 +1,22 @@
 package com.volmit.iris.core.scripting.kotlin.environment
 
 import com.volmit.iris.core.loader.IrisData
+import com.volmit.iris.core.scripting.environment.EngineEnvironment
 import com.volmit.iris.core.scripting.environment.PackEnvironment
 import com.volmit.iris.core.scripting.kotlin.base.DataScript
 import com.volmit.iris.core.scripting.kotlin.base.NoiseScript
 import com.volmit.iris.core.scripting.kotlin.runner.Script
+import com.volmit.iris.core.scripting.kotlin.runner.ScriptRunner
 import com.volmit.iris.core.scripting.kotlin.runner.valueOrThrow
+import com.volmit.iris.engine.framework.Engine
 import com.volmit.iris.util.math.RNG
 import kotlin.reflect.KClass
 
-open class IrisPackExecutionEnvironment(
+open class IrisPackExecutionEnvironment internal constructor(
-    private val data: IrisData
+    private val data: IrisData,
-) : IrisSimpleExecutionEnvironment(data.dataFolder), PackEnvironment {
+    parent: ScriptRunner?
+) : IrisSimpleExecutionEnvironment(data.dataFolder, parent), PackEnvironment {
+    constructor(data: IrisData) : this(data, null)
 
     override fun getData() = data
 
@@ -31,6 +36,9 @@ open class IrisPackExecutionEnvironment(
     override fun createNoise(script: String, rng: RNG) =
         evaluate(script, NoiseScript::class.java, data.parameters("rng" to rng))
 
+    override fun with(engine: Engine) =
+        IrisExecutionEnvironment(engine, runner)
+
     private fun IrisData.parameters(vararg values: Pair<String, Any?>): Map<String, Any?> {
         return mapOf(
             "data" to this,

core/src/main/kotlin/com/volmit/iris/core/scripting/kotlin/environment/IrisSimpleExecutionEnvironment.kt

@@ -19,11 +19,14 @@ import kotlin.script.experimental.annotations.KotlinScript
 import kotlin.script.experimental.api.ResultWithDiagnostics
 import kotlin.text.split
 
-open class IrisSimpleExecutionEnvironment(
+open class IrisSimpleExecutionEnvironment internal constructor(
-    baseDir: File = File(".").absoluteFile
+    baseDir: File,
+    parent: ScriptRunner?
 ) : SimpleEnvironment {
+    @JvmOverloads
+    constructor(baseDir: File = File(".").absoluteFile) : this(baseDir, null)
     protected val compileCache = KCache<String, KMap<KClass<*>, ResultWithDiagnostics<Script>>>({ _ -> KMap() }, IrisSettings.get().performance.cacheSize.toLong())
-    protected val runner = ScriptRunner(baseDir)
+    protected val runner = ScriptRunner(baseDir, parent)
 
     override fun execute(
         script: String
@@ -51,11 +54,6 @@ open class IrisSimpleExecutionEnvironment(
         return evaluate0(script, type.kotlin, vars)
     }
 
-    override fun close() {
-        compileCache.invalidate()
-        runner.clear()
-    }
-
     protected open fun compile(script: String, type: KClass<*>) =
         compileCache.get(script)
             .computeIfAbsent(type) { _ -> runner.compile(type, script) }

core/src/main/kotlin/com/volmit/iris/core/scripting/kotlin/runner/ScriptRunner.kt

@@ -19,24 +19,18 @@ import kotlin.script.experimental.jvm.jvm
 import kotlin.script.experimental.jvmhost.BasicJvmScriptingHost
 
 class ScriptRunner(
-    private val host: BasicJvmScriptingHost,
+    val baseDir: File,
-    val baseDir: File
+    parent: ScriptRunner? = null,
+    private val host: BasicJvmScriptingHost = BasicJvmScriptingHost()
 ) {
-    constructor(baseDir: File) : this(BasicJvmScriptingHost(), baseDir)
-
     private val configs = ConcurrentHashMap<KClass<*>, ScriptCompilationConfiguration>()
     private val hostConfig = host.baseHostConfiguration.withDefaultsFrom(defaultJvmScriptingHostConfiguration)
-    private val sharedClassLoader = SharedClassLoader()
+    private val sharedClassLoader: SharedClassLoader = parent?.let { SharedClassLoader(it.sharedClassLoader) } ?: SharedClassLoader()
-    private var resolver = createResolver(baseDir)
+    private val resolver = createResolver(baseDir)
 
     fun compile(type: KClass<*>, raw: String, name: String? = null) = compile(type, raw.toScriptSource(name))
     fun compile(type: KClass<*>, file: File, preloaded: String? = null) = compile(type, FileScriptSource(file, preloaded))
 
-    fun clear() {
-        configs.clear()
-        resolver = createResolver(baseDir)
-    }
-
     private fun compile(
         type: KClass<*>,
         code: SourceCode