Merge pull request #2 from bmstefanski/feat/javet-loader

feat: add Javet runtime

Author: iipanda

docs/content/docs/concurrency.mdx

@@ -181,6 +181,8 @@ for (let i = 0; i < 100; i++) {
 
 ![](./pool-stats.png)
 
+**`/hytalejs runtime`** - Show runtime debug info (active runtime, pool size, multithreaded status)
+
 **`/hytalejs tasks`** - Show operations waiting in queue
 
 ![](./queued-tasks.png)
@@ -220,15 +222,31 @@ Only Java objects passed through bindings (`Universe`, `HytaleServer`) are share
 
 ## Configuration
 
-Pool size can be configured via `config.json` in your plugin's data directory. The file is created automatically on first run:
+Runtime options can be configured via `config.json` in your plugin's data directory. The file is created automatically on first run:
 
 ```json
 {
-  "poolSize": 6
+  "runtime": {
+    "type": "graal",
+    "poolSize": 6,
+    "multithreaded": true
+  }
+}
+```
+
+Set `multithreaded: false` to force single-threaded execution (pool size becomes 1).
+
+```json
+{
+  "runtime": {
+    "type": "javet",
+    "poolSize": 1,
+    "multithreaded": false
+  }
 }
 ```
 
-Edit this value and restart the server to apply changes.
+Edit the config and restart the server to apply changes.
 
 ## References
 

docs/content/docs/meta.json

@@ -4,6 +4,7 @@
     "index",
     "getting-started",
     "concurrency",
+    "runtimes",
     "guides",
     "api"
   ]

docs/content/docs/runtimes.mdx

@@ -0,0 +1,60 @@
+---
+title: Runtimes
+description: Configure GraalJS and Javet runtimes for HytaleJS
+---
+
+HytaleJS supports two JavaScript runtimes:
+
+- **GraalJS** (default) — more tested and stable, but generally less performant.
+- **Javet (V8)** — faster in many workloads, uses V8 under the hood.
+
+## Configuration
+
+Runtime settings live in `config.json` inside your plugin data directory
+(`mods/bmstefanski_HytaleJS/config.json`).
+
+```json
+{
+  "runtime": {
+    "type": "graal",
+    "poolSize": 6,
+    "multithreaded": true
+  }
+}
+```
+
+### Options
+
+- `runtime.type`: `"graal"` or `"javet"` (default: `"graal"`).
+- `runtime.poolSize`: Number of runtime instances in the pool (e.g., Graal contexts or V8 runtimes) (default: `6`).
+- `runtime.multithreaded`: Enable/disable multi-context execution.
+  - If `false`, the pool is forced to size `1` (single-threaded execution).
+
+### Javet download settings
+
+When using Javet, native libraries are downloaded at runtime by default.
+
+```json
+{
+  "runtime": {
+    "type": "javet",
+    "poolSize": 6,
+    "multithreaded": true
+  },
+  "javet": {
+    "download": true,
+    "downloadBaseUrl": "https://repo1.maven.org/maven2"
+  }
+}
+```
+
+## Runtime Debug Command
+
+Use `/hytalejs runtime` to print the active runtime, pool size, queue depth,
+and Javet download settings.
+
+## Notes
+
+- Switching runtimes requires a server restart.
+- If you run into runtime-specific issues, try GraalJS first since it’s the
+  most tested option right now.

loader/build.gradle

@@ -21,6 +21,7 @@ dependencies {
   implementation 'org.graalvm.polyglot:polyglot:24.1.1'
   implementation 'org.graalvm.polyglot:js-community:24.1.1'
   implementation 'com.google.code.gson:gson:2.11.0'
+  implementation 'com.caoccao.javet:javet:5.0.3'
 }
 
 shadowJar {

loader/src/main/java/com/bmstefanski/hytalejs/ContextPool.java

@@ -0,0 +1,121 @@
+package com.bmstefanski.hytalejs;
+
+import org.graalvm.polyglot.Context;
+import org.graalvm.polyglot.Engine;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.BlockingQueue;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.LinkedBlockingQueue;
+import java.util.function.Consumer;
+
+public class GraalRuntimePool implements ScriptRuntimePool {
+  private final Engine engine;
+  private final List<ScriptRuntime> allRuntimes;
+  private final BlockingQueue<ScriptRuntime> available;
+  private final ConcurrentHashMap<Thread, PendingRequest> pendingRequests = new ConcurrentHashMap<>();
+
+  public GraalRuntimePool(int size, Consumer<ScriptRuntime> runtimeInitializer) {
+    engine = Engine.newBuilder()
+      .option("engine.WarnInterpreterOnly", "false")
+      .build();
+    allRuntimes = new ArrayList<>(size);
+    available = new LinkedBlockingQueue<>(size);
+
+    for (int i = 0; i < size; i++) {
+      Context ctx = Context.newBuilder("js")
+        .engine(engine)
+        .allowAllAccess(true)
+        .allowHostClassLookup(className -> true)
+        .build();
+      ScriptRuntime runtime = new GraalScriptRuntime(ctx);
+      runtimeInitializer.accept(runtime);
+      allRuntimes.add(runtime);
+      available.offer(runtime);
+    }
+  }
+
+  private ScriptRuntime acquire(String operation) {
+    Thread currentThread = Thread.currentThread();
+    pendingRequests.put(currentThread, new PendingRequest(operation, System.currentTimeMillis()));
+    try {
+      ScriptRuntime runtime = available.take();
+      pendingRequests.remove(currentThread);
+      try {
+        runtime.enter();
+      } catch (RuntimeException e) {
+        available.offer(runtime);
+        throw e;
+      }
+      return runtime;
+    } catch (InterruptedException e) {
+      pendingRequests.remove(currentThread);
+      Thread.currentThread().interrupt();
+      throw new RuntimeException("Interrupted while acquiring runtime", e);
+    }
+  }
+
+  private void release(ScriptRuntime runtime) {
+    runtime.leave();
+    available.offer(runtime);
+  }
+
+  @Override
+  public <T> T executeInRuntime(String operation, ScriptRuntimeTask<T> task) {
+    ScriptRuntime runtime = acquire(operation);
+    try {
+      return task.execute(runtime);
+    } finally {
+      release(runtime);
+    }
+  }
+
+  @Override
+  public void executeInRuntime(String operation, ScriptRuntimeRunnable task) {
+    ScriptRuntime runtime = acquire(operation);
+    try {
+      task.execute(runtime);
+    } finally {
+      release(runtime);
+    }
+  }
+
+  @Override
+  public List<ScriptRuntime> getAllRuntimes() {
+    return allRuntimes;
+  }
+
+  @Override
+  public int getTotalSize() {
+    return allRuntimes.size();
+  }
+
+  @Override
+  public int getAvailableCount() {
+    return available.size();
+  }
+
+  @Override
+  public int getBusyCount() {
+    return allRuntimes.size() - available.size();
+  }
+
+  @Override
+  public List<QueuedOperation> getQueuedOperations() {
+    long now = System.currentTimeMillis();
+    return pendingRequests.values().stream()
+      .map(req -> new QueuedOperation(req.operation, now - req.startTime))
+      .toList();
+  }
+
+  @Override
+  public void close() {
+    for (ScriptRuntime runtime : allRuntimes) {
+      if (runtime instanceof GraalScriptRuntime graalRuntime) {
+        graalRuntime.getContext().close();
+      }
+    }
+    engine.close();
+  }
+}