@rn-org/react-native-thread 0.7.0 → 0.8.0

package/README.md

@@ -1,6 +1,6 @@
 # @rn-org/react-native-thread
 
-Run JavaScript on real background threads in React Native — no Workers, no Worklets. Uses **JavaScriptCore** on iOS and **Mozilla Rhino** on Android, each on a dedicated OS-level thread. Built as a New Architecture **TurboModule**.
+Run JavaScript on real background threads in React Native — no Workers, no Worklets. Uses **Hermes** on both iOS and Android, each on a dedicated OS-level thread. Built as a New Architecture **TurboModule**.
 
 ---
 
@@ -41,17 +41,18 @@ Run JavaScript on real background threads in React Native — no Workers, no Wor
 
 ## Features
 
-- **True background threads** — each thread runs its own JS engine on an OS-level thread; the main Hermes/JSC runtime is never blocked.
+- **True background threads** — each thread runs its own isolated **Hermes** runtime on a dedicated OS-level thread; the main React Native runtime is never blocked. Works on both **iOS** and **Android**.
 - **Unlimited threads** — create as many threads as you need; each is isolated.
 - **Shared thread** (`runOnJS`) — fire-and-forget tasks on a single persistent background thread; no teardown required.
 - **Per-thread message passing** — call `resolveThreadMessage(data)` from any thread, receive it on the main thread with `onMessage` (callback or `await`).
 - **Parameter injection** — pass values from the main thread into the background function as a typed argument `(args) => { ... }`. Supports primitives, objects, arrays, **and functions**.
-- **Function params** — pass functions (including imported ones) alongside plain data in the params object. The Babel plugin extracts their source at compile time, captures closed-over variables transitively, and downlevels to ES5 for Rhino compatibility.
+- **Function params** — pass functions (including imported ones) alongside plain data in the params object. The Babel plugin extracts their source at compile time and captures closed-over variables transitively.
 - **Cross-module function params** — functions imported from other files (e.g. `import { compute } from './math'`) are automatically resolved and inlined by the Babel plugin.
 - **Named threads** — give threads friendly names; list or destroy them by name.
 - **Error handling** — thread exceptions are automatically caught and forwarded to the main thread. Use `onError` or `.catch()` on the `onMessage()` promise.
 - **Full `console` support** — `console.log/info/warn/error/debug` work inside threads and appear in Logcat / Xcode logs.
-- **Hermes-safe** — ships a Babel plugin that extracts function source at compile time so Hermes bytecode never breaks serialisation.
+- **Timer support** — `setTimeout`, `setInterval`, `clearTimeout`, and `clearInterval` work inside threads.
+- **Hermes-safe** — ships a Babel plugin that extracts function source at compile time so Hermes bytecode never breaks serialisation. Required on both iOS and Android since both platforms use Hermes.
 - **New Architecture only** — built on the TurboModule / Codegen pipeline.
 
 ---
@@ -81,7 +82,9 @@ yarn add @rn-org/react-native-thread
 cd ios && pod install
 ```
 
-**Android** — the Rhino dependency is declared in the library's `build.gradle`; no extra steps needed.
+The `hermes-engine` pod is declared as a dependency in the library's podspec; no extra configuration needed.
+
+**Android** — the Hermes native dependency is declared in the library's `build.gradle`; no extra steps needed.
 
 ---
 
@@ -93,8 +96,7 @@ Hermes compiles your JS to bytecode at build time. That means `fn.toString()` at
 2. Detects **function-valued properties** in the params object (second argument) and inlines their source.
 3. **Captures closed-over variables** transitively — if a function references outer `const`/`let`/`var` bindings (literals or other functions), those are bundled into a self-contained IIFE.
 4. **Resolves cross-module imports** — functions imported from relative paths (e.g. `import { fn } from './utils'`) are read from disk and inlined.
-5. **Downlevels ES6+ to ES5** — arrow functions, `let`/`const`, template literals, etc. are transpiled for Rhino (Android's JS engine).
-6. **Strips TypeScript** annotations automatically when the source file is `.ts` or `.tsx`.
+5. **Strips TypeScript** annotations automatically when the source file is `.ts` or `.tsx`.
 
 Add the plugin to your app's `babel.config.js`:
 
@@ -109,7 +111,9 @@ module.exports = {
 };
 ```
 
-The plugin is a no-op on non-Hermes builds (JSC, V8, etc.).
+The plugin is a no-op on non-Hermes builds (V8, etc.).
+
+> **Note:** The plugin safely handles cases where `@react-native/babel-preset` transforms `async` functions before the plugin's visitor fires. It falls back to the original source text via Babel's preserved AST positions.
 
 ---
 
@@ -149,6 +153,24 @@ thread.run(
   { x: 6, y: 7, multiply }
 );
 
+// Async function params work too — the Babel plugin transforms async/await
+// to generator-based code before sending to the Hermes thread runtime:
+const isPrime = async (num) => {
+  if (num <= 1) return 'Not Prime';
+  for (let i = 2; i < num; i++) {
+    if (num % i === 0) return 'Not Prime';
+  }
+  return 'Prime';
+};
+
+thread.run(
+  async (args) => {
+    const result = await args.isPrime(args.num);
+    resolveThreadMessage(`${args.num} is ${result}`);
+  },
+  { num: 17, isPrime }
+);
+
 // Functions that close over outer variables work too:
 const factor = 10;
 const scale = (n) => n * factor;
@@ -404,11 +426,29 @@ console.log(data); // { status: 'done', value: 42 }
 
 `console.log`, `.info`, `.warn`, `.error`, and `.debug` are all available and route to:
 
-- **iOS** — `NSLog`, visible in Xcode / Console.app; tagged `[RNThread-<id>]`.
+- **iOS** — `NSLog`, visible in Xcode / Console.app; tagged `[RNThread-<id>] [Hermes]`.
 - **Android** — `android.util.Log`, visible in Logcat; tagged `RNThread-<id>`.
 
 ---
 
+### Timers
+
+`setTimeout`, `clearTimeout`, `setInterval`, and `clearInterval` are available inside threads.
+
+Both iOS and Android use the same Hermes-based event loop: after the initial evaluation, the thread drains all pending timers (and microtasks) before returning. The thread blocks until all timers have fired or been cleared.
+
+```ts
+thread.run(() => {
+  setTimeout(() => {
+    resolveThreadMessage('delayed hello');
+  }, 2000);
+});
+```
+
+> **Note:** The event loop blocks the thread until timers complete. Be careful with `setInterval` — the thread won't finish until the interval is cleared inside the thread.
+
+---
+
 ### `__params__`
 
 ```ts
@@ -469,16 +509,20 @@ The included Babel plugin runs at **compile time** — before Hermes touches the
 
 #### Task function (first argument)
 
-Arrow functions and function expressions are replaced with an ES5-downleveled string literal wrapped as an IIFE:
+Arrow functions and function expressions (including `async`) are replaced with a string literal wrapped as an IIFE. `async`/`await` is transformed to generator-based code because Hermes' eval-mode compiler does not support async syntax:
 
 ```js
 // Input (your source)
-thread.run((args) => {
-  resolveThreadMessage(`${args.num} is great`);
-}, { num: 42 });
-
-// Output (what Hermes compiles)
-thread.run("((function (args) {\n  resolveThreadMessage(\"\".concat(args.num, \" is great\"));\n}))(__params__)", { num: 42 });
+thread.run(async (args) => {
+  const result = await args.compute(args.num);
+  resolveThreadMessage(result);
+}, { num: 42, compute });
+
+// Output (what Hermes compiles) — async transformed, compute inlined
+thread.run("((function(){ ... _asyncToGenerator ... })())(__params__)", {
+  num: 42,
+  compute: { __rnThreadFn: "(function(){ ... })()" }
+});
 ```
 
 #### Function params (second argument)
@@ -497,7 +541,7 @@ thread.run(fn, { multiply });
 // Output — transitive closures are captured in a self-contained IIFE
 thread.run(fn, {
   multiply: {
-    __rnThreadFn: "(function(){ var b = 3;\nvar add = function(x) { return x + b; };\nreturn function multiply(a) { return add(a) * 2; };})()" 
+    __rnThreadFn: "(function(){ var b = 3;\nvar add = (x) => x + b;\nreturn function multiply(a) { return add(a) * 2; };})()" 
   }
 });
 ```
@@ -515,7 +559,7 @@ export function checkEvenOdd(num: number): string {
 // App.tsx
 import { checkEvenOdd } from './utils';
 thread.run(fn, { checkEvenOdd });
-// → checkEvenOdd is inlined with TypeScript stripped and ES5-downleveled
+// → checkEvenOdd is inlined with TypeScript stripped
 ```
 
 ### Supported call sites
@@ -532,8 +576,10 @@ thread.run(fn, { checkEvenOdd });
 | Value type | Captured |
 |---|---|
 | Inline arrow / function expression | Yes |
+| Inline `async` arrow / function expression | Yes (transformed to generator) |
 | Reference to local `function` declaration | Yes |
 | Reference to local `const fn = () => ...` | Yes |
+| Reference to local `const fn = async () => ...` | Yes (transformed to generator) |
 | Imported function (`import { fn } from './mod'`) | Yes (relative paths only) |
 | Closed-over `const`/`let`/`var` with literal init | Yes (transitively) |
 | Closed-over function references | Yes (transitively) |
@@ -542,10 +588,10 @@ thread.run(fn, { checkEvenOdd });
 ### Limitations
 
 - **Captured closures must be statically resolvable**: only variables initialized with literals and functions (local or imported) are captured. Runtime-computed values (e.g. `const x = fetchValue()`) must be passed explicitly as params.
+- **`async` functions in params are supported** — the plugin transforms them to generator-based code before extraction. `await` works inside both task functions and function params.
 - **Cross-module resolution** only follows **relative imports** (e.g. `'./utils'`). Package imports (e.g. `'lodash'`) are not resolved.
-- Thread function bodies must be **ASCII-safe**: Rhino (Android) does not support non-ASCII identifier characters in source mode.
 - `undefined`, `Map`, `Set`, and class instances are not serialisable as param values — use plain objects, arrays, strings, numbers, booleans, or `null`.
-- Thread functions run in an **isolated JS engine** with no access to the React tree, native modules, or the main thread's global scope.
+- Thread functions run in an **isolated Hermes runtime** with no access to the React tree, native modules, or the main thread's global scope.
 
 ---
 
@@ -553,12 +599,13 @@ thread.run(fn, { checkEvenOdd });
 
 | Constraint | Reason |
 |---|---|
-| Thread functions run in isolation | They execute in a completely separate JS engine |
+| Thread functions run in isolation | They execute in a completely separate Hermes runtime (iOS and Android) |
+| Hermes eval-mode has no `async`/`await` | The Babel plugin transforms async to generators before extraction |
 | Function params must be statically resolvable | The Babel plugin extracts source at compile time |
 | Non-function `params` must be JSON-serialisable | Serialised via `JSON.stringify` at runtime |
 | `resolveThreadMessage` payload must be JSON-serialisable | Transported as a JSON string over the bridge |
 | Cross-module resolution is relative-only | The plugin reads files from disk using the import path |
-| Function body must be ASCII-safe | Rhino parser limitation |
+| No `fetch` / `XMLHttpRequest` | Thread runtimes have no network stack |
 | New Architecture required | TurboModule / Codegen only; no bridge fallback |
 
 ---

package/ReactNativeThread.podspec

@@ -16,5 +16,11 @@ Pod::Spec.new do |s|
   s.source_files = "ios/**/*.{h,m,mm,swift,cpp}"
   s.private_header_files = "ios/**/*.h"
 
+  s.pod_target_xcconfig = {
+    "CLANG_CXX_LANGUAGE_STANDARD" => "c++17",
+  }
+
   install_modules_dependencies(s)
+
+  s.dependency "hermes-engine"
 end

package/android/build.gradle

@@ -40,10 +40,24 @@ android {
   defaultConfig {
     minSdkVersion getExtOrDefault("minSdkVersion")
     targetSdkVersion getExtOrDefault("targetSdkVersion")
+
+    externalNativeBuild {
+      cmake {
+        cppFlags "-std=c++17"
+        arguments "-DANDROID_STL=c++_shared"
+      }
+    }
+  }
+
+  externalNativeBuild {
+    cmake {
+      path "src/main/cpp/CMakeLists.txt"
+    }
   }
 
   buildFeatures {
     buildConfig true
+    prefab true
   }
 
   buildTypes {
@@ -64,6 +78,5 @@ android {
 
 dependencies {
   implementation "com.facebook.react:react-android"
-  // Rhino JS engine – provides a self-contained JS runtime for background threads
-  implementation "org.mozilla:rhino:1.7.15"
+  implementation "com.facebook.react:hermes-android"
 }

package/android/src/main/cpp/CMakeLists.txt

@@ -0,0 +1,24 @@
+cmake_minimum_required(VERSION 3.13)
+project(react_native_thread)
+
+set(CMAKE_CXX_STANDARD 17)
+
+find_package(fbjni REQUIRED CONFIG)
+find_package(ReactAndroid REQUIRED CONFIG)
+find_package(hermes-engine REQUIRED CONFIG)
+
+add_library(react_native_thread SHARED
+    HermesThreadEngine.cpp
+)
+
+target_include_directories(react_native_thread PRIVATE
+    ${CMAKE_CURRENT_SOURCE_DIR}
+)
+
+target_link_libraries(react_native_thread
+    fbjni::fbjni
+    ReactAndroid::jsi
+    hermes-engine::hermesvm
+    android
+    log
+)

package/android/src/main/cpp/HermesThreadEngine.cpp

@@ -0,0 +1,388 @@
+#include "HermesThreadEngine.h"
+
+#include <android/log.h>
+#include <string>
+#include <thread>
+#include <unordered_map>
+
+#define LOG_TAG "RNThread"
+#define LOGI(...) __android_log_print(ANDROID_LOG_INFO, LOG_TAG, __VA_ARGS__)
+#define LOGW(...) __android_log_print(ANDROID_LOG_WARN, LOG_TAG, __VA_ARGS__)
+#define LOGE(...) __android_log_print(ANDROID_LOG_ERROR, LOG_TAG, __VA_ARGS__)
+
+using namespace facebook;
+
+namespace rnthread {
+
+// ──────────────────────────────────────────────────────────────────
+// HermesThreadRuntime
+// ──────────────────────────────────────────────────────────────────
+
+HermesThreadRuntime::HermesThreadRuntime(
+    JNIEnv *env,
+    jobject module,
+    long threadId)
+    : runtime_(facebook::hermes::makeHermesRuntime(
+          ::hermes::vm::RuntimeConfig::Builder()
+              .withES6Promise(true)
+              .withMicrotaskQueue(true)
+              .build())),
+      moduleRef_(nullptr), jvm_(nullptr) {
+  env->GetJavaVM(&jvm_);
+  moduleRef_ = env->NewWeakGlobalRef(module);
+
+  installConsole(threadId);
+  installTimers();
+  installResolveThreadMessage(env, module, threadId);
+}
+
+HermesThreadRuntime::~HermesThreadRuntime() {
+  runtime_.reset();
+  if (jvm_ && moduleRef_) {
+    JNIEnv *env = nullptr;
+    bool didAttach = false;
+    if (jvm_->GetEnv(reinterpret_cast<void **>(&env), JNI_VERSION_1_6) ==
+        JNI_EDETACHED) {
+      jvm_->AttachCurrentThread(&env, nullptr);
+      didAttach = true;
+    }
+    if (env) {
+      env->DeleteWeakGlobalRef(moduleRef_);
+    }
+    if (didAttach) {
+      jvm_->DetachCurrentThread();
+    }
+  }
+}
+
+void HermesThreadRuntime::evaluate(
+    const std::string &code,
+    const std::string &sourceURL) {
+  auto buf = std::make_shared<jsi::StringBuffer>(code);
+  runtime_->evaluateJavaScript(buf, sourceURL);
+  // Run the event loop: drain microtasks and pending timers until
+  // both queues are empty.
+  drainTimerLoop();
+}
+
+// ──────────────────────────────────────────────────────────────────
+// Timer event loop
+// ──────────────────────────────────────────────────────────────────
+
+void HermesThreadRuntime::drainTimerLoop() {
+  auto &rt = *runtime_;
+  // Keep a JS object that maps timerId → callback so we hold references.
+  auto callbacks =
+      rt.global()
+          .getPropertyAsObject(rt, "__rnTimerCallbacks__");
+
+  while (true) {
+    rt.drainMicrotasks();
+
+    if (timerQueue_.empty()) break;
+
+    auto now = std::chrono::steady_clock::now();
+    auto &next = timerQueue_.top();
+
+    if (next.fireAt > now) {
+      // Sleep until the next timer is due.
+      std::this_thread::sleep_until(next.fireAt);
+    }
+
+    // Pop and fire all timers that are now due.
+    bool fired = false;
+    while (!timerQueue_.empty()) {
+      now = std::chrono::steady_clock::now();
+      if (timerQueue_.top().fireAt > now) break;
+
+      auto entry = timerQueue_.top();
+      timerQueue_.pop();
+
+      // Skip cancelled timers.
+      if (cancelledTimers_.count(entry.id)) {
+        cancelledTimers_.erase(entry.id);
+        continue;
+      }
+
+      auto idStr = std::to_string(entry.id);
+      auto cb = callbacks.getProperty(rt, idStr.c_str());
+      if (cb.isObject() && cb.getObject(rt).isFunction(rt)) {
+        cb.getObject(rt).asFunction(rt).call(rt);
+        fired = true;
+      }
+
+      if (entry.repeating) {
+        // Re-enqueue for the next interval.
+        entry.fireAt = std::chrono::steady_clock::now() +
+                        std::chrono::milliseconds(entry.intervalMs);
+        timerQueue_.push(entry);
+      } else {
+        // One-shot: remove the callback reference.
+        callbacks.setProperty(rt, idStr.c_str(), jsi::Value::undefined());
+      }
+    }
+
+    if (fired) {
+      // Drain microtasks generated by the callbacks.
+      rt.drainMicrotasks();
+    }
+
+    // If no more timers, we're done.
+    if (timerQueue_.empty()) break;
+  }
+}
+
+// ──────────────────────────────────────────────────────────────────
+// setTimeout / setInterval / clearTimeout / clearInterval
+// ──────────────────────────────────────────────────────────────────
+
+void HermesThreadRuntime::installTimers() {
+  auto &rt = *runtime_;
+
+  // Hidden object to hold callback references so they aren't GC'd.
+  rt.global().setProperty(
+      rt, "__rnTimerCallbacks__", jsi::Object(rt));
+
+  // Pointer to `this` captured by the lambdas — safe because the
+  // lambdas only run while `evaluate()` is executing on the owning thread.
+  auto *self = this;
+
+  // ── setTimeout(fn, ms) → id ──
+  auto setTimeoutFn = jsi::Function::createFromHostFunction(
+      rt, jsi::PropNameID::forAscii(rt, "setTimeout"), 2,
+      [self](jsi::Runtime &rt, const jsi::Value &,
+             const jsi::Value *args, size_t count) -> jsi::Value {
+        if (count < 1 || !args[0].isObject() ||
+            !args[0].getObject(rt).isFunction(rt))
+          return jsi::Value::undefined();
+
+        int ms = count >= 2 ? static_cast<int>(args[1].asNumber()) : 0;
+        int id = self->nextTimerId_++;
+
+        // Store callback in the hidden map.
+        auto cbs = rt.global().getPropertyAsObject(rt, "__rnTimerCallbacks__");
+        cbs.setProperty(rt, std::to_string(id).c_str(),
+                        args[0].getObject(rt));
+
+        TimerEntry entry;
+        entry.id = id;
+        entry.fireAt = std::chrono::steady_clock::now() +
+                        std::chrono::milliseconds(ms);
+        entry.repeating = false;
+        entry.intervalMs = 0;
+        self->timerQueue_.push(entry);
+
+        return jsi::Value(id);
+      });
+  rt.global().setProperty(rt, "setTimeout", std::move(setTimeoutFn));
+
+  // ── setInterval(fn, ms) → id ──
+  auto setIntervalFn = jsi::Function::createFromHostFunction(
+      rt, jsi::PropNameID::forAscii(rt, "setInterval"), 2,
+      [self](jsi::Runtime &rt, const jsi::Value &,
+             const jsi::Value *args, size_t count) -> jsi::Value {
+        if (count < 1 || !args[0].isObject() ||
+            !args[0].getObject(rt).isFunction(rt))
+          return jsi::Value::undefined();
+
+        int ms = count >= 2 ? static_cast<int>(args[1].asNumber()) : 0;
+        if (ms <= 0) ms = 1; // Prevent tight infinite loop.
+        int id = self->nextTimerId_++;
+
+        auto cbs = rt.global().getPropertyAsObject(rt, "__rnTimerCallbacks__");
+        cbs.setProperty(rt, std::to_string(id).c_str(),
+                        args[0].getObject(rt));
+
+        TimerEntry entry;
+        entry.id = id;
+        entry.fireAt = std::chrono::steady_clock::now() +
+                        std::chrono::milliseconds(ms);
+        entry.repeating = true;
+        entry.intervalMs = ms;
+        self->timerQueue_.push(entry);
+
+        return jsi::Value(id);
+      });
+  rt.global().setProperty(rt, "setInterval", std::move(setIntervalFn));
+
+  // ── clearTimeout(id) / clearInterval(id) ──
+  auto clearTimerFn = jsi::Function::createFromHostFunction(
+      rt, jsi::PropNameID::forAscii(rt, "clearTimeout"), 1,
+      [self](jsi::Runtime &rt, const jsi::Value &,
+             const jsi::Value *args, size_t count) -> jsi::Value {
+        if (count >= 1 && args[0].isNumber()) {
+          int id = static_cast<int>(args[0].asNumber());
+          self->cancelledTimers_.insert(id);
+          // Also remove the callback reference.
+          auto cbs =
+              rt.global().getPropertyAsObject(rt, "__rnTimerCallbacks__");
+          cbs.setProperty(rt, std::to_string(id).c_str(),
+                          jsi::Value::undefined());
+        }
+        return jsi::Value::undefined();
+      });
+  rt.global().setProperty(rt, "clearTimeout", clearTimerFn);
+  rt.global().setProperty(rt, "clearInterval", std::move(clearTimerFn));
+}
+
+// ──────────────────────────────────────────────────────────────────
+// console.{log,info,warn,error,debug}
+// ──────────────────────────────────────────────────────────────────
+
+void HermesThreadRuntime::installConsole(long threadId) {
+  auto &rt = *runtime_;
+
+  auto makeLogFn = [&rt, threadId](int prio) {
+    return jsi::Function::createFromHostFunction(
+        rt,
+        jsi::PropNameID::forAscii(rt, "log"),
+        1,
+        [threadId, prio](
+            jsi::Runtime &rt,
+            const jsi::Value &,
+            const jsi::Value *args,
+            size_t count) -> jsi::Value {
+          std::string msg;
+          for (size_t i = 0; i < count; ++i) {
+            if (i > 0) msg += ' ';
+            msg += args[i].toString(rt).utf8(rt);
+          }
+          std::string tag = "RNThread-" + std::to_string(threadId);
+          __android_log_print(prio, tag.c_str(), "%s", msg.c_str());
+          return jsi::Value::undefined();
+        });
+  };
+
+  auto console = jsi::Object(rt);
+  console.setProperty(rt, "log", makeLogFn(ANDROID_LOG_INFO));
+  console.setProperty(rt, "info", makeLogFn(ANDROID_LOG_INFO));
+  console.setProperty(rt, "warn", makeLogFn(ANDROID_LOG_WARN));
+  console.setProperty(rt, "error", makeLogFn(ANDROID_LOG_ERROR));
+  console.setProperty(rt, "debug", makeLogFn(ANDROID_LOG_DEBUG));
+  rt.global().setProperty(rt, "console", std::move(console));
+}
+
+// ──────────────────────────────────────────────────────────────────
+// resolveThreadMessage(data)
+// ──────────────────────────────────────────────────────────────────
+
+void HermesThreadRuntime::installResolveThreadMessage(
+    JNIEnv *env,
+    jobject module,
+    long threadId) {
+  auto &rt = *runtime_;
+
+  // We need a shared pointer to the weak global ref and JVM pointer
+  // so the lambda can outlive this scope.
+  JavaVM *jvm = jvm_;
+  jobject weakModule = moduleRef_;
+
+  auto fn = jsi::Function::createFromHostFunction(
+      rt,
+      jsi::PropNameID::forAscii(rt, "resolveThreadMessage"),
+      1,
+      [jvm, weakModule, threadId](
+          jsi::Runtime &rt,
+          const jsi::Value &,
+          const jsi::Value *args,
+          size_t count) -> jsi::Value {
+        // JSON.stringify(args[0])
+        auto json = rt.global().getPropertyAsObject(rt, "JSON");
+        auto stringify = json.getPropertyAsFunction(rt, "stringify");
+        std::string serialised;
+        if (count > 0) {
+          auto result = stringify.call(rt, args[0]);
+          if (result.isString()) {
+            serialised = result.getString(rt).utf8(rt);
+          } else {
+            serialised = "null";
+          }
+        } else {
+          serialised = "null";
+        }
+
+        // Call back to Java on whatever thread we're on.
+        JNIEnv *jniEnv = nullptr;
+        bool didAttach = false;
+        if (jvm->GetEnv(
+                reinterpret_cast<void **>(&jniEnv), JNI_VERSION_1_6) ==
+            JNI_EDETACHED) {
+          jvm->AttachCurrentThread(&jniEnv, nullptr);
+          didAttach = true;
+        }
+        if (!jniEnv) return jsi::Value::undefined();
+
+        // Resolve the weak ref
+        jobject strongModule = jniEnv->NewLocalRef(weakModule);
+        if (!strongModule) {
+          if (didAttach) jvm->DetachCurrentThread();
+          return jsi::Value::undefined();
+        }
+
+        jclass cls = jniEnv->GetObjectClass(strongModule);
+        jmethodID mid = jniEnv->GetMethodID(
+            cls, "onThreadMessage", "(DLjava/lang/String;)V");
+        if (mid) {
+          jstring jData = jniEnv->NewStringUTF(serialised.c_str());
+          jniEnv->CallVoidMethod(
+              strongModule, mid, static_cast<jdouble>(threadId), jData);
+          jniEnv->DeleteLocalRef(jData);
+        }
+
+        jniEnv->DeleteLocalRef(cls);
+        jniEnv->DeleteLocalRef(strongModule);
+        if (didAttach) jvm->DetachCurrentThread();
+
+        return jsi::Value::undefined();
+      });
+
+  rt.global().setProperty(rt, "resolveThreadMessage", std::move(fn));
+}
+
+} // namespace rnthread
+
+// ──────────────────────────────────────────────────────────────────
+// JNI entry points
+// ──────────────────────────────────────────────────────────────────
+
+extern "C" {
+
+JNIEXPORT jlong JNICALL
+Java_com_rnorg_reactnativethread_HermesThreadEngine_nativeCreate(
+    JNIEnv *env,
+    jobject /* thiz */,
+    jobject module,
+    jlong threadId) {
+  auto *rt = new rnthread::HermesThreadRuntime(env, module, threadId);
+  return reinterpret_cast<jlong>(rt);
+}
+
+JNIEXPORT void JNICALL
+Java_com_rnorg_reactnativethread_HermesThreadEngine_nativeEvaluate(
+    JNIEnv *env,
+    jobject /* thiz */,
+    jlong ptr,
+    jstring code,
+    jstring sourceURL) {
+  auto *rt = reinterpret_cast<rnthread::HermesThreadRuntime *>(ptr);
+  const char *cCode = env->GetStringUTFChars(code, nullptr);
+  const char *cUrl = env->GetStringUTFChars(sourceURL, nullptr);
+  try {
+    rt->evaluate(std::string(cCode), std::string(cUrl));
+  } catch (const std::exception &e) {
+    LOGE("JS exception: %s", e.what());
+  }
+  env->ReleaseStringUTFChars(code, cCode);
+  env->ReleaseStringUTFChars(sourceURL, cUrl);
+}
+
+JNIEXPORT void JNICALL
+Java_com_rnorg_reactnativethread_HermesThreadEngine_nativeDestroy(
+    JNIEnv * /* env */,
+    jobject /* thiz */,
+    jlong ptr) {
+  auto *rt = reinterpret_cast<rnthread::HermesThreadRuntime *>(ptr);
+  delete rt;
+}
+
+} // extern "C"