expo-modules-jsi 57.0.4 → 57.0.6

package/CHANGELOG.md

@@ -10,6 +10,19 @@
 
 ### 💡 Others
 
+## 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
+
+- [iOS] Fixed `dateFromMilliseconds` failing to compile with "type of expression is ambiguous" under newer toolchains: the unqualified `abs(_:)` in the `Double` overflow guard is ambiguous once C++ interop brings the C `abs` overloads into scope, so use `Double.magnitude` instead. ([#49039](https://github.com/expo/expo/pull/49039) by [@kraenhansen](https://github.com/kraenhansen))
+- [iOS] Fixed the xcframework prebuild failing under Xcode 27 due to new foreign reference ownership warnings emitted for `RuntimeScheduler` constructors. ([#49120](https://github.com/expo/expo/pull/49120) by [@tsapeta](https://github.com/tsapeta))
+
 ## 57.0.4 — 2026-07-22
 
 ### 💡 Others

package/apple/Sources/ExpoModulesJSI/Coding/JavaScriptCodable+Date.swift

@@ -50,7 +50,7 @@ let maxJavaScriptDateMilliseconds: Double = 8_640_000_000_000_000
 /// faithful to `new Date(number)`; the `Date`/string branches pass an already-clipped `getTime()` through.
 @usableFromInline
 func dateFromMilliseconds(_ milliseconds: Double) throws -> Date {
-  guard milliseconds.isFinite, abs(milliseconds) <= maxJavaScriptDateMilliseconds else {
+  guard milliseconds.isFinite, milliseconds.magnitude <= maxJavaScriptDateMilliseconds else {
     throw InvalidDateException()
   }
   return Date(timeIntervalSince1970: milliseconds.rounded(.towardZero) / 1000.0)

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-Cxx/include/RuntimeScheduler.h

@@ -50,7 +50,7 @@ public:
    `scheduleTask` dispatches through `fn`, which the host implements against
    the real react::RuntimeScheduler.
    */
-  RuntimeScheduler(void *scheduler, ScheduleFn fn) noexcept
+  SWIFT_RETURNS_RETAINED RuntimeScheduler(void *scheduler, ScheduleFn fn) noexcept
       : nativeScheduler(scheduler), scheduleFn(fn) {}
 
   /**
@@ -58,7 +58,7 @@ public:
    caller's thread — intended for standalone runtimes (e.g. tests) that have
    no React scheduler.
    */
-  RuntimeScheduler() {}
+  SWIFT_RETURNS_RETAINED RuntimeScheduler() {}
 
   RuntimeScheduler(const RuntimeScheduler &) = delete;
 

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.4",
+  "version": "57.0.6",
   "description": "The JavaScript Interface for Expo Modules",
   "main": "index.js",
   "sideEffects": [],
@@ -41,7 +41,7 @@
       "./apple/scripts/test.sh"
     ]
   },
-  "gitHead": "a4789f1e53353f4929b0baddcfe5a7c622b99c71",
+  "gitHead": "c300d2cc60c9e684e64f48d9bc90ea18a571d01d",
   "scripts": {
     "build": "apple/scripts/build-xcframework.sh",
     "clean": "apple/scripts/clear-caches.sh",