expo-modules-jsi 56.0.8 → 56.0.10

package/CHANGELOG.md

@@ -10,6 +10,19 @@
 
 ### 💡 Others
 
+## 56.0.10 — 2026-06-15
+
+### 🐛 Bug fixes
+
+- [iOS] Ignore already-settled promises. ([#46765](https://github.com/expo/expo/pull/46765) by [@jakex7](https://github.com/jakex7))
+
+## 56.0.9 — 2026-06-10
+
+### 🎉 New features
+
+- [iOS] Add closure-taking `JavaScriptObject.setProperty(_:function:)` overloads that create a sync or async host function from the given closure. ([#46622](https://github.com/expo/expo/pull/46622) by [@tsapeta](https://github.com/tsapeta))
+- [iOS] Add `JavaScriptUnownedValue`, a non-owning, non-copyable value that borrows a `jsi::Value` for the zero-copy argument-decode fast path. ([#46616](https://github.com/expo/expo/pull/46616) by [@tsapeta](https://github.com/tsapeta))
+
 ## 56.0.8 — 2026-06-05
 
 ### 🐛 Bug fixes

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

@@ -61,6 +61,17 @@ public struct JavaScriptValuesBuffer: JavaScriptType, ~Copyable {
     return JavaScriptValue(runtime, bufferPointer[index])
   }
 
+  /// Returns a non-owning, non-copyable value borrowing the element at `index` for the zero-copy decode
+  /// path. It borrows the `jsi::Value` this buffer owns, so it is valid only while the buffer is alive
+  /// and must not be stored or escaped — see ``JavaScriptUnownedValue``.
+  ///
+  /// Unlike `subscript(_:)`, this is unchecked: `index` must be in `0..<count`. The accessor force-unwraps
+  /// `baseAddress`, so passing any index into an empty buffer crashes, and an out-of-range index reads past
+  /// the buffer. The caller is responsible for the bounds check.
+  public func unownedValue(at index: Int) -> JavaScriptUnownedValue {
+    return JavaScriptUnownedValue(runtime, bufferPointer.baseAddress! + index)
+  }
+
   @discardableResult
   internal consuming func set<T: JSIRepresentable>(value: borrowing T, atIndex index: Int) -> JavaScriptValuesBuffer
   where T: ~Copyable {

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

@@ -256,6 +256,30 @@ public struct JavaScriptObject: JavaScriptType, Sendable, ~Copyable {
     expo.setProperty(runtime.pointee, pointee, name, facebook.jsi.Value(runtime.pointee, object.pointee))
   }
 
+  /// Sets a property to a synchronous host function created from the given closure. The function
+  /// is named after the property and runs the closure when called from JavaScript, returning its
+  /// result synchronously. Equivalent to `setProperty(name, runtime.createFunction(name) { … })`.
+  @JavaScriptActor
+  public func setProperty(_ name: String, function: sending @escaping JavaScriptRuntime.SyncFunctionClosure) {
+    guard let runtime else {
+      FatalError.runtimeLost()
+    }
+    setProperty(name, value: runtime.createFunction(name, function))
+  }
+
+  /// Sets a property to an asynchronous host function created from the given closure. The function
+  /// is named after the property and runs the closure when called from JavaScript, returning a
+  /// promise that resolves with its result. Equivalent to
+  /// `setProperty(name, runtime.createAsyncFunction(name) { … })`. The `async` closure body
+  /// selects this overload over the synchronous `setProperty(_:_:)`.
+  @JavaScriptActor
+  public func setProperty(_ name: String, function: sending @escaping JavaScriptRuntime.AsyncFunctionClosure) {
+    guard let runtime else {
+      FatalError.runtimeLost()
+    }
+    setProperty(name, value: runtime.createAsyncFunction(name, function))
+  }
+
   /// Deletes a property with the given name. After calling this function,
   /// `hasProperty` will return `false`, and `getProperty` will return `undefined` value.
   #if !os(macOS)

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

@@ -75,15 +75,16 @@ public struct JavaScriptPromise: JavaScriptType, ~Copyable {
     guard let runtime else {
       return
     }
-    guard !resolveFunction.isEmpty else {
-      preconditionFailure("Cannot settle a promise more than once")
-    }
 
     // `resolve` is not isolated, so make sure to jump to JS thread.
     runtime.schedule(priority: .immediate) { [resolveFunction, rejectFunction] in
+      // If the promise is already settled, do nothing.
+      guard let resolver = resolveFunction.take() else {
+        return
+      }
       // Call the actual resolver given in the Promise setup.
       // This will also call `deferredPromise.resolve` in the `then` handler.
-      _ = try! resolveFunction.take().getFunction().call(arguments: value)
+      _ = try! resolver.getFunction().call(arguments: value)
 
       // Release the rejecter, we cannot call it anymore.
       rejectFunction.release()
@@ -94,19 +95,20 @@ public struct JavaScriptPromise: JavaScriptType, ~Copyable {
     guard let runtime else {
       return
     }
-    guard !rejectFunction.isEmpty else {
-      preconditionFailure("Cannot settle a promise more than once")
-    }
 
     // `reject` is not isolated, so make sure to jump to JS thread.
     runtime.schedule(priority: .immediate) { [resolveFunction, rejectFunction] in
+      // If the promise is already settled, do nothing.
+      guard let rejecter = rejectFunction.take() else {
+        return
+      }
       // Create a JS error from any (native) error.
       let errorMessage = String(describing: error)
       let errorValue = JavaScriptError(runtime, message: errorMessage).asValue()
 
       // Call the actual rejecter given in the Promise setup.
       // This will also call `deferredPromise.reject` in the `then` handler.
-      _ = try! rejectFunction.take().getFunction().call(arguments: errorValue)
+      _ = try! rejecter.getFunction().call(arguments: errorValue)
 
       // Release the resolver, we cannot call it anymore.
       resolveFunction.release()

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

@@ -0,0 +1,137 @@
+// Copyright 2025-present 650 Industries. All rights reserved.
+
+internal import ExpoModulesJSI_Cxx
+import Foundation
+internal import jsi
+
+/// A non-owning, non-copyable `JavaScriptValue` that borrows a `facebook.jsi.Value` owned elsewhere —
+/// typically an argument still living in the `JavaScriptValuesBuffer` for the duration of a host
+/// function call.
+///
+/// Unlike ``JavaScriptValue`` (a `final class` that owns its `jsi::Value`) and ``JavaScriptRef``
+/// (an owning reference that promotes a value to reference semantics so it *can* escape), an unowned
+/// value owns nothing: it borrows a `jsi::Value` whose lifetime is guaranteed by someone else. It
+/// exists to feed the argument-decode fast path, where wrapping each argument in a heap-allocated
+/// owning `JavaScriptValue` (ARC plus a real `jsi::Value` copy, per argument, per call) is pure
+/// overhead — `decode` only needs to *read* the argument long enough to extract a `Double`/`String`/etc.
+///
+/// > Warning: Lifetime safety rests on convention, not the compiler. `~Copyable` prevents *aliasing*
+/// > the value but does not enforce that the owning buffer outlives it. Unlike Swift's `unowned(safe)`
+/// > class refs, there is no trap on use-after-free. The contract is "valid only within the synchronous
+/// > decode call, while the owner is alive" — which the buffer-driven decode path honors because it
+/// > reads the value inline on the JS thread before the buffer is torn down. Do not store, capture, or
+/// > escape it; call ``copied()`` to materialize an owning value when escape is needed.
+public struct JavaScriptUnownedValue: ~Copyable {
+  // Borrows the `jsi::Value` at this address; it does not own it and must not outlive the owner.
+  internal let pointer: UnsafePointer<facebook.jsi.Value>
+
+  // Non-optional `unowned`, matching `JavaScriptValuesBuffer.runtime`: it is strictly call-scoped and
+  // cannot outlive the runtime executing the call, so we skip both the ARC traffic and the optional unwrap
+  // that the owning `JavaScriptValue` pays.
+  internal unowned let runtime: JavaScriptRuntime
+
+  internal init(_ runtime: JavaScriptRuntime, _ pointer: UnsafePointer<facebook.jsi.Value>) {
+    self.runtime = runtime
+    self.pointer = pointer
+  }
+
+  /// Materializes an owning ``JavaScriptValue`` by copying the borrowed `jsi::Value`. Use it when the
+  /// value must outlive the decode call (stored, captured, handed to a `Promise`).
+  public func copied() -> JavaScriptValue {
+    return JavaScriptValue(runtime, pointer.pointee)
+  }
+
+  // MARK: - Type checks
+
+  public func isUndefined() -> Bool {
+    return pointer.pointee.isUndefined()
+  }
+
+  public func isNull() -> Bool {
+    return pointer.pointee.isNull()
+  }
+
+  public func isBool() -> Bool {
+    return pointer.pointee.isBool()
+  }
+
+  public func isNumber() -> Bool {
+    return pointer.pointee.isNumber()
+  }
+
+  public func isString() -> Bool {
+    return pointer.pointee.isString()
+  }
+
+  public func isSymbol() -> Bool {
+    return pointer.pointee.isSymbol()
+  }
+
+  public func isBigInt() -> Bool {
+    return pointer.pointee.isBigInt()
+  }
+
+  public func isObject() -> Bool {
+    return pointer.pointee.isObject()
+  }
+
+  // MARK: - Primitive accessors
+
+  /// Returns the value as a boolean, or asserts if not a boolean.
+  public func getBool() -> Bool {
+    assert(isBool(), "Value is not a boolean")
+    return pointer.pointee.getBool()
+  }
+
+  /// Returns the value as an integer, or asserts if not a number.
+  public func getInt() -> Int {
+    assert(isNumber(), "Value is not a number")
+    return Int(pointer.pointee.getNumber())
+  }
+
+  /// Returns the value as a double, or asserts if not a number.
+  public func getDouble() -> Double {
+    assert(isNumber(), "Value is not a number")
+    return pointer.pointee.getNumber()
+  }
+
+  /// Returns the value as a string, or asserts if not a string.
+  public func getString() -> String {
+    assert(isString(), "Value is not a string")
+    return String(pointer.pointee.getString(runtime.pointee).utf8(runtime.pointee))
+  }
+
+  // MARK: - Throwing conversions ("as functions")
+
+  /// Returns the value as a boolean, or throws `TypeError` if it is not a boolean.
+  public func asBool() throws(JavaScriptValue.TypeError) -> Bool {
+    guard isBool() else {
+      throw JavaScriptValue.TypeError(type: Bool.self)
+    }
+    return getBool()
+  }
+
+  /// Returns the value as an integer, or throws `TypeError` if it is not a number.
+  public func asInt() throws(JavaScriptValue.TypeError) -> Int {
+    guard isNumber() else {
+      throw JavaScriptValue.TypeError(type: Int.self)
+    }
+    return getInt()
+  }
+
+  /// Returns the value as a double, or throws `TypeError` if it is not a number.
+  public func asDouble() throws(JavaScriptValue.TypeError) -> Double {
+    guard isNumber() else {
+      throw JavaScriptValue.TypeError(type: Double.self)
+    }
+    return getDouble()
+  }
+
+  /// Returns the value as a string, or throws `TypeError` if it is not a string.
+  public func asString() throws(JavaScriptValue.TypeError) -> String {
+    guard isString() else {
+      throw JavaScriptValue.TypeError(type: String.self)
+    }
+    return getString()
+  }
+}

package/apple/Tests/JavaScriptObjectTests.swift

@@ -223,6 +223,29 @@ struct JavaScriptObjectTests {
       #expect(try object.getPropertyAsObject("nested").getProperty("value").getInt() == 42)
     }
 
+    @Test
+    @JavaScriptActor
+    func `set property with sync function closure`() throws {
+      let object = JavaScriptObject(runtime)
+      object.setProperty("double") { this, arguments in
+        return JavaScriptValue(self.runtime, arguments[0].getInt() * 2)
+      }
+      let fn = try object.getPropertyAsFunction("double")
+      #expect(try fn.call(arguments: 21).getInt() == 42)
+    }
+
+    @Test
+    @JavaScriptActor
+    func `set property with async function closure`() async throws {
+      let object = JavaScriptObject(runtime)
+      object.setProperty("addAsync") { this, arguments async throws in
+        return JavaScriptValue(self.runtime, arguments[0].getInt() + arguments[1].getInt())
+      }
+      let fn = try object.getPropertyAsFunction("addAsync")
+      let result = try await fn.call(arguments: 20, 22).getPromise().await()
+      #expect(result.getInt() == 42)
+    }
+
     @Test
     func `delete property`() {
       let object = JavaScriptObject(runtime)

package/apple/Tests/JavaScriptPromiseTests.swift

@@ -279,6 +279,23 @@ struct JavaScriptPromiseTests {
     #expect(result.getInt() == 99)
   }
 
+  @Test
+  func `settling promise more than once is ignored`() async throws {
+    struct TestError: Error, Sendable {}
+
+    let runtime = JavaScriptRuntime()
+    let promise = try JavaScriptPromise(runtime)
+
+    runtime.global().setProperty("testPromise", value: promise.asValue())
+    promise.resolve(42)
+    promise.reject(TestError())
+    promise.resolve(100)
+
+    let result = try await promise.await()
+
+    #expect(result.getInt() == 42)
+  }
+
   @Test
   func `promise all`() async throws {
     let runtime = JavaScriptRuntime()

package/apple/Tests/JavaScriptUnownedValueTests.swift

@@ -0,0 +1,78 @@
+import ExpoModulesJSI
+import Testing
+
+@Suite
+@JavaScriptActor
+struct JavaScriptUnownedValueTests {
+  let runtime = JavaScriptRuntime()
+
+  @Test
+  func `reads primitives without copying`() {
+    let buffer = JavaScriptValuesBuffer.allocate(in: runtime, with: 42, "hello", true)
+
+    // The view is `~Copyable`, so compare accessor results against literals rather than passing the
+    // view into `#expect` — the macro captures its operand and would otherwise require `Copyable`.
+    let number = buffer.unownedValue(at: 0)
+    #expect(number.isNumber() == true)
+    #expect(number.getInt() == 42)
+    #expect(number.getDouble() == 42)
+
+    let string = buffer.unownedValue(at: 1)
+    #expect(string.isString() == true)
+    #expect(string.getString() == "hello")
+
+    let bool = buffer.unownedValue(at: 2)
+    #expect(bool.isBool() == true)
+    #expect(bool.getBool() == true)
+  }
+
+  @Test
+  func `recognizes null and undefined`() {
+    let buffer = JavaScriptValuesBuffer.allocate(in: runtime, with: JavaScriptValue.null, JavaScriptValue.undefined)
+
+    let null = buffer.unownedValue(at: 0)
+    #expect(null.isNull() == true)
+    #expect(null.isUndefined() == false)
+
+    let undefined = buffer.unownedValue(at: 1)
+    #expect(undefined.isUndefined() == true)
+    #expect(undefined.isNull() == false)
+  }
+
+  @Test
+  func `throwing accessors validate the type`() throws {
+    let buffer = JavaScriptValuesBuffer.allocate(in: runtime, with: 42, "hello")
+
+    #expect(try buffer.unownedValue(at: 0).asInt() == 42)
+    #expect(try buffer.unownedValue(at: 0).asDouble() == 42)
+    #expect(try buffer.unownedValue(at: 1).asString() == "hello")
+
+    #expect(throws: JavaScriptValue.TypeError.self) {
+      try buffer.unownedValue(at: 0).asString()
+    }
+    #expect(throws: JavaScriptValue.TypeError.self) {
+      try buffer.unownedValue(at: 1).asInt()
+    }
+    #expect(throws: JavaScriptValue.TypeError.self) {
+      try buffer.unownedValue(at: 1).asBool()
+    }
+  }
+
+  @Test
+  func `copied materializes an owning value`() throws {
+    let buffer = JavaScriptValuesBuffer.allocate(in: runtime, with: "owned")
+    let owning = buffer.unownedValue(at: 0).copied()
+
+    #expect(try owning.asString() == "owned")
+  }
+
+  @Test
+  func `recognizes objects`() {
+    let object = runtime.createObject()
+    let buffer = JavaScriptValuesBuffer.allocate(in: runtime, with: object.asValue())
+
+    let view = buffer.unownedValue(at: 0)
+    #expect(view.isObject() == true)
+    #expect(view.isNumber() == false)
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "expo-modules-jsi",
-  "version": "56.0.8",
+  "version": "56.0.10",
   "description": "The JavaScript Interface for Expo Modules",
   "main": "index.js",
   "sideEffects": [],
@@ -41,7 +41,7 @@
       "./apple/scripts/test.sh"
     ]
   },
-  "gitHead": "175f1e78e3444ca99ddea473faea6777a0656668",
+  "gitHead": "812dc007aefed0c432c0439fdfe05ee2f4f21da2",
   "scripts": {
     "build": "apple/scripts/build-xcframework.sh",
     "swift:format": "../../scripts/swift-format.sh",