expo-modules-jsi 57.0.5 → 57.0.7

package/CHANGELOG.md

@@ -10,6 +10,19 @@
 
 ### 💡 Others
 
+## 57.0.7 — 2026-09-01
+
+### 💡 Others
+
+- [iOS] `JavaScriptValue.undefined` and `JavaScriptValue.null` now return shared immortal instances instead of allocating a new value on each access, removing one allocation from every void-returning host call. ([#49545](https://github.com/expo/expo/pull/49545) by [@tsapeta](https://github.com/tsapeta))
+- [iOS] `CppError::tryCatch` now takes a C++ callable instead of an Objective-C block. Every caller already passes a pure C++ body, so the block bridged no Swift closure and only added a non-inlinable indirect call and an Objective-C runtime dependency on the JS call/eval error-handling path. ([#48333](https://github.com/expo/expo/pull/48333) by [@tsapeta](https://github.com/tsapeta))
+
+## 57.0.6 — 2026-08-26
+
+### 💡 Others
+
+- [iOS] `JavaScriptActor.assumeIsolated` no longer heap-allocates a closure box per call by keeping its `operation` non-escaping, making synchronous host calls ~1.6× faster. ([#47837](https://github.com/expo/expo/pull/47837) by [@tsapeta](https://github.com/tsapeta))
+
 ## 57.0.5 — 2026-08-20
 
 ### 🐛 Bug fixes

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

@@ -1,8 +1,5 @@
 import Foundation
 
-/// Name of the JavaScript thread created by React Native. Copied from `RCTJSThreadManager.mm`.
-private let jsThreadName = "com.facebook.react.runtime.JavaScript"
-
 /// Global actor that is used to isolate the code that should only be executed from the JavaScript thread.
 /// Theoretically it does not act as a real actor; it uses a serial executor that executes jobs **synchronously**
 /// without hopping to the proper thread. Meaning that running these jobs on the JavaScript thread must be ensured
@@ -23,25 +20,56 @@ public actor JavaScriptActor: GlobalActor {
   /// An equivalent of `MainActor.assumeIsolated`, but for the `JavaScriptActor`. Assumes that the currently executing
   /// synchronous function is actually executing on the JavaScript thread and invokes an isolated version of the operation,
   /// allowing synchronous access to JavaScript runtime state without hopping through asynchronous boundaries.
-  ///
-  /// See https://stackoverflow.com/a/79346971 for more information about the implementation.
-  public static func assumeIsolated<T: ~Copyable>(_ operation: @JavaScriptActor () throws -> T) rethrows -> T {
-    typealias YesActor = @JavaScriptActor () throws -> T
-    typealias NoActor = () throws -> T
+  /// The nonthrowing overload keeps `operation` nonescaping so its captured context can remain stack-allocated.
+  @_alwaysEmitIntoClient
+  @inline(__always)
+  public static func assumeIsolated<T: ~Copyable>(_ operation: @JavaScriptActor () -> T) -> T {
+    typealias IsolatedRunner = @JavaScriptActor (@JavaScriptActor () -> T) -> T
+    typealias NonisolatedRunner = (@JavaScriptActor () -> T) -> T
 
     // This will crash if the current context cannot be isolated.
-    shared.executor.checkIsolated()
+    checkIsolated()
+
+    // Cast the capture-free runner rather than `operation` itself. `operation` remains nonescaping,
+    // so its captures can stay in the caller's stack frame.
+    let runner = unsafeBitCast(runIsolated as IsolatedRunner, to: NonisolatedRunner.self)
+    return runner(operation)
+  }
 
-    // To do the unsafe cast, we have to pretend it's @escaping.
-    return try withoutActuallyEscaping(operation) { (_ fn: @escaping YesActor) throws -> T in
-      let rawFn = unsafeBitCast(fn, to: NoActor.self)
-      return try rawFn()
+  /// Throwing counterpart to the nonthrowing overload above. The generic error type keeps
+  /// `operation` nonescaping while preserving the exact error it can throw.
+  @_alwaysEmitIntoClient
+  @inline(__always)
+  public static func assumeIsolated<T: ~Copyable, E: Error>(
+    _ operation: @JavaScriptActor () throws(E) -> T
+  ) throws(E) -> T {
+    // Casting a `throws(E)` function value requires newer OS runtime support. Wrapping the
+    // operation in the nonthrowing fast path keeps this backdeployable and stack-allocated.
+    let result: Result<T, E> = assumeIsolated {
+      return Result(catching: operation)
     }
+    return try result.get()
   }
 
-  /// Stops program execution if the actor's executor is not isolating the current context.
+  /// In debug builds, asserts if the actor's executor is not isolating the current context.
+  @inlinable
+  @inline(__always)
   public static func checkIsolated() {
-    shared.executor.checkIsolated()
+    // Using `assert` instead of `precondition` because this check is a heuristic based on
+    // thread name, not a precise isolation guarantee. Worklet runtimes legitimately run on
+    // the UI thread, which would cause a false-positive crash with `precondition`.
+    assert(
+      // JavaScript thread name copied from `RCTJSThreadManager.mm`.
+      Thread.current.name == "com.facebook.react.runtime.JavaScript" || !Thread.isMultiThreaded()
+        || ProcessInfo.processInfo.processName == "xctest",
+      "JavaScriptActor operations must be run on the JavaScript thread"
+    )
+  }
+
+  @JavaScriptActor
+  @usableFromInline
+  internal static func runIsolated<T: ~Copyable>(_ operation: @JavaScriptActor () -> T) -> T {
+    return operation()
   }
 }
 
@@ -57,20 +85,11 @@ internal class JavaScriptExecutor: SerialExecutor, @unchecked Sendable {
     return UnownedSerialExecutor(ordinary: self)
   }
 
-  /// Stops program execution if the executor is not isolating the current context.
+  /// Runtime hook used by Swift's actor data-race checks for synchronous entry into
+  /// `@JavaScriptActor` code. Do not remove: the `SerialExecutor` default always fails
+  /// when there is no active Swift task carrying this executor.
   func checkIsolated() {
-    // Using `assert` instead of `precondition` because this check is a heuristic based on
-    // thread name, not a precise isolation guarantee. Worklet runtimes legitimately run on
-    // the UI thread, which would cause a false-positive crash with `precondition`.
-    assert(isIsolatingCurrentContext() == true, "JavaScriptActor operations must be run on the JavaScript thread")
-  }
-
-  /// Checks whether the executor isolates the current context, i.e. the current thread is a JavaScript thread.
-  /// The condition is also met when running tests and in single threaded environments.
-  func isIsolatingCurrentContext() -> Bool? {
-    // We must be careful as it relies on the thread name given by React Native.
-    return Thread.current.name == jsThreadName || !Thread.isMultiThreaded()
-      || ProcessInfo.processInfo.processName == "xctest"
+    JavaScriptActor.checkIsolated()
   }
 }
 

package/apple/Sources/ExpoModulesJSI/Runtime/Values/JavaScriptValue.swift

@@ -600,18 +600,25 @@ public final class JavaScriptValue: JavaScriptType, Equatable, Escapable {
 
   // MARK: - Runtime-free initializers
 
+  // Shared immortal instances for the runtime-free `undefined`/`null` kinds. The class is fully
+  // immutable and these carry no runtime and a trivial `jsi::Value`, so one instance can be safely
+  // handed out from any isolation context. Every void-returning `@JS` function returns `.undefined`,
+  // so a computed getter here would allocate on every host call.
+  private static let sharedUndefined = JavaScriptValue(nil, facebook.jsi.Value.undefined())
+  private static let sharedNull = JavaScriptValue(nil, facebook.jsi.Value.null())
+
   /// This is a lightweight way to create an undefined value that can be used in contexts
   /// where a runtime is not available or needed. The resulting value can be passed to
   /// JavaScript functions or used in comparisons.
   public static var undefined: JavaScriptValue {
-    JavaScriptValue(nil, facebook.jsi.Value.undefined())
+    return sharedUndefined
   }
 
   /// This is a lightweight way to create a null value that can be used in contexts
   /// where a runtime is not available or needed. The resulting value represents
   /// JavaScript's `null`, which is distinct from `undefined`.
   public static var null: JavaScriptValue {
-    JavaScriptValue(nil, facebook.jsi.Value.null())
+    return sharedNull
   }
 
   /// This is a lightweight way to create a boolean true value that can be used in contexts

package/apple/Sources/ExpoModulesJSI-Cxx/include/CppError.h

@@ -68,12 +68,18 @@ public:
   }
 
   /**
-   Executes a block of code and catches any C++ exceptions that are thrown.
+   Executes a C++ callable and catches any C++ exceptions that are thrown.
    Caught exceptions are stored in thread-local storage and can be retrieved
    using `getCurrent()`. The function returns `nullptr` when an exception occurs.
+
+   Takes a forwarding reference to a C++ callable (e.g. a lambda) rather than an
+   Objective-C block. Every caller passes a pure C++ body, so no Swift closure
+   crosses this boundary; the block only added a non-inlinable indirect call and
+   a dependency on the Objective-C runtime. This helper is C++-only and is not
+   imported into Swift.
    */
-  template <typename Result>
-  inline static Result tryCatch(jsi::IRuntime &runtime, Result(^block)(void)) {
+  template <typename Fn>
+  inline static auto tryCatch(jsi::IRuntime &runtime, Fn &&block) -> decltype(block()) {
     try {
       return block();
     } catch (jsi::JSError e) {

package/apple/Sources/ExpoModulesJSI-Cxx/include/JSIUtils.h

@@ -136,25 +136,25 @@ inline void destroyRuntime(jsi::Runtime &runtime) {
 }
 
 inline jsi::Value evaluateJavaScript(jsi::IRuntime &runtime, const std::shared_ptr<const jsi::Buffer>& buffer, const std::string& sourceURL) {
-  return expo::CppError::tryCatch(runtime, ^{
+  return expo::CppError::tryCatch(runtime, [&] {
     return runtime.evaluateJavaScript(buffer, sourceURL);
   });
 }
 
 inline jsi::Value callFunction(jsi::IRuntime &runtime, const jsi::Function &function, const jsi::Value *_Nullable args, size_t count) {
-  return expo::CppError::tryCatch(runtime, ^{
+  return expo::CppError::tryCatch(runtime, [&] {
     return function.call(runtime, args, count);
   });
 }
 
 inline jsi::Value callFunctionWithThis(jsi::IRuntime &runtime, const jsi::Function &function, const jsi::Object &jsThis, const jsi::Value *_Nullable args, size_t count) {
-  return expo::CppError::tryCatch(runtime, ^{
+  return expo::CppError::tryCatch(runtime, [&] {
     return function.callWithThis(runtime, jsThis, args, count);
   });
 }
 
 inline jsi::Value callAsConstructor(jsi::IRuntime &runtime, const jsi::Function &function, const jsi::Value *_Nullable args, size_t count) {
-  return expo::CppError::tryCatch(runtime, ^{
+  return expo::CppError::tryCatch(runtime, [&] {
     return function.callAsConstructor(runtime, args, count);
   });
 }

package/apple/Tests/JavaScriptActorTests.swift

@@ -58,6 +58,17 @@ struct JavaScriptActorTests {
     }
   }
 
+  @Test
+  func `assumeIsolated preserves typed error`() {
+    struct CustomError: Error {}
+
+    #expect(throws: CustomError.self) {
+      try JavaScriptActor.assumeIsolated { () throws(CustomError) -> Int in
+        throw CustomError()
+      }
+    }
+  }
+
   @Test
   func `assumeIsolated can modify captured variables`() {
     var counter = 0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "expo-modules-jsi",
-  "version": "57.0.5",
+  "version": "57.0.7",
   "description": "The JavaScript Interface for Expo Modules",
   "main": "index.js",
   "sideEffects": [],
@@ -41,7 +41,7 @@
       "./apple/scripts/test.sh"
     ]
   },
-  "gitHead": "499024a441d67293aa60afcbe02051999a54f1bb",
+  "gitHead": "b76ecf192c5325793bcea31dd9bb8efd91f9ad7f",
   "scripts": {
     "build": "apple/scripts/build-xcframework.sh",
     "clean": "apple/scripts/clear-caches.sh",