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

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

@@ -0,0 +1,55 @@
+#pragma once
+
+#include <jni.h>
+#include <jsi/jsi.h>
+#include <hermes/hermes.h>
+#include <chrono>
+#include <memory>
+#include <mutex>
+#include <queue>
+#include <string>
+#include <unordered_set>
+
+namespace rnthread {
+
+/**
+ * Holds a standalone Hermes runtime for a single background thread.
+ * All evaluateJavaScript / global-injection calls must happen on the
+ * same thread that created the runtime (enforced by the caller in Kotlin).
+ */
+class HermesThreadRuntime {
+ public:
+  HermesThreadRuntime(JNIEnv *env, jobject module, long threadId);
+  ~HermesThreadRuntime();
+
+  void evaluate(const std::string &code, const std::string &sourceURL);
+
+ private:
+  void installConsole(long threadId);
+  void installResolveThreadMessage(JNIEnv *env, jobject module, long threadId);
+  void installTimers();
+  void drainTimerLoop();
+
+  std::unique_ptr<facebook::hermes::HermesRuntime> runtime_;
+  jobject moduleRef_;
+  JavaVM *jvm_;
+
+  // ── Timer state ──
+  struct TimerEntry {
+    int id;
+    std::chrono::steady_clock::time_point fireAt;
+    bool repeating;
+    int intervalMs;
+
+    bool operator>(const TimerEntry &o) const { return fireAt > o.fireAt; }
+  };
+
+  // Min-heap ordered by fire time.
+  std::priority_queue<TimerEntry, std::vector<TimerEntry>,
+                      std::greater<TimerEntry>>
+      timerQueue_;
+  std::unordered_set<int> cancelledTimers_;
+  int nextTimerId_ = 1;
+};
+
+} // namespace rnthread

package/android/src/main/java/com/rnorg/reactnativethread/HermesThreadEngine.kt

@@ -0,0 +1,35 @@
+package com.rnorg.reactnativethread
+
+/**
+ * Thin JNI wrapper around the C++ HermesThreadRuntime.
+ * Each instance owns a standalone Hermes runtime.
+ */
+class HermesThreadEngine {
+  companion object {
+    init {
+      System.loadLibrary("react_native_thread")
+    }
+  }
+
+  /**
+   * Create a new Hermes runtime. Must be called on the thread that
+   * will subsequently call [evaluate].
+   *
+   * @param module  The ReactNativeThreadModule instance (so native
+   *                code can call back onThreadMessage).
+   * @param threadId  The numeric thread ID.
+   * @return A native pointer (opaque handle) to the C++ runtime.
+   */
+  external fun nativeCreate(module: Any, threadId: Long): Long
+
+  /**
+   * Evaluate a JS code string on the runtime identified by [ptr].
+   * Must be called on the same thread that created the runtime.
+   */
+  external fun nativeEvaluate(ptr: Long, code: String, sourceURL: String)
+
+  /**
+   * Destroy the native runtime and free its memory.
+   */
+  external fun nativeDestroy(ptr: Long)
+}

package/android/src/main/java/com/rnorg/reactnativethread/ReactNativeThreadModule.kt

@@ -4,12 +4,6 @@ import android.util.Log
 import com.facebook.react.bridge.Arguments
 import com.facebook.react.bridge.ReactApplicationContext
 import com.facebook.react.modules.core.DeviceEventManagerModule
-import org.mozilla.javascript.BaseFunction
-import org.mozilla.javascript.Context as RhinoContext
-import org.mozilla.javascript.NativeObject
-import org.mozilla.javascript.ScriptRuntime
-import org.mozilla.javascript.Scriptable
-import org.mozilla.javascript.ScriptableObject
 import java.util.concurrent.CompletableFuture
 import java.util.concurrent.ConcurrentHashMap
 import java.util.concurrent.ExecutorService
@@ -21,9 +15,10 @@ class ReactNativeThreadModule(reactContext: ReactApplicationContext) :
 
   private data class ThreadEntry(
     val executor: ExecutorService,
-    val scope: Scriptable
+    val runtimePtr: Long
   )
 
+  private val engine = HermesThreadEngine()
   private val threads = ConcurrentHashMap<Long, ThreadEntry>()
   private val nextId = AtomicLong(1L)
 
@@ -36,24 +31,19 @@ class ReactNativeThreadModule(reactContext: ReactApplicationContext) :
       Thread(r, "RNThread-$id")
     }
 
-    val scopeFuture = CompletableFuture<Scriptable>()
+    // Create the Hermes runtime on the thread that will own it.
+    val ptrFuture = CompletableFuture<Long>()
     executor.execute {
-      val cx = RhinoContext.enter()
       try {
-        cx.optimizationLevel = -1
-        val scope = cx.initStandardObjects()
-        injectConsole(scope, id)
-        injectResolveThreadMessage(scope, id)
-        scopeFuture.complete(scope)
+        val ptr = engine.nativeCreate(this, id)
+        ptrFuture.complete(ptr)
       } catch (e: Exception) {
-        scopeFuture.completeExceptionally(e)
-      } finally {
-        RhinoContext.exit()
+        ptrFuture.completeExceptionally(e)
       }
     }
 
-    val scope = scopeFuture.get()
-    threads[id] = ThreadEntry(executor, scope)
+    val ptr = ptrFuture.get()
+    threads[id] = ThreadEntry(executor, ptr)
     return id.toDouble()
   }
 
@@ -64,91 +54,40 @@ class ReactNativeThreadModule(reactContext: ReactApplicationContext) :
       return
     }
     entry.executor.execute {
-      val cx = RhinoContext.enter()
       try {
-        cx.optimizationLevel = -1
-        cx.evaluateString(entry.scope, code, "RNThread-${threadId.toLong()}", 1, null)
+        engine.nativeEvaluate(entry.runtimePtr, code, "RNThread-${threadId.toLong()}")
       } catch (e: Exception) {
         Log.e(NAME, "JS exception on thread $threadId: ${e.message}")
-      } finally {
-        RhinoContext.exit()
       }
     }
   }
 
   override fun destroyThread(threadId: Double) {
     val entry = threads.remove(threadId.toLong()) ?: return
-    entry.executor.shutdown()
-  }
-
-  private fun injectResolveThreadMessage(scope: Scriptable, threadId: Long) {
-    val ctx = reactApplicationContext
-    ScriptableObject.putProperty(
-      scope as ScriptableObject,
-      "resolveThreadMessage",
-      object : BaseFunction() {
-        override fun call(
-          cx: RhinoContext,
-          callScope: Scriptable,
-          thisObj: Scriptable?,
-          args: Array<out Any?>
-        ): Any {
-          val raw = args.getOrNull(0)
-          val jsonString: String = try {
-            val jsonObj = ScriptableObject.getProperty(callScope, "JSON") as? Scriptable
-            val stringify = jsonObj?.let { ScriptableObject.getProperty(it, "stringify") }
-            if (stringify is org.mozilla.javascript.Function) {
-              ScriptRuntime.toString(stringify.call(cx, callScope, jsonObj, arrayOf(raw)))
-            } else {
-              raw?.toString() ?: "null"
-            }
-          } catch (e: Exception) {
-            raw?.toString() ?: "null"
-          }
-
-          val params = Arguments.createMap().apply {
-            putDouble("threadId", threadId.toDouble())
-            putString("data", jsonString)
-          }
-          ctx.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
-            .emit("RNThreadMessage", params)
-
-          return RhinoContext.getUndefinedValue()
-        }
+    // Destroy the native runtime on its owning thread, then shut down.
+    entry.executor.execute {
+      try {
+        engine.nativeDestroy(entry.runtimePtr)
+      } catch (e: Exception) {
+        Log.w(NAME, "Error destroying runtime for thread $threadId: ${e.message}")
       }
-    )
+    }
+    entry.executor.shutdown()
   }
 
-  private fun injectConsole(scope: Scriptable, threadId: Long) {
-    val tag = "RNThread-$threadId"
-
-    fun makeLogFn(level: Int) = object : BaseFunction() {
-      override fun call(
-        cx: RhinoContext,
-        scope: Scriptable,
-        thisObj: Scriptable?,
-        args: Array<out Any?>
-      ): Any {
-        val msg = args.joinToString(" ") { it?.toString() ?: "null" }
-        when (level) {
-          Log.DEBUG -> Log.d(tag, msg)
-          Log.INFO  -> Log.i(tag, msg)
-          Log.WARN  -> Log.w(tag, msg)
-          Log.ERROR -> Log.e(tag, msg)
-          else      -> Log.v(tag, msg)
-        }
-        return RhinoContext.getUndefinedValue()
-      }
+  /**
+   * Called from C++ via JNI when resolveThreadMessage() is invoked
+   * inside a background thread.
+   */
+  @Suppress("unused")
+  fun onThreadMessage(threadId: Double, data: String) {
+    val params = Arguments.createMap().apply {
+      putDouble("threadId", threadId)
+      putString("data", data)
     }
-
-    val console = NativeObject()
-    console.parentScope = scope
-    ScriptableObject.putProperty(console, "log",   makeLogFn(Log.INFO))
-    ScriptableObject.putProperty(console, "info",  makeLogFn(Log.INFO))
-    ScriptableObject.putProperty(console, "warn",  makeLogFn(Log.WARN))
-    ScriptableObject.putProperty(console, "error", makeLogFn(Log.ERROR))
-    ScriptableObject.putProperty(console, "debug", makeLogFn(Log.DEBUG))
-    ScriptableObject.putProperty(scope as ScriptableObject, "console", console)
+    reactApplicationContext
+      .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+      .emit("RNThreadMessage", params)
   }
 
   companion object {

package/ios/HermesThreadEngine.cpp

@@ -0,0 +1,263 @@
+#include "HermesThreadEngine.h"
+
+#include <string>
+#include <thread>
+
+using namespace facebook;
+
+namespace rnthread {
+
+// ──────────────────────────────────────────────────────────────────
+// HermesThreadRuntime
+// ──────────────────────────────────────────────────────────────────
+
+HermesThreadRuntime::HermesThreadRuntime(long threadId, MessageCallback onMessage)
+    : runtime_(facebook::hermes::makeHermesRuntime(
+          ::hermes::vm::RuntimeConfig::Builder()
+              .withES6Promise(true)
+              .withMicrotaskQueue(true)
+              .build())),
+      onMessage_(std::move(onMessage)) {
+  installConsole(threadId);
+  installTimers();
+  installResolveThreadMessage(threadId);
+}
+
+HermesThreadRuntime::~HermesThreadRuntime() {
+  runtime_.reset();
+}
+
+void HermesThreadRuntime::evaluate(
+    const std::string &code,
+    const std::string &sourceURL) {
+  auto buf = std::make_shared<jsi::StringBuffer>(code);
+  runtime_->evaluateJavaScript(buf, sourceURL);
+  drainTimerLoop();
+}
+
+// ──────────────────────────────────────────────────────────────────
+// Timer event loop
+// ──────────────────────────────────────────────────────────────────
+
+void HermesThreadRuntime::drainTimerLoop() {
+  auto &rt = *runtime_;
+  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) {
+      std::this_thread::sleep_until(next.fireAt);
+    }
+
+    bool fired = false;
+    while (!timerQueue_.empty()) {
+      now = std::chrono::steady_clock::now();
+      if (timerQueue_.top().fireAt > now) break;
+
+      auto entry = timerQueue_.top();
+      timerQueue_.pop();
+
+      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) {
+        entry.fireAt = std::chrono::steady_clock::now() +
+                        std::chrono::milliseconds(entry.intervalMs);
+        timerQueue_.push(entry);
+      } else {
+        callbacks.setProperty(rt, idStr.c_str(), jsi::Value::undefined());
+      }
+    }
+
+    if (fired) {
+      rt.drainMicrotasks();
+    }
+
+    if (timerQueue_.empty()) break;
+  }
+}
+
+// ──────────────────────────────────────────────────────────────────
+// setTimeout / setInterval / clearTimeout / clearInterval
+// ──────────────────────────────────────────────────────────────────
+
+void HermesThreadRuntime::installTimers() {
+  auto &rt = *runtime_;
+
+  rt.global().setProperty(
+      rt, "__rnTimerCallbacks__", jsi::Object(rt));
+
+  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_++;
+
+        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;
+        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);
+          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](const char *level) {
+    return jsi::Function::createFromHostFunction(
+        rt,
+        jsi::PropNameID::forAscii(rt, "log"),
+        1,
+        [threadId, level](
+            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);
+          }
+          // NSLog is not available in pure C++; use fprintf which
+          // shows up in Xcode console.
+          fprintf(stderr, "[RNThread-%ld] %s: %s\n", threadId, level, msg.c_str());
+          return jsi::Value::undefined();
+        });
+  };
+
+  auto console = jsi::Object(rt);
+  console.setProperty(rt, "log", makeLogFn("LOG"));
+  console.setProperty(rt, "info", makeLogFn("INFO"));
+  console.setProperty(rt, "warn", makeLogFn("WARN"));
+  console.setProperty(rt, "error", makeLogFn("ERROR"));
+  console.setProperty(rt, "debug", makeLogFn("DEBUG"));
+  rt.global().setProperty(rt, "console", std::move(console));
+}
+
+// ──────────────────────────────────────────────────────────────────
+// resolveThreadMessage(data)
+// ──────────────────────────────────────────────────────────────────
+
+void HermesThreadRuntime::installResolveThreadMessage(long threadId) {
+  auto &rt = *runtime_;
+
+  auto fn = jsi::Function::createFromHostFunction(
+      rt,
+      jsi::PropNameID::forAscii(rt, "resolveThreadMessage"),
+      1,
+      [this](
+          jsi::Runtime &rt,
+          const jsi::Value &,
+          const jsi::Value *args,
+          size_t count) -> jsi::Value {
+        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";
+        }
+
+        if (onMessage_) {
+          onMessage_(serialised);
+        }
+
+        return jsi::Value::undefined();
+      });
+
+  rt.global().setProperty(rt, "resolveThreadMessage", std::move(fn));
+}
+
+} // namespace rnthread

package/ios/HermesThreadEngine.h

@@ -0,0 +1,49 @@
+#pragma once
+
+#include <jsi/jsi.h>
+#include <hermes/hermes.h>
+#include <chrono>
+#include <functional>
+#include <memory>
+#include <queue>
+#include <string>
+#include <unordered_set>
+
+namespace rnthread {
+
+using MessageCallback = std::function<void(const std::string &serialised)>;
+
+class HermesThreadRuntime {
+ public:
+  HermesThreadRuntime(long threadId, MessageCallback onMessage);
+  ~HermesThreadRuntime();
+
+  void evaluate(const std::string &code, const std::string &sourceURL);
+
+ private:
+  void installConsole(long threadId);
+  void installResolveThreadMessage(long threadId);
+  void installTimers();
+  void drainTimerLoop();
+
+  std::unique_ptr<facebook::hermes::HermesRuntime> runtime_;
+  MessageCallback onMessage_;
+
+  // ── Timer state ──
+  struct TimerEntry {
+    int id;
+    std::chrono::steady_clock::time_point fireAt;
+    bool repeating;
+    int intervalMs;
+
+    bool operator>(const TimerEntry &o) const { return fireAt > o.fireAt; }
+  };
+
+  std::priority_queue<TimerEntry, std::vector<TimerEntry>,
+                      std::greater<TimerEntry>>
+      timerQueue_;
+  std::unordered_set<int> cancelledTimers_;
+  int nextTimerId_ = 1;
+};
+
+} // namespace rnthread

package/ios/ReactNativeThread.mm

@@ -1,9 +1,12 @@
 #import "ReactNativeThread.h"
-#import <JavaScriptCore/JavaScriptCore.h>
+#import "HermesThreadEngine.h"
+
+#include <dispatch/dispatch.h>
+#include <memory>
+#include <string>
 
 @interface RNThread : NSObject
-@property (nonatomic, strong) JSVirtualMachine *vm;
-@property (nonatomic, strong) JSContext *context;
+@property (nonatomic, assign) std::shared_ptr<rnthread::HermesThreadRuntime> engine;
 @property (nonatomic, strong) dispatch_queue_t queue;
 @property (nonatomic) dispatch_semaphore_t ready;
 @end
@@ -44,59 +47,25 @@
     t.queue = dispatch_queue_create(label.UTF8String, attr);
     t.ready = dispatch_semaphore_create(0);
 
-    NSUInteger tidForLog = (NSUInteger)_nextId;
+    long tidForLog = (long)_nextId;
+    __weak ReactNativeThread *weakSelf = self;
 
     dispatch_async(t.queue, ^{
-        t.vm = [[JSVirtualMachine alloc] init];
-        t.context = [[JSContext alloc] initWithVirtualMachine:t.vm];
-        t.context.exceptionHandler = ^(JSContext *ctx, JSValue *exception) {
-            NSLog(@"[RNThread-%lu] JS exception: %@", (unsigned long)tidForLog, exception);
-        };
-
-        NSString *tag = [NSString stringWithFormat:@"RNThread-%lu", (unsigned long)tidForLog];
-        NSMutableDictionary *console = [NSMutableDictionary new];
-        console[@"log"] = ^{
-            NSArray *args = [JSContext currentArguments];
-            NSMutableArray *parts = [NSMutableArray new];
-            for (JSValue *v in args) [parts addObject:[v toString]];
-            NSLog(@"[%@] %@", tag, [parts componentsJoinedByString:@" "]);
-        };
-        console[@"info"]  = console[@"log"];
-        console[@"debug"] = console[@"log"];
-        console[@"warn"] = ^{
-            NSArray *args = [JSContext currentArguments];
-            NSMutableArray *parts = [NSMutableArray new];
-            for (JSValue *v in args) [parts addObject:[v toString]];
-            NSLog(@"[%@] WARN: %@", tag, [parts componentsJoinedByString:@" "]);
-        };
-        console[@"error"] = ^{
-            NSArray *args = [JSContext currentArguments];
-            NSMutableArray *parts = [NSMutableArray new];
-            for (JSValue *v in args) [parts addObject:[v toString]];
-            NSLog(@"[%@] ERROR: %@", tag, [parts componentsJoinedByString:@" "]);
-        };
-        t.context[@"console"] = console;
-
-        NSUInteger capturedTid = tidForLog;
-        __weak ReactNativeThread *weakSelf = self;
-        t.context[@"resolveThreadMessage"] = ^(JSValue *data) {
-            JSValue *jsonStr = [data.context[@"JSON"] invokeMethod:@"stringify"
-                                                      withArguments:@[data]];
-            NSString *serialised = [jsonStr toString];
-            if (!serialised || [serialised isEqualToString:@"undefined"]) {
-                serialised = @"null";
-            }
-
+        auto onMessage = [weakSelf, tidForLog](const std::string &serialised) {
             ReactNativeThread *strongSelf = weakSelf;
             if (!strongSelf) return;
 
+            NSString *nsData = [NSString stringWithUTF8String:serialised.c_str()];
+            if (!nsData) nsData = @"null";
+
             [strongSelf sendEventWithName:@"RNThreadMessage"
                                      body:@{
-                @"threadId": @(capturedTid),
-                @"data":     serialised
+                @"threadId": @(tidForLog),
+                @"data":     nsData
             }];
         };
 
+        t.engine = std::make_shared<rnthread::HermesThreadRuntime>(tidForLog, onMessage);
         dispatch_semaphore_signal(t.ready);
     });
 
@@ -119,12 +88,18 @@
         return;
     }
 
-    NSString *codeCopy = [code copy];
+    std::string codeCpp = std::string([code UTF8String]);
+    std::string sourceURL = "RNThread-" + std::to_string((long)threadId);
     dispatch_semaphore_t ready = t.ready;
+
     dispatch_async(t.queue, ^{
         dispatch_semaphore_wait(ready, DISPATCH_TIME_FOREVER);
         dispatch_semaphore_signal(ready);
-        [t.context evaluateScript:codeCopy];
+        try {
+            t.engine->evaluate(codeCpp, sourceURL);
+        } catch (const std::exception &e) {
+            NSLog(@"[RNThread-%.0f] JS exception: %s", threadId, e.what());
+        }
     });
 }
 
@@ -137,7 +112,7 @@
     if (!t) return;
 
     dispatch_async(t.queue, ^{
-        (void)t;
+        t.engine.reset();
     });
 }