expo-modules-jsi 56.0.4 → 56.0.5

package/CHANGELOG.md

@@ -10,6 +10,10 @@
 
 ### 💡 Others
 
+## 56.0.5 — 2026-05-15
+
+_This version does not introduce any user-facing changes._
+
 ## 56.0.4 — 2026-05-13
 
 ### 🐛 Bug fixes

package/apple/Sources/ExpoModulesJSI/Runtime/JavaScriptRuntime.swift

@@ -43,6 +43,17 @@ open class JavaScriptRuntime: Equatable, @unchecked Sendable {
   internal let runtimePointee: facebook.jsi.Runtime
   internal let scheduler: expo.RuntimeScheduler
 
+  /**
+   Thread ID of the JavaScript thread, captured at construction time. Used by `isOnJavaScriptThread()`
+   for a fast integer comparison instead of `Thread.current.name == "..."`.
+   Assumes runtime initializers always run on the JS thread.
+   */
+  private let jsThreadID: UInt64 = {
+    var id: UInt64 = 0
+    pthread_threadid_np(nil, &id)
+    return id
+  }()
+
   /**
    Actor for running runtime work.
    */
@@ -362,7 +373,7 @@ open class JavaScriptRuntime: Equatable, @unchecked Sendable {
       let argumentsRef = arguments.copy().ref()
 
       // Switch to asynchronous context.
-      self.schedule(taskName: "[JS] Async function \(name)") {
+      self.schedule {
         // Invoke the asynchronous function and resolve/reject the promise.
         do {
           let result = try await function(this, argumentsRef.take())
@@ -399,11 +410,10 @@ open class JavaScriptRuntime: Equatable, @unchecked Sendable {
 
   public func schedule(
     priority: SchedulerPriority = .normal,
-    taskName: String? = "[JS] runtime.schedule (\(#function))",
     @_implicitSelfCapture _ closure: @escaping @JavaScriptActor () async throws -> Void
   ) -> Void {
     schedule(priority: priority) {
-      Task.immediate_polyfill(name: taskName) {
+      Task.immediate_polyfill {
         try await closure()
       }
     }
@@ -414,8 +424,14 @@ open class JavaScriptRuntime: Equatable, @unchecked Sendable {
    Not available in async contexts to prevent blocking the cooperative thread pool.
    */
   @available(*, noasync)
+  @discardableResult
   public func execute<R: Sendable>(@_implicitSelfCapture _ closure: @escaping @JavaScriptActor () throws -> R) throws -> sending R {
+    if isOnJavaScriptThread() {
+      return try JavaScriptActor.assumeIsolated(closure)
+    }
+
     var result: Result<R, any Error>!
+    nonisolated(unsafe) let callerRunLoop = CFRunLoopGetCurrent()
 
     scheduler.scheduleTask(.ImmediatePriority) {
       do {
@@ -423,12 +439,23 @@ open class JavaScriptRuntime: Equatable, @unchecked Sendable {
       } catch {
         result = .failure(error)
       }
+      // Wake the caller's run loop so its `CFRunLoopRunInMode(...)` returns immediately
+      // instead of waiting out the timeout backstop.
+      CFRunLoopPerformBlock(callerRunLoop, CFRunLoopMode.commonModes.rawValue) {}
+      CFRunLoopWakeUp(callerRunLoop)
     }
 
-    // Use RunLoop to wait for the task to finish. As opposed to DispatchSemaphore or DispatchGroup,
-    // this solution lets the current run loop to process other events in the meantime.
+    // Pump the caller's run loop until the task finishes. As opposed to DispatchSemaphore
+    // or DispatchGroup, this lets the run loop continue to process other events in the meantime,
+    // and the spin is also faster than a real kernel-mediated context switch when the JS work
+    // is short (the common case). The 100ms timeout is a backstop in case the wakeup is missed;
+    // the common path is woken by `CFRunLoopWakeUp` from the scheduled block above.
+    //
+    // `CFRunLoopRunInMode` is the C API rather than `RunLoop.current.run(mode:before:)` to
+    // avoid the per-iteration `+[NSRunLoop currentRunLoop]` autorelease push and `Date()`
+    // allocation that dominated the caller-thread profile otherwise.
     while result == nil {
-      RunLoop.current.run(mode: .common, before: Date().addingTimeInterval(0.001))
+      CFRunLoopRunInMode(.commonModes, 0.1, false)
     }
     return try result.get()
   }
@@ -438,26 +465,40 @@ open class JavaScriptRuntime: Equatable, @unchecked Sendable {
    Not available in async contexts to prevent blocking the cooperative thread pool.
    */
   @available(*, noasync)
+  @discardableResult
   public func execute<R: Sendable>(
-    taskName: String? = "[JS] runtime.execute (\(#function))",
     @_implicitSelfCapture _ closure: @escaping @JavaScriptActor () async throws -> R
   ) throws -> sending R {
     let result = NonisolatedUnsafeVar<Result<R, any Error>>()
+    let runInline = isOnJavaScriptThread()
+    // Wrapped in `NonisolatedUnsafeVar` instead of `nonisolated(unsafe) let`
+    // to work around a Swift 6.2.3 compiler bug.
+    let callerRunLoop = NonisolatedUnsafeVar(CFRunLoopGetCurrent())
 
-    scheduler.scheduleTask(.ImmediatePriority) {
-      Task.immediate_polyfill(name: taskName, priority: .high) {
+    func body() -> Void {
+      Task.immediate_polyfill(priority: .high) {
         do {
           result.value = .success(try await closure())
         } catch {
           result.value = .failure(error)
         }
+        // Wake the caller's run loop so its `CFRunLoopRunInMode(...)` returns immediately
+        // instead of waiting out the timeout backstop.
+        CFRunLoopPerformBlock(callerRunLoop.value, CFRunLoopMode.commonModes.rawValue) {}
+        CFRunLoopWakeUp(callerRunLoop.value)
       }
     }
+    if runInline {
+      body()
+    } else {
+      scheduler.scheduleTask(.ImmediatePriority, body)
+    }
 
-    // Use RunLoop to wait for the task to finish. As opposed to DispatchSemaphore or DispatchGroup,
-    // this solution lets the current run loop to process other events in the meantime.
+    // Pump the caller's run loop until the task finishes. See the sync overload above for
+    // the rationale on `CFRunLoopRunInMode` vs. `RunLoop.current.run(...)` and on pumping
+    // the run loop instead of blocking on a semaphore.
     while result.value == nil {
-      RunLoop.current.run(mode: .common, before: Date().addingTimeInterval(0.001))
+      CFRunLoopRunInMode(.commonModes, 0.1, false)
     }
     return try result.value.get()
   }
@@ -465,9 +506,13 @@ open class JavaScriptRuntime: Equatable, @unchecked Sendable {
   /**
    Asynchronously executes a sync closure on the JavaScript runtime thread, awaiting its completion without blocking.
    */
+  @discardableResult
   public func execute<R: Sendable>(
     @_implicitSelfCapture _ closure: @escaping @JavaScriptActor () throws -> R
   ) async throws -> sending R {
+    if isOnJavaScriptThread() {
+      return try JavaScriptActor.assumeIsolated(closure)
+    }
     return try await withUnsafeThrowingContinuation { continuation in
       scheduler.scheduleTask(.ImmediatePriority) {
         do {
@@ -482,13 +527,16 @@ open class JavaScriptRuntime: Equatable, @unchecked Sendable {
   /**
    Asynchronously executes an async closure on the JavaScript runtime thread, awaiting its completion without blocking.
    */
+  @discardableResult
   public func execute<R: Sendable>(
-    taskName: String? = "[JS] runtime.execute (async \(#function))",
     @_implicitSelfCapture _ closure: @escaping @JavaScriptActor () async throws -> R
   ) async throws -> sending R {
+    if isOnJavaScriptThread() {
+      return try await Task.immediate_polyfill(priority: .high, operation: closure).value
+    }
     return try await withUnsafeThrowingContinuation { continuation in
       scheduler.scheduleTask(.ImmediatePriority) {
-        Task.immediate_polyfill(name: taskName, priority: .high) { @JavaScriptActor in
+        Task.immediate_polyfill(priority: .high) { @JavaScriptActor in
           do {
             continuation.resume(returning: try await closure())
           } catch {
@@ -502,14 +550,18 @@ open class JavaScriptRuntime: Equatable, @unchecked Sendable {
   /**
    Checks whether the function is called on the JavaScript thread.
    */
-  public func isOnJavaScriptThread() -> Bool {
-    return Thread.current.name == "com.facebook.react.runtime.JavaScript"
+  @inline(__always)
+  public final func isOnJavaScriptThread() -> Bool {
+    var current: UInt64 = 0
+    pthread_threadid_np(nil, &current)
+    return current == jsThreadID
   }
 
   /**
    Asserts whether we are on the JavaScript thread. Helpful for debugging threading issues.
    */
-  public func assertThread(file: String = #file, function: String = #function, line: Int = #line) {
+  @inline(__always)
+  public final func assertThread(file: String = #file, function: String = #function, line: Int = #line) {
     assert(isOnJavaScriptThread(), "Function '\(function)' is not run on the JavaScript thread (\(file):\(line))")
   }
 

package/apple/Tests/JavaScriptRuntimeTests.swift

@@ -1,5 +1,6 @@
 import Testing
 import ExpoModulesJSI
+import Foundation
 
 @Suite
 @JavaScriptActor
@@ -118,6 +119,49 @@ struct JavaScriptRuntimeTests {
     #expect(result == 100)
   }
 
+  // The execute<R> overloads have a same-thread fast path and a cross-thread path that
+  // schedules the closure onto the JS thread and pumps the caller's run loop until it
+  // completes. The tests above run on `@JavaScriptActor` (the JS thread), so they only
+  // exercise the fast path. The next three hop off the JS thread first to cover the
+  // cross-thread scheduling + run-loop pump. The sync overloads of `execute` are
+  // `@available(*, noasync)`, so the caller must be a real synchronous thread — wrapping
+  // in `Task.detached` would stay on the cooperative pool and trip the noasync diagnostic.
+
+  @Test
+  func `execute sync from off-thread caller`() async throws {
+    let runtime = self.runtime
+    let result = try await onSyncOffThread {
+      try runtime.execute { @JavaScriptActor in
+        return runtime.global().hasProperty("Object") ? 1 : 0
+      }
+    }
+    #expect(result == 1)
+  }
+
+  @Test
+  func `execute blocking-async from off-thread caller`() async throws {
+    let runtime = self.runtime
+    let result = try await onSyncOffThread {
+      try runtime.execute { @JavaScriptActor () async in
+        await Task.yield()
+        return runtime.global().hasProperty("Object") ? 1 : 0
+      }
+    }
+    #expect(result == 1)
+  }
+
+  @Test
+  func `execute sync rethrows from off-thread caller`() async throws {
+    let runtime = self.runtime
+    await #expect(throws: ScriptEvaluationError.self) {
+      try await onSyncOffThread {
+        try runtime.execute { @JavaScriptActor in
+          try runtime.eval("invalid syntax +++")
+        }
+      }
+    }
+  }
+
   // MARK: - Host objects
 
   @Test
@@ -698,3 +742,19 @@ struct JavaScriptRuntimeTests {
     #expect(result.getInt() == 3)
   }
 }
+
+/// Runs `body` on a freshly spawned synchronous thread and bridges the result back into the
+/// async test. The thread has a real run loop, which the cross-thread `execute` path pumps.
+private func onSyncOffThread<R: Sendable>(
+  _ body: @escaping @Sendable () throws -> R
+) async throws -> R {
+  return try await withCheckedThrowingContinuation { (continuation: CheckedContinuation<R, any Error>) in
+    Thread.detachNewThread {
+      do {
+        continuation.resume(returning: try body())
+      } catch {
+        continuation.resume(throwing: error)
+      }
+    }
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "expo-modules-jsi",
-  "version": "56.0.4",
+  "version": "56.0.5",
   "description": "The JavaScript Interface for Expo Modules",
   "main": "index.js",
   "sideEffects": [],
@@ -41,7 +41,7 @@
       "./apple/scripts/test.sh"
     ]
   },
-  "gitHead": "51c27fce31a5b3a877a4b05d832dabf4a99db5e1",
+  "gitHead": "f26be3dd9396bf7c399a1d607865d0fabdbc0d64",
   "scripts": {
     "build": "apple/scripts/build-xcframework.sh",
     "test": "apple/scripts/test.sh"