expo-modules-jsi 58.0.8 → 58.0.9

package/CHANGELOG.md

@@ -1,5 +1,15 @@
 # Changelog
 
+## 58.0.9
+
+### Patch Changes
+
+- [iOS] Add a `JavaScriptCodable` conformance for `Set`: it encodes to a JS `Set` and decodes from a JS `Set` or an array, collapsing duplicate elements. ([#50859](https://github.com/expo/expo/pull/50859) by [@tsapeta](https://github.com/tsapeta))
+- `JavaScriptRuntime.evalAsync` now evaluates on the JavaScript thread when called from another thread on a runtime with a scheduler, instead of on the calling thread. ([#51015](https://github.com/expo/expo/pull/51015) by [@tsapeta](https://github.com/tsapeta))
+- [iOS] Speed up `JavaScriptObject.defineProperty` by looking up `Object.defineProperty` once per runtime and building the descriptor in C++. ([#51004](https://github.com/expo/expo/pull/51004) by [@tsapeta](https://github.com/tsapeta))
+- [iOS] Fix the xcframework failing to build with Xcode 26 (Swift 6.2): `RuntimeScheduler` constructors annotated with `SWIFT_RETURNS_RETAINED` were rejected, and host function and host object getter callbacks failed with `sending '...' risks causing data races`. ([#51040](https://github.com/expo/expo/pull/51040) by [@tsapeta](https://github.com/tsapeta))
+- [iOS] Speed up integer arguments and results of native functions by running the integer conversions specialized inside `ExpoModulesJSI` instead of unspecialized in the calling module. A host function that adds two `Int`s runs about 7× faster. ([#51055](https://github.com/expo/expo/pull/51055) by [@tsapeta](https://github.com/tsapeta))
+
 ## 58.0.8
 
 ### Patch Changes

package/apple/Benchmarks/ContainerCodingBenchmarks.swift

@@ -0,0 +1,74 @@
+// Copyright 2026-present 650 Industries. All rights reserved.
+
+import ExpoModulesJSI
+import Testing
+
+/// Benchmarks comparing the `Array` and `Set` `JavaScriptCodable` conformances. `Set` decoding from a
+/// JS array shares the `Array` fast path and adds only the hashing, while decoding from a JS `Set` and
+/// encoding to one go through the global `Array.from` and `Set` constructor, so each case is measured
+/// against its `Array` counterpart at a small and a large element count.
+extension JSIBenchmarks {
+  // MARK: - Decode
+
+  @Test(arguments: [10, 1000])
+  func `decode an array of ints as Array`(count: Int) async throws {
+    try await benchmarkCase { runtime in
+      let value = try runtime.eval("Array.from({ length: \(count) }, (_, i) => i)")
+      try benchmark("[Int].decode: JS array of \(count)", runtime: runtime) { iterations in
+        for _ in 0..<iterations {
+          _ = try [Int].decode(value, in: runtime)
+        }
+      }
+    }
+  }
+
+  @Test(arguments: [10, 1000])
+  func `decode an array of ints as Set`(count: Int) async throws {
+    try await benchmarkCase { runtime in
+      let value = try runtime.eval("Array.from({ length: \(count) }, (_, i) => i)")
+      try benchmark("Set<Int>.decode: JS array of \(count)", runtime: runtime) { iterations in
+        for _ in 0..<iterations {
+          _ = try Set<Int>.decode(value, in: runtime)
+        }
+      }
+    }
+  }
+
+  @Test(arguments: [10, 1000])
+  func `decode a set of ints as Set`(count: Int) async throws {
+    try await benchmarkCase { runtime in
+      let value = try runtime.eval("new Set(Array.from({ length: \(count) }, (_, i) => i))")
+      try benchmark("Set<Int>.decode: JS Set of \(count)", runtime: runtime) { iterations in
+        for _ in 0..<iterations {
+          _ = try Set<Int>.decode(value, in: runtime)
+        }
+      }
+    }
+  }
+
+  // MARK: - Encode
+
+  @Test(arguments: [10, 1000])
+  func `encode an Array of ints`(count: Int) async throws {
+    try await benchmarkCase { runtime in
+      let array = Array(0..<count)
+      try benchmark("[Int].encode: \(count) elements", runtime: runtime) { iterations in
+        for _ in 0..<iterations {
+          _ = try [Int].encode(array, in: runtime)
+        }
+      }
+    }
+  }
+
+  @Test(arguments: [10, 1000])
+  func `encode a Set of ints`(count: Int) async throws {
+    try await benchmarkCase { runtime in
+      let set = Set(0..<count)
+      try benchmark("Set<Int>.encode: \(count) elements", runtime: runtime) { iterations in
+        for _ in 0..<iterations {
+          _ = try Set<Int>.encode(set, in: runtime)
+        }
+      }
+    }
+  }
+}

package/apple/Benchmarks/HostFunctionBenchmarks.swift

@@ -87,6 +87,47 @@ extension JSIBenchmarks {
     }
   }
 
+  // The integer codables, as bindings call them: `Int.decode` for an `Int` argument and `Int?.decode`
+  // for an optional one.
+
+  @Test
+  func `host function adding two Ints`() async throws {
+    try await benchmarkCase { runtime in
+      let fn = runtime.createFunction("add") {
+        [runtime] (this: borrowing JavaScriptUnownedValue, arguments: consuming JavaScriptValuesBuffer) in
+        let a = try Int.decode(arguments.unownedValue(at: 0), in: runtime)
+        let b = try Int.decode(arguments.unownedValue(at: 1), in: runtime)
+        return try Int.encode(a + b, in: runtime)
+      }
+      runtime.global().setProperty("benchFn", value: fn)
+      let driver = try runtime.eval(
+        "(function(n) { for (var i = 0; i < n; i++) benchFn(3, 38); })"
+      ).getFunction()
+      try benchmark("host function: add two Ints", runtime: runtime) { iterations in
+        _ = try driver.call(arguments: iterations)
+      }
+    }
+  }
+
+  @Test
+  func `host function adding two optional Ints`() async throws {
+    try await benchmarkCase { runtime in
+      let fn = runtime.createFunction("add") {
+        [runtime] (this: borrowing JavaScriptUnownedValue, arguments: consuming JavaScriptValuesBuffer) in
+        let a = try Int?.decode(arguments.unownedValue(at: 0), in: runtime) ?? 0
+        let b = try Int?.decode(arguments.unownedValue(at: 1), in: runtime) ?? 0
+        return try Int.encode(a + b, in: runtime)
+      }
+      runtime.global().setProperty("benchFn", value: fn)
+      let driver = try runtime.eval(
+        "(function(n) { for (var i = 0; i < n; i++) benchFn(3, 38); })"
+      ).getFunction()
+      try benchmark("host function: add two optional Ints", runtime: runtime) { iterations in
+        _ = try driver.call(arguments: iterations)
+      }
+    }
+  }
+
   // MARK: - Unowned-this form with string arguments
 
   @Test

package/apple/Benchmarks/ValueAccessBenchmarks.swift

@@ -129,4 +129,27 @@ extension JSIBenchmarks {
       }
     }
   }
+
+  @Test
+  func `define a property`() async throws {
+    try await benchmarkCase { runtime in
+      try benchmark("JavaScriptObject.defineProperty(_:value:options:)", runtime: runtime) { iterations in
+        for index in 0..<iterations {
+          let object = runtime.createObject()
+          object.defineProperty("__expo_shared_object_id__", value: index, options: [.writable])
+        }
+      }
+    }
+  }
+
+  @Test
+  func `create an object`() async throws {
+    try await benchmarkCase { runtime in
+      try benchmark("JavaScriptRuntime.createObject()", runtime: runtime) { iterations in
+        for _ in 0..<iterations {
+          _ = runtime.createObject()
+        }
+      }
+    }
+  }
 }

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

@@ -482,13 +482,134 @@ extension UInt64: JavaScriptCodable {
   }
 }
 
+// MARK: - Integer conversion entry points
+
+// The inlinable integer witnesses call these non-generic overloads rather than the generic
+// implementations below. A client can devirtualize a witness and inline it only when its body calls
+// non-generic functions; through a generic, non-inlinable call, it falls back to dynamic dispatch, and a
+// direct call runs the generic implementation unspecialized. Each overload runs a copy of the generic
+// implementation specialized inside the framework.
+
+@usableFromInline
+@JavaScriptActor
+func decodeInteger(_ number: Double, as type: Int8.Type) throws -> Int8 {
+  return try genericDecodeInteger(number, as: Int8.self)
+}
+
+@usableFromInline
+@JavaScriptActor
+func decodeInteger(_ number: Double, as type: Int16.Type) throws -> Int16 {
+  return try genericDecodeInteger(number, as: Int16.self)
+}
+
+@usableFromInline
+@JavaScriptActor
+func decodeInteger(_ number: Double, as type: Int32.Type) throws -> Int32 {
+  return try genericDecodeInteger(number, as: Int32.self)
+}
+
+@usableFromInline
+@JavaScriptActor
+func decodeInteger(_ number: Double, as type: UInt8.Type) throws -> UInt8 {
+  return try genericDecodeInteger(number, as: UInt8.self)
+}
+
+@usableFromInline
+@JavaScriptActor
+func decodeInteger(_ number: Double, as type: UInt16.Type) throws -> UInt16 {
+  return try genericDecodeInteger(number, as: UInt16.self)
+}
+
+@usableFromInline
+@JavaScriptActor
+func decodeInteger(_ number: Double, as type: UInt32.Type) throws -> UInt32 {
+  return try genericDecodeInteger(number, as: UInt32.self)
+}
+
+@usableFromInline
+@JavaScriptActor
+func decodeWideInteger(_ value: borrowing JavaScriptValue, as type: Int.Type) throws -> Int {
+  return try genericDecodeWideInteger(value, as: Int.self)
+}
+
+@usableFromInline
+@JavaScriptActor
+func decodeWideInteger(
+  _ value: borrowing JavaScriptUnownedValue,
+  as type: Int.Type,
+  runtime: borrowing JavaScriptRuntime
+) throws -> Int {
+  return try genericDecodeWideInteger(value, as: Int.self, runtime: runtime)
+}
+
+@usableFromInline
+@JavaScriptActor
+func decodeWideInteger(_ value: borrowing JavaScriptValue, as type: Int64.Type) throws -> Int64 {
+  return try genericDecodeWideInteger(value, as: Int64.self)
+}
+
+@usableFromInline
+@JavaScriptActor
+func decodeWideInteger(
+  _ value: borrowing JavaScriptUnownedValue,
+  as type: Int64.Type,
+  runtime: borrowing JavaScriptRuntime
+) throws -> Int64 {
+  return try genericDecodeWideInteger(value, as: Int64.self, runtime: runtime)
+}
+
+@usableFromInline
+@JavaScriptActor
+func decodeWideInteger(_ value: borrowing JavaScriptValue, as type: UInt.Type) throws -> UInt {
+  return try genericDecodeWideInteger(value, as: UInt.self)
+}
+
+@usableFromInline
+@JavaScriptActor
+func decodeWideInteger(
+  _ value: borrowing JavaScriptUnownedValue,
+  as type: UInt.Type,
+  runtime: borrowing JavaScriptRuntime
+) throws -> UInt {
+  return try genericDecodeWideInteger(value, as: UInt.self, runtime: runtime)
+}
+
+@usableFromInline
+@JavaScriptActor
+func decodeWideInteger(_ value: borrowing JavaScriptValue, as type: UInt64.Type) throws -> UInt64 {
+  return try genericDecodeWideInteger(value, as: UInt64.self)
+}
+
+@usableFromInline
+@JavaScriptActor
+func decodeWideInteger(
+  _ value: borrowing JavaScriptUnownedValue,
+  as type: UInt64.Type,
+  runtime: borrowing JavaScriptRuntime
+) throws -> UInt64 {
+  return try genericDecodeWideInteger(value, as: UInt64.self, runtime: runtime)
+}
+
+@usableFromInline
+@JavaScriptActor
+func encodeSafeInteger(_ value: Int) throws -> JavaScriptValue {
+  return try genericEncodeSafeInteger(value)
+}
+
+@usableFromInline
+@JavaScriptActor
+func encodeSafeInteger(_ value: UInt) throws -> JavaScriptValue {
+  return try genericEncodeSafeInteger(value)
+}
+
+// MARK: - Generic integer conversions
+
 /// Rounds a JavaScript number to the nearest integer and narrows it to `T`, throwing instead of
 /// trapping when the value is non-finite or outside `T`'s representable range. `T(exactly:)` on the
 /// already-rounded value is nil only when out of range, sidestepping the lossy `Double(T.max)`
 /// boundary comparison for 64-bit widths.
-@usableFromInline
 @JavaScriptActor
-func decodeInteger<T: FixedWidthInteger>(_ number: Double, as type: T.Type) throws -> T {
+func genericDecodeInteger<T: FixedWidthInteger>(_ number: Double, as type: T.Type) throws -> T {
   guard number.isFinite, let result = T(exactly: number.rounded()) else {
     throw IntegerOutOfRangeException(value: number, type: "\(T.self)")
   }
@@ -499,47 +620,41 @@ func decodeInteger<T: FixedWidthInteger>(_ number: Double, as type: T.Type) thro
 /// case is checked first since it's the common one: a single `isNumber()` tag check, then the
 /// assert-only `getDouble()` reads the value without re-checking the tag. A `bigint` is read losslessly
 /// through its 64-bit accessor; anything else throws the same `TypeError` the `number` read would.
-@usableFromInline
 @JavaScriptActor
-func decodeWideInteger<T: FixedWidthInteger>(_ value: borrowing JavaScriptValue, as type: T.Type) throws -> T {
+func genericDecodeWideInteger<T: FixedWidthInteger>(_ value: borrowing JavaScriptValue, as type: T.Type) throws -> T {
   guard value.isNumber() else {
     guard value.isBigInt() else {
-      // Neither a number nor a bigint: `asDouble()` throws the canonical `TypeError`. Throwing it
-      // through the accessor (rather than constructing it here) keeps this inlinable helper from
-      // referencing `TypeError`'s internal memberwise initializer.
-      return try decodeInteger(value.asDouble(), as: T.self)
+      // Neither a number nor a bigint: `asDouble()` throws the canonical `TypeError`.
+      return try genericDecodeInteger(value.asDouble(), as: T.self)
     }
-    return try decodeBigInt(value.getBigInt(), as: T.self)
+    return try genericDecodeBigInt(value.getBigInt(), as: T.self)
   }
-  return try decodeInteger(value.getDouble(), as: T.self)
+  return try genericDecodeInteger(value.getDouble(), as: T.self)
 }
 
 /// `JavaScriptUnownedValue` overload of `decodeWideInteger`. The common `number` path stays zero-copy
 /// and pays a single tag check (see the owning overload); only a `bigint` materializes an owning value
 /// (the borrowed value exposes no BigInt accessor), which is acceptable on this rare branch.
-@usableFromInline
 @JavaScriptActor
-func decodeWideInteger<T: FixedWidthInteger>(
+func genericDecodeWideInteger<T: FixedWidthInteger>(
   _ value: borrowing JavaScriptUnownedValue,
   as type: T.Type,
   runtime: borrowing JavaScriptRuntime
 ) throws -> T {
   guard value.isNumber() else {
     guard value.isBigInt() else {
-      // See the owning overload: route the not-a-number throw through `asDouble()` rather than
-      // constructing `TypeError` here, which this inlinable helper can't reference.
-      return try decodeInteger(value.asDouble(), as: T.self)
+      // Neither a number nor a bigint: `asDouble()` throws the canonical `TypeError`.
+      return try genericDecodeInteger(value.asDouble(), as: T.self)
     }
-    return try decodeBigInt(value.copied(in: runtime).getBigInt(), as: T.self)
+    return try genericDecodeBigInt(value.copied(in: runtime).getBigInt(), as: T.self)
   }
-  return try decodeInteger(value.getDouble(), as: T.self)
+  return try genericDecodeInteger(value.getDouble(), as: T.self)
 }
 
 /// Narrows a `JavaScriptBigInt` to `T`, reading it through the signed or unsigned 64-bit accessor to
 /// match `T`'s signedness and throwing rather than truncating when it falls outside `T`'s range.
-@usableFromInline
 @JavaScriptActor
-func decodeBigInt<T: FixedWidthInteger>(_ bigInt: borrowing JavaScriptBigInt, as type: T.Type) throws -> T {
+func genericDecodeBigInt<T: FixedWidthInteger>(_ bigInt: borrowing JavaScriptBigInt, as type: T.Type) throws -> T {
   let wide: T? =
     if T.isSigned {
       bigInt.isInt64() ? T(exactly: bigInt.getInt64()) : nil
@@ -555,9 +670,8 @@ func decodeBigInt<T: FixedWidthInteger>(_ bigInt: borrowing JavaScriptBigInt, as
 /// Encodes a 64-bit-wide integer to a JS `number`, throwing when it falls outside JavaScript's
 /// safe-integer range where a `Double` could no longer represent it exactly. Used by `Int`/`UInt`,
 /// whose JS mapping stays a `number`; the explicitly-sized 64-bit types encode as a `bigint` instead.
-@usableFromInline
 @JavaScriptActor
-func encodeSafeInteger<T: FixedWidthInteger>(_ value: T) throws -> JavaScriptValue {
+func genericEncodeSafeInteger<T: FixedWidthInteger>(_ value: T) throws -> JavaScriptValue {
   // `Number.MAX_SAFE_INTEGER` (2^53 - 1): the largest magnitude where every integer up to it, and the
   // next one, is representable as a JS number. 2^53 itself is representable but unsafe (it collides with
   // 2^53 + 1), so the bound is exclusive above this. Used by `Int`/`UInt`, both 64-bit, so 2^53 fits.

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

@@ -0,0 +1,79 @@
+// Copyright 2026-present 650 Industries. All rights reserved.
+
+internal import ExpoModulesJSI_Cxx
+internal import jsi
+
+// `Set` encodes to a JS `Set` and decodes from a JS `Set` or, like `Array`, from an array or an arrayized
+// scalar. JSI has no `Set` API, so the conversions go through the runtime's global `Set` and `Array`
+// constructors. Equality differs between the two sides: a JS `Set` compares objects by reference while
+// a Swift `Set` compares by `Hashable`, so two distinct JS objects that decode to equal values collapse
+// into a single element.
+
+extension Set: JavaScriptDecodable where Element: JavaScriptDecodable {
+  @JavaScriptActor
+  @inlinable
+  public static func decode(_ value: borrowing JavaScriptValue, in runtime: borrowing JavaScriptRuntime) throws
+    -> Set<Element>
+  {
+    // The cheap tag checks come first: an array takes the `Array` path directly, and a primitive
+    // can't be a JS `Set`, so both skip the JS call below. Any other value that is not a JS `Set` is
+    // arrayized, as in `Array`. Duplicates in an array collapse without an error.
+    guard !value.isArray(), value.isObject(), let entries = try runtime.setEntries(of: value) else {
+      return Set(try [Element].decode(value, in: runtime))
+    }
+    return Set(try [Element].decode(entries, in: runtime))
+  }
+}
+
+extension Set: JavaScriptEncodable where Element: JavaScriptEncodable {
+  @JavaScriptActor
+  @inlinable
+  public static func encode(_ value: Set<Element>, in runtime: borrowing JavaScriptRuntime) throws
+    -> JavaScriptValue
+  {
+    // Constructing from an array fills the set in a single call, rather than one `add` call per element.
+    let entries = try [Element].encode(Array(value), in: runtime)
+    return try runtime.setConstructor().callAsConstructor(entries)
+  }
+}
+
+extension JavaScriptRuntime {
+  /// Copies the entries of a JS `Set` out into a JS array, or returns `nil` when the value is not a
+  /// JS `Set`. The instance check and the copy run in a single call to a cached JS function, which
+  /// saves the global lookups and the separate `instanceof` call of `value.is("Set")` followed by
+  /// `Array.from`. For a small `Set` those fixed costs are most of the decode time.
+  @usableFromInline
+  @JavaScriptActor
+  func setEntries(of value: borrowing JavaScriptValue) throws -> JavaScriptValue? {
+    let function = try cached(setEntriesFunctionKey) {
+      return try eval(
+        label: "expo-modules-jsi/set-entries.js",
+        "(function (value) { return value instanceof Set ? Array.from(value) : undefined; })"
+      )
+    }
+    let setEntries = function.getFunction()
+    // Pass the borrowed `jsi::Value` straight to the call, rather than copying it into an owned value
+    // and again into an arguments buffer.
+    let entries = try withUnsafePointer(to: value.pointee) { argument in
+      return try capturingCppErrors {
+        return JavaScriptValue(self, expo.callFunction(pointee, setEntries.pointee, argument, 1))
+      }
+    }
+    return entries.isUndefined() ? nil : entries
+  }
+
+  /// Returns the global `Set` constructor, looked up once and cached, so an encode doesn't pay for
+  /// the global property lookup.
+  @usableFromInline
+  @JavaScriptActor
+  func setConstructor() throws -> JavaScriptFunction {
+    let constructor = try cached(setConstructorKey) {
+      return try global().getPropertyAsFunction("Set").asValue()
+    }
+    return constructor.getFunction()
+  }
+}
+
+/// Keys of the `Set` entries function and the `Set` constructor in each runtime's cache.
+private let setEntriesFunctionKey = JavaScriptRuntime.Cache.Key<JavaScriptValue>()
+private let setConstructorKey = JavaScriptRuntime.Cache.Key<JavaScriptValue>()

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

@@ -67,7 +67,7 @@ open class JavaScriptRuntime: Equatable, Identifiable, @unchecked Sendable {
     self.runtimePointee = runtime
     self.pointee = expo.iruntime(runtime)
     self.handle = JavaScriptRuntimeHandle(self.pointee)
-    self.scheduler = expo.RuntimeScheduler()
+    self.scheduler = expo.RuntimeScheduler.create()
     self.ownsRuntime = false
     handle.attach(self)
     installLongLivedObjectsTeardown()
@@ -80,7 +80,7 @@ open class JavaScriptRuntime: Equatable, Identifiable, @unchecked Sendable {
     self.runtimePointee = runtime
     self.pointee = expo.iruntime(runtime)
     self.handle = JavaScriptRuntimeHandle(self.pointee)
-    self.scheduler = expo.RuntimeScheduler()
+    self.scheduler = expo.RuntimeScheduler.create()
     self.ownsRuntime = true
     handle.attach(self)
     installLongLivedObjectsTeardown()
@@ -94,7 +94,7 @@ open class JavaScriptRuntime: Equatable, Identifiable, @unchecked Sendable {
     self.runtimePointee = runtime
     self.pointee = expo.iruntime(runtime)
     self.handle = JavaScriptRuntimeHandle(self.pointee)
-    self.scheduler = expo.RuntimeScheduler()
+    self.scheduler = expo.RuntimeScheduler.create()
     self.ownsRuntime = false
     handle.attach(self)
     installLongLivedObjectsTeardown()
@@ -123,7 +123,7 @@ open class JavaScriptRuntime: Equatable, Identifiable, @unchecked Sendable {
     self.runtimePointee = runtime
     self.pointee = expo.iruntime(runtime)
     self.handle = JavaScriptRuntimeHandle(self.pointee)
-    self.scheduler = expo.RuntimeScheduler(scheduler, fn)
+    self.scheduler = expo.RuntimeScheduler.create(scheduler, fn)
     self.ownsRuntime = false
     handle.attach(self)
     installLongLivedObjectsTeardown()
@@ -197,14 +197,14 @@ open class JavaScriptRuntime: Equatable, Identifiable, @unchecked Sendable {
       propertyName: UnsafePointer<facebook.jsi.PropNameID>,
       resultPtr: UnsafeMutablePointer<facebook.jsi.Value>
     ) -> Bool {
-      nonisolated(unsafe) let resultPtr = resultPtr
+      let resultPtr = UncheckedSendable(resultPtr)
 
       return withGuaranteedContext(context) { (context: HostObjectContext, runtime) in
         let propertyName = String(jsiPropNameID: propertyName.pointee, in: runtime.pointee)
         return JavaScriptActor.assumeIsolated {
           return forwardingSwiftErrorsToJS(runtime: runtime) {
             var result = try context.get(propertyName)
-            JavaScriptValue.write(&result, to: resultPtr)
+            JavaScriptValue.write(&result, to: resultPtr.value)
           }
         }
       }
@@ -693,8 +693,15 @@ open class JavaScriptRuntime: Equatable, Identifiable, @unchecked Sendable {
   @discardableResult
   @JavaScriptActor
   public func evalAsync(label: String? = nil, _ source: String) async throws -> JavaScriptValue {
-    let result = try eval(label: label, source)
-    return result.is("Promise") ? try await result.getPromise().await() : result
+    // `@JavaScriptActor` runs this on the caller's thread, so go through `execute` to evaluate on the
+    // JavaScript thread. It runs the closure in place when already there, or when the runtime has no
+    // scheduler and thus no other thread to go to.
+    // The result is boxed because `execute` needs a `Sendable` result and `JavaScriptValue` is not one.
+    let result = try await execute { () async throws -> NonisolatedUnsafeVar<JavaScriptValue> in
+      let value = try self.eval(label: label, source)
+      return NonisolatedUnsafeVar(value.is("Promise") ? try await value.getPromise().await() : value)
+    }
+    return result.value
   }
 
   // MARK: - Garbage collection
@@ -871,23 +878,23 @@ private func createFunctionClosure(
     // heap-allocated `JavaScriptRef` (Swift 6.2 rejects capturing/consuming a `~Copyable` value in the
     // escaping closure that `withoutActuallyEscaping` synthesizes), the closure constructs the buffer
     // locally from the raw pointer + count. Those are read-only call-scoped inputs that never outlive the
-    // synchronous call, so the `nonisolated(unsafe)` capture is sound. This removes a per-call class
+    // synchronous call, so capturing them through `UncheckedSendable` is sound. This removes a per-call class
     // allocation + retain/release + dealloc that profiling showed dominating the no-op `@JS` host-call
     // floor.
-    nonisolated(unsafe) let thisPtr = thisPtr
-    nonisolated(unsafe) let argumentsPtr = argumentsPtr
-    nonisolated(unsafe) let resultPtr = resultPtr
+    let thisPtr = UncheckedSendable(thisPtr)
+    let argumentsPtr = UncheckedSendable(argumentsPtr)
+    let resultPtr = UncheckedSendable(resultPtr)
 
     // See `withGuaranteedContext` for why neither the context nor the runtime is retained here, and
     // why the result is written to the caller's slot instead of being returned.
     return withGuaranteedContext(context) { (context: HostFunctionContext, runtime) in
       return JavaScriptActor.assumeIsolated {
         return forwardingSwiftErrorsToJS(runtime: runtime) {
-          let this = UnsafeMutablePointer(mutating: thisPtr).move()
-          let arguments = JavaScriptValuesBuffer(runtime, start: argumentsPtr, count: argumentsCount)
+          let this = UnsafeMutablePointer(mutating: thisPtr.value).move()
+          let arguments = JavaScriptValuesBuffer(runtime, start: argumentsPtr.value, count: argumentsCount)
           let thisValue = JavaScriptValue(runtime, this)
           var result = try context.call(thisValue, consume arguments)
-          JavaScriptValue.write(&result, to: resultPtr)
+          JavaScriptValue.write(&result, to: resultPtr.value)
         }
       }
     }
@@ -919,19 +926,19 @@ private func createFunctionClosure(
     // handed in as a borrowed `JavaScriptUnownedValue` pointing straight at the C++-owned `this` slot:
     // it is not moved out and no owning `JavaScriptValue` is allocated, so the closure avoids the
     // per-call `weak`-runtime form/destroy and heap object that the owning `this` pays.
-    nonisolated(unsafe) let thisPtr = thisPtr
-    nonisolated(unsafe) let argumentsPtr = argumentsPtr
-    nonisolated(unsafe) let resultPtr = resultPtr
+    let thisPtr = UncheckedSendable(thisPtr)
+    let argumentsPtr = UncheckedSendable(argumentsPtr)
+    let resultPtr = UncheckedSendable(resultPtr)
 
     // See `withGuaranteedContext` for why neither the context nor the runtime is retained here, and
     // why the result is written to the caller's slot instead of being returned.
     return withGuaranteedContext(context) { (context: UnownedThisHostFunctionContext, runtime) in
       return JavaScriptActor.assumeIsolated {
         return forwardingSwiftErrorsToJS(runtime: runtime) {
-          let arguments = JavaScriptValuesBuffer(runtime, start: argumentsPtr, count: argumentsCount)
-          let thisValue = JavaScriptUnownedValue(runtime.pointee, thisPtr)
+          let arguments = JavaScriptValuesBuffer(runtime, start: argumentsPtr.value, count: argumentsCount)
+          let thisValue = JavaScriptUnownedValue(runtime.pointee, thisPtr.value)
           var result = try context.call(thisValue, consume arguments)
-          JavaScriptValue.write(&result, to: resultPtr)
+          JavaScriptValue.write(&result, to: resultPtr.value)
         }
       }
     }

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

@@ -375,19 +375,50 @@ public struct JavaScriptObject: JavaScriptType, Sendable, ~Copyable {
     guard let runtime else {
       FatalError.runtimeLost()
     }
-    try! runtime
-      .global()
-      .getPropertyAsObject("Object")
-      .getPropertyAsFunction("defineProperty")
-      .call(arguments: self.asValue().ref(), JavaScriptValue(runtime, name).ref(), descriptor.ref())
+    do {
+      try definePropertyFunction(in: runtime).function
+        .call(arguments: self.asValue().ref(), JavaScriptValue(runtime, name).ref(), descriptor.ref())
+    } catch {
+      FatalError.definePropertyFailed(name, error)
+    }
   }
 
   public func defineProperty(_ name: String, descriptor: consuming PropertyDescriptor = .init()) {
     guard let runtime else {
       FatalError.runtimeLost()
     }
-    let descriptorObject = descriptor.toObject(runtime)
-    defineProperty(name, descriptor: descriptorObject)
+    let defineProperty = definePropertyFunction(in: runtime)
+    let jsiRuntime = runtime.pointee
+    let hasValue = descriptor.value != nil
+    let value = descriptor.value?.toJSIValue(in: jsiRuntime) ?? facebook.jsi.Value.undefined()
+    var utf8Name = name
+    utf8Name.withUTF8 { nameUtf8 in
+      // A JS error can't propagate through Swift, so `capturingCppErrors` captures it and rethrows it
+      // here; `defineProperty` doesn't throw, so it stops execution with that error.
+      do {
+        try capturingCppErrors {
+          expo.defineProperty(
+            jsiRuntime,
+            defineProperty.function.pointee,
+            defineProperty.configurableKey.pointee,
+            defineProperty.enumerableKey.pointee,
+            defineProperty.writableKey.pointee,
+            defineProperty.valueKey.pointee,
+            pointee,
+            // An empty buffer may have no base address; any non-null pointer works with a zero length.
+            nameUtf8.baseAddress ?? UnsafePointer(bitPattern: 1)!,
+            nameUtf8.count,
+            value,
+            hasValue,
+            descriptor.writable,
+            descriptor.enumerable,
+            descriptor.configurable
+          )
+        }
+      } catch {
+        FatalError.definePropertyFailed(name, error)
+      }
+    }
   }
 
   public func defineProperty<T: JavaScriptRepresentable & ~Copyable>(
@@ -674,3 +705,40 @@ extension JavaScriptObject {
     }
   }
 }
+
+// MARK: - Object.defineProperty
+
+/// Holds the runtime's `Object.defineProperty` and the property names of a descriptor, created once per
+/// runtime instead of on every `defineProperty` call.
+private final class DefinePropertyFunction {
+  let function: JavaScriptFunction
+  let configurableKey: JavaScriptPropNameID
+  let enumerableKey: JavaScriptPropNameID
+  let writableKey: JavaScriptPropNameID
+  let valueKey: JavaScriptPropNameID
+
+  init(_ function: consuming JavaScriptFunction, in runtime: JavaScriptRuntime) {
+    self.function = function
+    self.configurableKey = JavaScriptPropNameID(runtime, string: "configurable")
+    self.enumerableKey = JavaScriptPropNameID(runtime, string: "enumerable")
+    self.writableKey = JavaScriptPropNameID(runtime, string: "writable")
+    self.valueKey = JavaScriptPropNameID(runtime, string: "value")
+  }
+}
+
+private let definePropertyFunctionKey = JavaScriptRuntime.Cache.Key<DefinePropertyFunction>()
+
+/// Returns the runtime's `Object.defineProperty`, cached in the runtime. Property definitions run on the
+/// JavaScript thread like every other JSI call, which is where the runtime's cache is isolated.
+private func definePropertyFunction(in runtime: JavaScriptRuntime) -> DefinePropertyFunction {
+  return JavaScriptActor.assumeIsolated {
+    runtime.cached(definePropertyFunctionKey) {
+      do {
+        let function = try runtime.global().getPropertyAsObject("Object").getPropertyAsFunction("defineProperty")
+        return DefinePropertyFunction(function, in: runtime)
+      } catch {
+        FatalError.definePropertyUnavailable(error)
+      }
+    }
+  }
+}

package/apple/Sources/ExpoModulesJSI/Utilities/Errors.swift

@@ -30,4 +30,23 @@ internal struct FatalError {
         + "Check that its null-setter short-circuit is still in place."
     )
   }
+
+  /// Stops program execution when `Object.defineProperty` throws, for example when the property already
+  /// exists and isn't configurable, or the object isn't extensible. `defineProperty` doesn't throw, so
+  /// its callers are expected to define properties that JavaScript accepts.
+  internal static func definePropertyFailed(_ name: String, _ error: any Error) -> Never {
+    fatalError(
+      "Object.defineProperty failed to define '\(name)': \(error). "
+        + "Make sure the object is extensible and doesn't already have a non-configurable property with this name."
+    )
+  }
+
+  /// Stops program execution when the runtime has no `Object.defineProperty` function, which every
+  /// JavaScript engine provides unless the global `Object` has been replaced.
+  internal static func definePropertyUnavailable(_ error: any Error) -> Never {
+    fatalError(
+      "Couldn't look up Object.defineProperty in the JavaScript runtime: \(error). "
+        + "Check whether the global Object has been replaced."
+    )
+  }
 }

package/apple/Sources/ExpoModulesJSI/Utilities/UncheckedSendable.swift

@@ -0,0 +1,13 @@
+/// Immutable wrapper that makes a non-Sendable value capturable by a `@Sendable` closure without compiler enforcement.
+/// Unlike `NonisolatedUnsafeVar`, it is a struct, so wrapping a value doesn't allocate.
+///
+/// Use it instead of a `nonisolated(unsafe) let` local captured by such a closure: Swift 6.2 still reports
+/// "sending '...' risks causing data races" for those, while a capture of a `Sendable` value passes on every version.
+/// The caller is responsible for making sure the value is never accessed concurrently.
+internal struct UncheckedSendable<Value>: @unchecked Sendable {
+  let value: Value
+
+  init(_ value: Value) {
+    self.value = value
+  }
+}

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

@@ -220,6 +220,47 @@ inline jsi::Value callFunctionWithThis(jsi::IRuntime &runtime, const jsi::Functi
   });
 }
 
+/**
+ Calls `defineProperty`, the runtime's `Object.defineProperty`, on `object` with a new descriptor that holds
+ `value` (when `hasValue` is set) and only the attributes that are `true`, like a descriptor built in
+ JavaScript. Taking the function and the descriptor keys from the caller lets it create them once per runtime,
+ and building the descriptor and the arguments here avoids a round trip through Swift for each of them.
+ */
+inline void defineProperty(
+  jsi::IRuntime &runtime,
+  const jsi::Function &defineProperty,
+  const jsi::PropNameID &configurableKey,
+  const jsi::PropNameID &enumerableKey,
+  const jsi::PropNameID &writableKey,
+  const jsi::PropNameID &valueKey,
+  const jsi::Object &object,
+  const uint8_t *_Nonnull nameUtf8,
+  size_t nameLength,
+  const jsi::Value &value,
+  bool hasValue,
+  bool writable,
+  bool enumerable,
+  bool configurable
+) {
+  expo::CppError::tryCatch(runtime, [&] {
+    jsi::Object descriptor(runtime);
+    if (configurable) {
+      descriptor.setProperty(runtime, configurableKey, true);
+    }
+    if (enumerable) {
+      descriptor.setProperty(runtime, enumerableKey, true);
+    }
+    if (writable) {
+      descriptor.setProperty(runtime, writableKey, true);
+    }
+    if (hasValue) {
+      descriptor.setProperty(runtime, valueKey, value);
+    }
+    defineProperty.call(runtime, object, jsi::String::createFromUtf8(runtime, nameUtf8, nameLength), descriptor);
+    return jsi::Value::undefined();
+  });
+}
+
 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 function.callAsConstructor(runtime, args, count);

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

@@ -44,21 +44,34 @@ private:
 
   std::atomic<int> refCount{1};
 
+  RuntimeScheduler(void *scheduler, ScheduleFn fn) noexcept
+      : nativeScheduler(scheduler), scheduleFn(fn) {}
+
+  RuntimeScheduler() noexcept {}
+
 public:
+  // Swift creates instances through the static `create` functions rather than the constructors.
+  // Annotating the constructors with `SWIFT_RETURNS_RETAINED` silences the Swift 6.4 "cannot infer
+  // ownership" warning, but Swift 6.2 rejects that annotation on a constructor as an error. Static
+  // functions returning a shared reference accept the annotation on every Swift version.
+
   /**
-   Constructs a scheduler bound to a host-provided native RuntimeScheduler.
+   Creates a scheduler bound to a host-provided native RuntimeScheduler.
    `scheduleTask` dispatches through `fn`, which the host implements against
    the real react::RuntimeScheduler.
    */
-  SWIFT_RETURNS_RETAINED RuntimeScheduler(void *scheduler, ScheduleFn fn) noexcept
-      : nativeScheduler(scheduler), scheduleFn(fn) {}
+  static RuntimeScheduler *create(void *scheduler, ScheduleFn fn) noexcept SWIFT_RETURNS_RETAINED {
+    return new RuntimeScheduler(scheduler, fn);
+  }
 
   /**
-   Constructs a no-op scheduler. Scheduled tasks run synchronously on the
+   Creates a no-op scheduler. Scheduled tasks run synchronously on the
    caller's thread — intended for standalone runtimes (e.g. tests) that have
    no React scheduler.
    */
-  SWIFT_RETURNS_RETAINED RuntimeScheduler() {}
+  static RuntimeScheduler *create() noexcept SWIFT_RETURNS_RETAINED {
+    return new RuntimeScheduler();
+  }
 
   RuntimeScheduler(const RuntimeScheduler &) = delete;
 

package/apple/Tests/JavaScriptCodableSetTests.swift

@@ -0,0 +1,115 @@
+// Copyright 2026-present 650 Industries. All rights reserved.
+
+import ExpoModulesJSI
+import Testing
+
+@Suite("JavaScriptCodable+Set")
+@JavaScriptActor
+struct JavaScriptCodableSetTests {
+  let runtime = JavaScriptRuntime()
+
+  @Test
+  func `decodes a set of strings from a JS Set`() throws {
+    let decoded = try Set<String>.decode(runtime.eval("new Set(['a', 'b'])"), in: runtime)
+    #expect(decoded == ["a", "b"])
+  }
+
+  @Test
+  func `decodes a set from a subclass of Set`() throws {
+    let decoded = try Set<Int>.decode(runtime.eval("new (class extends Set {})([1, 2])"), in: runtime)
+    #expect(decoded == [1, 2])
+  }
+
+  @Test
+  func `arrayizes a non-set object into a single-element set`() throws {
+    let decoded = try Set<[String: Int]>.decode(runtime.eval("({ a: 1 })"), in: runtime)
+    #expect(decoded == [["a": 1]])
+  }
+
+  @Test
+  func `decoding many sets leaves no helper on the global object`() throws {
+    let runtime = JavaScriptRuntime()
+    for _ in 0..<100 {
+      _ = try Set<Int>.decode(runtime.eval("new Set([1, 2, 3])"), in: runtime)
+    }
+    // The only object the wrapper may leave on `globalThis` is the long-lived-objects anchor.
+    let ownGlobals = try runtime.eval("Object.getOwnPropertyNames(globalThis).length").getInt()
+    let freshGlobals = try JavaScriptRuntime().eval("Object.getOwnPropertyNames(globalThis).length").getInt()
+    #expect(ownGlobals - freshGlobals <= 1)
+  }
+
+  @Test
+  func `decodes a set from an array, collapsing duplicates`() throws {
+    let decoded = try Set<Int>.decode(runtime.eval("[1, 2, 2, 3, 1]"), in: runtime)
+    #expect(decoded == [1, 2, 3])
+  }
+
+  @Test
+  func `arrayizes a non-array, non-set scalar into a set`() throws {
+    #expect(try Set<Int>.decode(runtime.eval("42"), in: runtime) == [42])
+  }
+
+  @Test
+  func `encodes a set to a JS Set`() throws {
+    let encoded = try Set<Int>.encode([1, 2, 3], in: runtime)
+    #expect(encoded.is("Set"))
+    let object = encoded.getObject()
+    #expect(object.getProperty("size").getInt() == 3)
+    #expect(try object.callFunction("has", arguments: 2).getBool() == true)
+    #expect(try object.callFunction("has", arguments: 4).getBool() == false)
+  }
+
+  @Test
+  func `round-trips a set of sets`() throws {
+    let value: Set<Set<String>> = [["a"], ["b", "c"]]
+    let encoded = try Set<Set<String>>.encode(value, in: runtime)
+    #expect(try Set<Set<String>>.decode(encoded, in: runtime) == value)
+  }
+
+  @Test
+  func `round-trips an empty set`() throws {
+    #expect(try Set<Int>.decode(runtime.eval("new Set()"), in: runtime) == [])
+    let encoded = try Set<Int>.encode([], in: runtime)
+    #expect(encoded.is("Set"))
+    #expect(encoded.getObject().getProperty("size").getInt() == 0)
+  }
+
+  @Test
+  func `set decode rejects an element of the wrong type`() throws {
+    #expect(throws: (any Error).self) {
+      try Set<Int>.decode(runtime.eval("new Set([1, 'a'])"), in: runtime)
+    }
+  }
+
+  @Test
+  func `set decode collapses distinct JS objects that decode to equal values`() throws {
+    // JS `Set` compares objects by reference, so it holds both objects; Swift compares the decoded
+    // dictionaries by value, so they collapse into one element.
+    let decoded = try Set<[String: Int]>.decode(runtime.eval("new Set([{ a: 1 }, { a: 1 }, { b: 2 }])"), in: runtime)
+    #expect(decoded == [["a": 1], ["b": 2]])
+  }
+
+  @Test
+  func `encodes a set of dictionaries to a JS Set of distinct objects`() throws {
+    let encoded = try Set<[String: Int]>.encode([["a": 1], ["b": 2]], in: runtime)
+    runtime.global().setProperty("encodedSet", value: encoded)
+    let summary = try runtime.eval(
+      "Array.from(encodedSet, (entry) => JSON.stringify(entry)).sort().join(',')"
+    )
+    #expect(summary.getString() == #"{"a":1},{"b":2}"#)
+  }
+
+  @Test
+  func `decodes a set argument and encodes a set result through a host function`() throws {
+    let fn = runtime.createFunction("uppercased") { [self] _, arguments in
+      let strings = try Set<String>.decode(arguments.unownedValue(at: 0), in: runtime)
+      return try Set<String>.encode(Set(strings.map { $0.uppercased() }), in: runtime)
+    }
+    runtime.global().setProperty("uppercased", value: fn.asValue())
+    let result = try runtime.eval(
+      "const result = uppercased(new Set(['a', 'b']))",
+      "result instanceof Set && result.size === 2 && result.has('A') && result.has('B')"
+    )
+    #expect(result.getBool() == true)
+  }
+}

package/apple/Tests/JavaScriptRuntimeTests.swift

@@ -92,6 +92,23 @@ struct JavaScriptRuntimeTests {
     #expect(result.getString() == "hello")
   }
 
+  @Test
+  func `evaluate to promise on the JavaScript thread when called from another thread`() async throws {
+    // The test body runs on a cooperative thread, not on the scheduler's thread. Evaluating there
+    // would run JavaScript concurrently with the work the scheduler runs, such as settling a promise.
+    let testRuntime = await TestRuntimeScheduler().makeRuntime()
+    let runtime = testRuntime.runtime
+    try await testRuntime.scheduler.runIsolated {
+      let isOnJavaScriptThread = runtime.createFunction("isOnJavaScriptThread") { _, _ in
+        return JavaScriptValue(runtime, runtime.isOnJavaScriptThread())
+      }
+      runtime.global().setProperty("isOnJavaScriptThread", value: isOnJavaScriptThread.asValue())
+    }
+
+    let result = try await runtime.evalAsync("Promise.resolve(isOnJavaScriptThread())")
+    #expect(result.getBool() == true)
+  }
+
   @Test
   func `is equatable`() {
     #expect((runtime == runtime) == true)
@@ -170,11 +187,11 @@ struct JavaScriptRuntimeTests {
     }
 
     await scheduler.run {
-      nonisolated(unsafe) var didRunInline = false
+      let didRunInline = InlineRunFlag()
       runtime.runOrSchedule {
-        didRunInline = true
+        didRunInline.value = true
       }
-      #expect(didRunInline)
+      #expect(didRunInline.value)
     }
 
     await withCheckedContinuation { continuation in
@@ -1148,6 +1165,13 @@ struct JavaScriptRuntimeTests {
   }
 }
 
+/// Records whether a `runOrSchedule` block ran. A class instead of a `nonisolated(unsafe) var` captured
+/// by the block, which Swift 6.2 rejects as a data race. Safe without synchronization: the test only
+/// reads it after the block ran inline on the same thread.
+private final class InlineRunFlag: @unchecked Sendable {
+  var value = false
+}
+
 /// Tasks captured by `holdSchedulerTask` instead of being executed, emulating a React
 /// `RuntimeScheduler` that is torn down with work still queued (the #47716 reload scenario).
 /// Safe without synchronization: the dispatch always runs synchronously on the test's thread.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "expo-modules-jsi",
-  "version": "58.0.8",
+  "version": "58.0.9",
   "description": "The JavaScript Interface for Expo Modules",
   "main": "index.js",
   "sideEffects": [],