expo-modules-jsi 58.0.6 → 58.0.8

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

@@ -15,6 +15,11 @@ import CoreGraphics
 // MARK: - Bool
 
 extension Bool: JavaScriptCodable {
+  @inlinable
+  public static var decodableKinds: JavaScriptValueKinds {
+    return .bool
+  }
+
   @JavaScriptActor
   @inlinable
   public static func decode(_ value: borrowing JavaScriptValue, in runtime: borrowing JavaScriptRuntime) throws -> Bool
@@ -40,6 +45,11 @@ extension Bool: JavaScriptCodable {
 // MARK: - String
 
 extension String: JavaScriptCodable {
+  @inlinable
+  public static var decodableKinds: JavaScriptValueKinds {
+    return .string
+  }
+
   @JavaScriptActor
   @inlinable
   public static func decode(_ value: borrowing JavaScriptValue, in runtime: borrowing JavaScriptRuntime) throws
@@ -74,6 +84,11 @@ extension String: JavaScriptCodable {
 // undefined behavior — a native crash, not a catchable error.
 
 extension Double: JavaScriptCodable {
+  @inlinable
+  public static var decodableKinds: JavaScriptValueKinds {
+    return .number
+  }
+
   @JavaScriptActor
   @inlinable
   public static func decode(_ value: borrowing JavaScriptValue, in runtime: borrowing JavaScriptRuntime) throws
@@ -100,6 +115,11 @@ extension Double: JavaScriptCodable {
 }
 
 extension Float: JavaScriptCodable {
+  @inlinable
+  public static var decodableKinds: JavaScriptValueKinds {
+    return .number
+  }
+
   @JavaScriptActor
   @inlinable
   public static func decode(_ value: borrowing JavaScriptValue, in runtime: borrowing JavaScriptRuntime) throws -> Float
@@ -123,6 +143,11 @@ extension Float: JavaScriptCodable {
 }
 
 extension CGFloat: JavaScriptCodable {
+  @inlinable
+  public static var decodableKinds: JavaScriptValueKinds {
+    return .number
+  }
+
   @JavaScriptActor
   @inlinable
   public static func decode(_ value: borrowing JavaScriptValue, in runtime: borrowing JavaScriptRuntime) throws
@@ -170,6 +195,11 @@ extension CGFloat: JavaScriptCodable {
 // back, and a JS caller may pass either form.
 
 extension Int: JavaScriptCodable {
+  @inlinable
+  public static var decodableKinds: JavaScriptValueKinds {
+    return [.number, .bigint]
+  }
+
   @JavaScriptActor
   @inlinable
   public static func decode(_ value: borrowing JavaScriptValue, in runtime: borrowing JavaScriptRuntime) throws -> Int {
@@ -192,6 +222,11 @@ extension Int: JavaScriptCodable {
 }
 
 extension Int8: JavaScriptCodable {
+  @inlinable
+  public static var decodableKinds: JavaScriptValueKinds {
+    return .number
+  }
+
   @JavaScriptActor
   @inlinable
   public static func decode(_ value: borrowing JavaScriptValue, in runtime: borrowing JavaScriptRuntime) throws -> Int8
@@ -215,6 +250,11 @@ extension Int8: JavaScriptCodable {
 }
 
 extension Int16: JavaScriptCodable {
+  @inlinable
+  public static var decodableKinds: JavaScriptValueKinds {
+    return .number
+  }
+
   @JavaScriptActor
   @inlinable
   public static func decode(_ value: borrowing JavaScriptValue, in runtime: borrowing JavaScriptRuntime) throws -> Int16
@@ -238,6 +278,11 @@ extension Int16: JavaScriptCodable {
 }
 
 extension Int32: JavaScriptCodable {
+  @inlinable
+  public static var decodableKinds: JavaScriptValueKinds {
+    return .number
+  }
+
   @JavaScriptActor
   @inlinable
   public static func decode(_ value: borrowing JavaScriptValue, in runtime: borrowing JavaScriptRuntime) throws -> Int32
@@ -261,6 +306,11 @@ extension Int32: JavaScriptCodable {
 }
 
 extension Int64: JavaScriptCodable {
+  @inlinable
+  public static var decodableKinds: JavaScriptValueKinds {
+    return [.number, .bigint]
+  }
+
   @JavaScriptActor
   @inlinable
   public static func decode(_ value: borrowing JavaScriptValue, in runtime: borrowing JavaScriptRuntime) throws -> Int64
@@ -284,6 +334,11 @@ extension Int64: JavaScriptCodable {
 }
 
 extension UInt: JavaScriptCodable {
+  @inlinable
+  public static var decodableKinds: JavaScriptValueKinds {
+    return [.number, .bigint]
+  }
+
   @JavaScriptActor
   @inlinable
   public static func decode(_ value: borrowing JavaScriptValue, in runtime: borrowing JavaScriptRuntime) throws -> UInt
@@ -307,6 +362,11 @@ extension UInt: JavaScriptCodable {
 }
 
 extension UInt8: JavaScriptCodable {
+  @inlinable
+  public static var decodableKinds: JavaScriptValueKinds {
+    return .number
+  }
+
   @JavaScriptActor
   @inlinable
   public static func decode(_ value: borrowing JavaScriptValue, in runtime: borrowing JavaScriptRuntime) throws -> UInt8
@@ -330,6 +390,11 @@ extension UInt8: JavaScriptCodable {
 }
 
 extension UInt16: JavaScriptCodable {
+  @inlinable
+  public static var decodableKinds: JavaScriptValueKinds {
+    return .number
+  }
+
   @JavaScriptActor
   @inlinable
   public static func decode(_ value: borrowing JavaScriptValue, in runtime: borrowing JavaScriptRuntime) throws
@@ -356,6 +421,11 @@ extension UInt16: JavaScriptCodable {
 }
 
 extension UInt32: JavaScriptCodable {
+  @inlinable
+  public static var decodableKinds: JavaScriptValueKinds {
+    return .number
+  }
+
   @JavaScriptActor
   @inlinable
   public static func decode(_ value: borrowing JavaScriptValue, in runtime: borrowing JavaScriptRuntime) throws
@@ -382,6 +452,11 @@ extension UInt32: JavaScriptCodable {
 }
 
 extension UInt64: JavaScriptCodable {
+  @inlinable
+  public static var decodableKinds: JavaScriptValueKinds {
+    return [.number, .bigint]
+  }
+
   @JavaScriptActor
   @inlinable
   public static func decode(_ value: borrowing JavaScriptValue, in runtime: borrowing JavaScriptRuntime) throws

package/apple/Sources/ExpoModulesJSI/Coding/JavaScriptDecodable.swift

@@ -13,9 +13,10 @@
 public protocol JavaScriptDecodable {
   /// Decodes an owning `JavaScriptValue` into `Self`.
   ///
-  /// This overload is the protocol requirement: every conformer provides it. It is also the
-  /// correct entry point for any value that must outlive the call (stored, captured, handed to a
-  /// `Promise`).
+  /// Defaulted (see the extension below) to borrow the value and decode it through the
+  /// `JavaScriptUnownedValue` overload, so a conformer may implement just that one. A conformer must
+  /// implement at least one of the two overloads: each default forwards to the other, so with neither
+  /// implemented a decode recurses until the stack overflows.
   @JavaScriptActor
   static func decode(_ value: borrowing JavaScriptValue, in runtime: borrowing JavaScriptRuntime) throws -> Self
 
@@ -24,13 +25,35 @@ public protocol JavaScriptDecodable {
   ///
   /// This is the argument-decode fast path: the value borrows the argument the
   /// `JavaScriptValuesBuffer` already owns for the duration of the call. It is defaulted (see the
-  /// extension below), so conformers get it for free by materializing an owning value; types that
-  /// can read straight from the borrowed value override it to stay zero-copy.
+  /// extension below) to materialize an owning value and decode that, for conformers that implement
+  /// only the owning overload; types that can read straight from the borrowed value implement it to
+  /// stay zero-copy.
   @JavaScriptActor
   static func decode(_ value: borrowing JavaScriptUnownedValue, in runtime: borrowing JavaScriptRuntime) throws -> Self
+
+  /// The kinds of JavaScript value `decode` can accept.
+  ///
+  /// A kind outside the set is definitive: `decode` would throw for a value of that kind. A kind in the
+  /// set only means the type may decode it, so `decode` can still throw, for example for an
+  /// out-of-range number or a missing record field. Code that picks between several types, like a
+  /// union, reads it to skip the ones that can't match without paying for a thrown error. Defaults to
+  /// `.all`, so a type that doesn't declare it is always tried.
+  static var decodableKinds: JavaScriptValueKinds { get }
 }
 
 extension JavaScriptDecodable {
+  /// Default owning decode: borrow the value and forward to the unowned overload, so a conformer that
+  /// implements only that one decodes owning values without a copy.
+  @JavaScriptActor
+  @inlinable
+  public static func decode(_ value: borrowing JavaScriptValue, in runtime: borrowing JavaScriptRuntime) throws -> Self
+  {
+    let runtime = copy runtime
+    return try value.withUnownedValue(in: runtime) { unownedValue in
+      return try decode(unownedValue, in: runtime)
+    }
+  }
+
   /// Default fast-path implementation: materialize an owning value and forward to the requirement.
   /// This is the "explicitly copy" behavior for types that cannot (or need not) read directly from
   /// the borrowed value.
@@ -44,4 +67,10 @@ extension JavaScriptDecodable {
   {
     return try decode(value.copied(in: runtime), in: runtime)
   }
+
+  /// Default: every kind, so a conformer that doesn't declare its kinds is always tried.
+  @inlinable
+  public static var decodableKinds: JavaScriptValueKinds {
+    return .all
+  }
 }

package/apple/Sources/ExpoModulesJSI/Coding/JavaScriptValueKinds.swift

@@ -0,0 +1,73 @@
+// Copyright 2026-present 650 Industries. All rights reserved.
+
+internal import jsi
+
+/// A set of JavaScript value kinds, as told apart by the value's type tag alone.
+///
+/// Unlike `JavaScriptValue.Kind`, a function is an `object` here: telling it apart needs a call into
+/// the runtime, while every kind in this set is read from the tag without one. Used by
+/// `JavaScriptDecodable.decodableKinds` to describe the kinds a type can decode from. Frozen, so a check
+/// against it compiles to a mask test in the client.
+@frozen
+public struct JavaScriptValueKinds: OptionSet, Sendable {
+  public let rawValue: UInt16
+
+  // `UInt16` leaves room for more kinds without changing the frozen layout.
+  //
+  // The kinds are computed and inlinable rather than stored `static let`s, which a client would reach
+  // through a lazily initialized global, so a mask built from them folds to a constant.
+
+  @inlinable
+  public init(rawValue: UInt16) {
+    self.rawValue = rawValue
+  }
+
+  @inlinable public static var undefined: JavaScriptValueKinds { JavaScriptValueKinds(rawValue: 1 << 0) }
+  @inlinable public static var null: JavaScriptValueKinds { JavaScriptValueKinds(rawValue: 1 << 1) }
+  @inlinable public static var bool: JavaScriptValueKinds { JavaScriptValueKinds(rawValue: 1 << 2) }
+  @inlinable public static var number: JavaScriptValueKinds { JavaScriptValueKinds(rawValue: 1 << 3) }
+  @inlinable public static var bigint: JavaScriptValueKinds { JavaScriptValueKinds(rawValue: 1 << 4) }
+  @inlinable public static var string: JavaScriptValueKinds { JavaScriptValueKinds(rawValue: 1 << 5) }
+  @inlinable public static var symbol: JavaScriptValueKinds { JavaScriptValueKinds(rawValue: 1 << 6) }
+  /// Any object, including arrays, typed arrays and functions.
+  @inlinable public static var object: JavaScriptValueKinds { JavaScriptValueKinds(rawValue: 1 << 7) }
+
+  /// Every kind, including any added later: the bits above the current kinds are set too, so a type that
+  /// accepts every kind keeps doing so.
+  @inlinable public static var all: JavaScriptValueKinds { JavaScriptValueKinds(rawValue: .max) }
+
+  /// The kind of `value`.
+  ///
+  /// Not inlinable on purpose: the type checks read the `jsi::Value`, which clients can't see, so an
+  /// inlined initializer would make one call into this module per check. Here it is a single call.
+  public init(of value: borrowing JavaScriptValue) {
+    self.init(of: value.pointee)
+  }
+
+  /// The kind of the borrowed `value`, read the same way as from an owning value.
+  public init(of value: borrowing JavaScriptUnownedValue) {
+    self.init(of: value.pointer.pointee)
+  }
+
+  /// Reads the kind from the `jsi::Value` both public initializers wrap. The checks go from the most to
+  /// the least common kind of an argument.
+  private init(of value: borrowing facebook.jsi.Value) {
+    if value.isNumber() {
+      self = .number
+    } else if value.isString() {
+      self = .string
+    } else if value.isObject() {
+      self = .object
+    } else if value.isBool() {
+      self = .bool
+    } else if value.isNull() {
+      self = .null
+    } else if value.isUndefined() {
+      self = .undefined
+    } else if value.isBigInt() {
+      self = .bigint
+    } else {
+      self = .symbol
+    }
+  }
+}

package/apple/Sources/ExpoModulesJSI/Protocols/JSIRepresentable.swift

@@ -93,14 +93,16 @@ extension String: JSIRepresentable {
     // allocation, copy and free per string. `withUTF8` is mutating (it makes a bridged string
     // contiguous first), hence the local copy; native strings are already contiguous and pay nothing.
     // The value is moved out through a local because `withUTF8` needs a `Copyable` closure result.
+    // The C++ helper moves the engine's `jsi::String` into the value, so this costs one engine handle;
+    // `jsi::Value(runtime, string)` would clone it and then release the original.
     var string = self
     var value = facebook.jsi.Value.undefined()
     string.withUTF8 { utf8 in
       guard let base = utf8.baseAddress else {
-        value = facebook.jsi.Value(runtime, facebook.jsi.String.createFromAscii(runtime, "", 0))
+        value = expo.createStringValueFromAscii(runtime, "", 0)
         return
       }
-      value = facebook.jsi.Value(runtime, facebook.jsi.String.createFromUtf8(runtime, base, utf8.count))
+      value = expo.createStringValueFromUtf8(runtime, base, utf8.count)
     }
     return value
   }

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

@@ -146,7 +146,7 @@ open class JavaScriptRuntime: Equatable, Identifiable, @unchecked Sendable {
     // when the last reference is gone. `deinit` is `nonisolated`, so it can touch the actor-isolated
     // registry directly given that exclusive access.
     propNameIdsRegistry.removeAll()
-    cachedDeferredPromiseFactory = nil
+    cache.clear()
     expo.destroyRuntime(runtimePointee)
   }
 
@@ -203,7 +203,8 @@ open class JavaScriptRuntime: Equatable, Identifiable, @unchecked Sendable {
         let propertyName = String(jsiPropNameID: propertyName.pointee, in: runtime.pointee)
         return JavaScriptActor.assumeIsolated {
           return forwardingSwiftErrorsToJS(runtime: runtime) {
-            try context.get(propertyName).writeJSIValue(to: resultPtr)
+            var result = try context.get(propertyName)
+            JavaScriptValue.write(&result, to: resultPtr)
           }
         }
       }
@@ -789,12 +790,14 @@ open class JavaScriptRuntime: Equatable, Identifiable, @unchecked Sendable {
   @JavaScriptActor
   internal var propNameIdsRegistry: [String: JavaScriptPropNameID] = [:]
 
-  // MARK: - Deferred promise factory
+  // MARK: - Cache
 
-  /// The JavaScript function ``JavaScriptPromise`` uses to create deferred promises, built on first
-  /// use and released with the runtime. See `JavaScriptPromise.init(_:)` for why it exists.
+  /// Values cached with ``cached(_:_:)``. Unchecked exclusivity skips the dynamic access checks on
+  /// every lookup: the cache is only used on the JavaScript thread, and `cached(_:_:)` never keeps an
+  /// access open while it calls out, so accesses can't overlap.
   @JavaScriptActor
-  internal var cachedDeferredPromiseFactory: JavaScriptValue?
+  @exclusivity(unchecked)
+  internal var cache = Cache()
 
   // MARK: - Long-lived objects
 
@@ -826,12 +829,12 @@ open class JavaScriptRuntime: Equatable, Identifiable, @unchecked Sendable {
         // hop back to the JavaScript thread first.
         JavaScriptActor.assumeIsolated {
           longLivedObjects.clear()
-          // Also flush the cached `jsi::PropNameID`s and the deferred-promise factory: a non-owning
-          // wrapper can outlive its runtime (e.g. captured by a task abandoned on reload) and would
-          // otherwise destroy them against the freed runtime when it deallocates. `self` is weak so
-          // the teardown object doesn't retain the wrapper; the owning wrapper clears both in `deinit`.
+          // Also flush the cached `jsi::PropNameID`s and the cache: a non-owning wrapper can outlive its
+          // runtime (e.g. captured by a task abandoned on reload) and would otherwise destroy them against
+          // the freed runtime when it deallocates. `self` is weak so the teardown object doesn't retain the
+          // wrapper; the owning wrapper clears both in `deinit`.
           self?.propNameIdsRegistry.removeAll()
-          self?.cachedDeferredPromiseFactory = nil
+          self?.cache.clear()
         }
       }
       let object = createObject()
@@ -883,7 +886,8 @@ private func createFunctionClosure(
           let this = UnsafeMutablePointer(mutating: thisPtr).move()
           let arguments = JavaScriptValuesBuffer(runtime, start: argumentsPtr, count: argumentsCount)
           let thisValue = JavaScriptValue(runtime, this)
-          try context.call(thisValue, consume arguments).writeJSIValue(to: resultPtr)
+          var result = try context.call(thisValue, consume arguments)
+          JavaScriptValue.write(&result, to: resultPtr)
         }
       }
     }
@@ -926,7 +930,8 @@ private func createFunctionClosure(
         return forwardingSwiftErrorsToJS(runtime: runtime) {
           let arguments = JavaScriptValuesBuffer(runtime, start: argumentsPtr, count: argumentsCount)
           let thisValue = JavaScriptUnownedValue(runtime.pointee, thisPtr)
-          try context.call(thisValue, consume arguments).writeJSIValue(to: resultPtr)
+          var result = try context.call(thisValue, consume arguments)
+          JavaScriptValue.write(&result, to: resultPtr)
         }
       }
     }

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

@@ -0,0 +1,74 @@
+// Copyright 2026-present 650 Industries. All rights reserved.
+
+import os
+
+extension JavaScriptRuntime {
+  /// Values cached by a runtime, stored by their keys' indices. Isolated to the JavaScript thread
+  /// together with the runtime that owns it. Values are read and created through
+  /// ``JavaScriptRuntime/cached(_:_:)``.
+  public struct Cache: ~Copyable {
+    /// A key for a value that a runtime creates once and then reuses, such as a JavaScript constructor
+    /// or a property name. Declare keys as `static let`s and pass them to ``JavaScriptRuntime/cached(_:_:)``.
+    ///
+    /// Each key gets a fixed index from a process-wide counter when it is created, so a lookup reads one
+    /// array slot instead of hashing a string. Every runtime keeps its own values for the same keys.
+    public struct Key<Value: AnyObject>: Sendable {
+      internal let index: Int
+
+      public init() {
+        self.index = nextCacheKeyIndex.withLock { index in
+          defer { index += 1 }
+          return index
+        }
+      }
+    }
+
+    // A slot per key index, up to the highest index used so far in this runtime. Slots of keys that
+    // haven't been used here yet are `nil`. `ContiguousArray` stores the references directly, without
+    // the bridging checks that `Array` can do for class elements on Apple platforms.
+    private var storage = ContiguousArray<AnyObject?>()
+
+    internal func value<Value>(for key: Key<Value>) -> Value? {
+      guard key.index < storage.count, let value = storage[key.index] else {
+        return nil
+      }
+      // The key's type guarantees the type of the value stored under it.
+      return unsafeDowncast(value, to: Value.self)
+    }
+
+    internal mutating func store<Value>(_ value: Value, for key: Key<Value>) {
+      if key.index >= storage.count {
+        storage.append(contentsOf: repeatElement(nil, count: key.index - storage.count + 1))
+      }
+      storage[key.index] = value
+    }
+
+    /// Releases all cached values. They often hold JSI objects, which must be destroyed before the
+    /// runtime they belong to.
+    internal mutating func clear() {
+      storage.removeAll()
+    }
+  }
+
+  /// Returns the value cached under `key`, creating it with `make` the first time the key is used in
+  /// this runtime. If `make` throws, nothing is cached and the next call tries again.
+  ///
+  /// `make` may look up other cached values, for example to build a prototype from a cached
+  /// constructor.
+  @JavaScriptActor
+  public func cached<Value>(_ key: Cache.Key<Value>, _ make: () throws -> Value) rethrows -> Value {
+    if let value = cache.value(for: key) {
+      return value
+    }
+    // Call `make` without accessing the cache, so that the lookups it does itself don't overlap with
+    // an access in progress here.
+    let value = try make()
+    cache.store(value, for: key)
+    return value
+  }
+}
+
+/// The index for the next created ``JavaScriptRuntime/Cache/Key``. Keys can be created on any thread,
+/// for example by initializing a `static let`, so the counter is behind a lock. That costs nothing on
+/// the lookup path, since each key takes an index only once.
+private let nextCacheKeyIndex = OSAllocatedUnfairLock(initialState: 0)

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

@@ -460,6 +460,32 @@ public struct JavaScriptArray: JavaScriptType, ~Copyable {
     return result
   }
 
+  /// Transforms each element like `map(_:)`, but lends each element to `transform` as a
+  /// `JavaScriptUnownedValue` instead of wrapping it in a new `JavaScriptValue`. An element is valid only
+  /// for the duration of its `transform` call and must not be stored or escaped.
+  public func mapUnowned<T>(_ transform: (borrowing JavaScriptUnownedValue) throws -> T) rethrows -> [T] {
+    guard let jsiRuntime else {
+      FatalError.runtimeLost()
+    }
+    let count = self.length
+    var result: [T] = []
+    result.reserveCapacity(count)
+    for index in 0..<count {
+      let element = pointee.getValueAtIndex(jsiRuntime, index)
+      // `withUnsafeBytes(of:)` rather than `withUnsafePointer(to:)`; see `JavaScriptValue.withUnsafePointee(_:)`.
+      try withUnsafeBytes(of: element) { bytes in
+        guard let baseAddress = bytes.baseAddress else {
+          preconditionFailure(
+            "withUnsafeBytes(of:) gave an empty buffer for a jsi::Value, which can't happen for a non-zero-sized type"
+          )
+        }
+        let pointer = baseAddress.assumingMemoryBound(to: facebook.jsi.Value.self)
+        result.append(try transform(JavaScriptUnownedValue(jsiRuntime, pointer)))
+      }
+    }
+    return result
+  }
+
   /// Converts the JavaScript array to a `JavaScriptValue`.
   ///
   /// - Returns: A `JavaScriptValue` representing this array

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

@@ -92,6 +92,14 @@ public struct JavaScriptObject: JavaScriptType, Sendable, ~Copyable {
     return pointee.isArrayBuffer(jsiRuntime)
   }
 
+  /// Returns `true` if the object is a typed array, such as `Uint8Array`.
+  internal func isTypedArray() -> Bool {
+    guard let runtime else {
+      FatalError.runtimeLost()
+    }
+    return expo.isTypedArray(runtime.pointee, pointee)
+  }
+
   /// Returns the object as an array buffer, or asserts if not an array buffer.
   public func getArrayBuffer() -> JavaScriptArrayBuffer {
     guard let runtime else {
@@ -138,6 +146,28 @@ public struct JavaScriptObject: JavaScriptType, Sendable, ~Copyable {
     return JavaScriptValue(runtimeHandle, pointee.getProperty(jsiRuntime, name.toJSIPropNameID(in: jsiRuntime)))
   }
 
+  /// Calls `body` with the property of the object with the given name, or `undefined` if there is no
+  /// such property, lent as a `JavaScriptUnownedValue` instead of wrapped in a new `JavaScriptValue`.
+  /// The value is valid only for the duration of the closure and must not be stored or escaped.
+  public func withUnownedProperty<R>(_ name: String, _ body: (borrowing JavaScriptUnownedValue) throws -> R) rethrows
+    -> R
+  {
+    guard let jsiRuntime else {
+      FatalError.runtimeLost()
+    }
+    let property = pointee.getProperty(jsiRuntime, name.toJSIPropNameID(in: jsiRuntime))
+    // `withUnsafeBytes(of:)` rather than `withUnsafePointer(to:)`; see `JavaScriptValue.withUnsafePointee(_:)`.
+    return try withUnsafeBytes(of: property) { bytes in
+      guard let baseAddress = bytes.baseAddress else {
+        preconditionFailure(
+          "withUnsafeBytes(of:) gave an empty buffer for a jsi::Value, which can't happen for a non-zero-sized type"
+        )
+      }
+      let pointer = baseAddress.assumingMemoryBound(to: facebook.jsi.Value.self)
+      return try body(JavaScriptUnownedValue(jsiRuntime, pointer))
+    }
+  }
+
   /// Returns the property of the object with the given prop name id,
   /// or `undefined` value if the name is not a property of the object.
   public func getProperty(_ propName: JavaScriptPropNameID) -> JavaScriptValue {

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

@@ -284,20 +284,20 @@ extension JavaScriptRuntime {
   /// optimize like any other closure.
   @JavaScriptActor
   fileprivate func deferredPromiseFactory() throws -> JavaScriptValue {
-    if let factory = cachedDeferredPromiseFactory {
-      return factory
+    return try cached(deferredPromiseFactoryKey) {
+      return try eval(
+        label: "expo-modules-jsi/deferred-promise.js",
+        """
+        (function () {
+          let resolve, reject;
+          const promise = new Promise(function (a, b) { resolve = a; reject = b; });
+          return [promise, resolve, reject];
+        })
+        """
+      )
     }
-    let factory = try eval(
-      label: "expo-modules-jsi/deferred-promise.js",
-      """
-      (function () {
-        let resolve, reject;
-        const promise = new Promise(function (a, b) { resolve = a; reject = b; });
-        return [promise, resolve, reject];
-      })
-      """
-    )
-    cachedDeferredPromiseFactory = factory
-    return factory
   }
 }
+
+/// Key of the deferred promise factory in each runtime's cache.
+private let deferredPromiseFactoryKey = JavaScriptRuntime.Cache.Key<JavaScriptValue>()

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

@@ -130,6 +130,23 @@ public struct JavaScriptUnownedValue: ~Copyable {
     return JavaScriptObject(runtime, pointer.pointee.getObject(self.runtime))
   }
 
+  /// Whether the value is an array. The zero-copy counterpart of ``JavaScriptValue/isArray()``.
+  public func isArray() -> Bool {
+    return pointer.pointee.isObject() && pointer.pointee.getObject(runtime).isArray(runtime)
+  }
+
+  /// Returns the value as a ``JavaScriptArray``, or asserts if it is not an array. The zero-copy
+  /// counterpart of ``JavaScriptValue/getArray()``, with the same runtime contract as
+  /// ``getObject(in:)``.
+  public func getArray(in runtime: JavaScriptRuntime) -> JavaScriptArray {
+    assert(isArray(), "Value is not an array")
+    assert(
+      Unmanaged.passUnretained(runtime.pointee).toOpaque() == Unmanaged.passUnretained(self.runtime).toOpaque(),
+      "`getArray(in:)` must be passed the runtime that owns the borrowed value"
+    )
+    return JavaScriptArray(runtime, pointer.pointee.getObject(self.runtime).getArray(self.runtime))
+  }
+
   // MARK: - Throwing conversions ("as functions")
 
   /// Returns the value as a boolean, or throws `TypeError` if it is not a boolean.