expo-modules-jsi 58.0.7 → 58.0.9

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()
@@ -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)
   }
 
@@ -197,13 +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) {
-            try context.get(propertyName).writeJSIValue(to: resultPtr)
+            var result = try context.get(propertyName)
+            JavaScriptValue.write(&result, to: resultPtr.value)
           }
         }
       }
@@ -692,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
@@ -789,12 +797,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 +836,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()
@@ -868,22 +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)
-          try context.call(thisValue, consume arguments).writeJSIValue(to: resultPtr)
+          var result = try context.call(thisValue, consume arguments)
+          JavaScriptValue.write(&result, to: resultPtr.value)
         }
       }
     }
@@ -915,18 +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)
-          try context.call(thisValue, consume arguments).writeJSIValue(to: resultPtr)
+          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.value)
         }
       }
     }

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

@@ -146,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 {
@@ -353,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>(
@@ -652,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/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.

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

@@ -10,7 +10,10 @@ public final class JavaScriptValue: JavaScriptType, Equatable, Escapable {
   /// Handle to the runtime the value belongs to. `nil` only for runtime-free values (undefined, null,
   /// booleans and numbers).
   internal let runtimeHandle: JavaScriptRuntimeHandle?
-  internal let pointee: facebook.jsi.Value
+  /// Mutable only so that ``write(_:to:)`` can move the engine value out of a uniquely referenced
+  /// instance on the JS thread, right before it is deallocated. Unchecked exclusivity keeps reads of
+  /// a mutable class property free of the dynamic exclusivity check.
+  @exclusivity(unchecked) nonisolated(unsafe) internal var pointee: facebook.jsi.Value
 
   /// The runtime the value belongs to, or `nil` if it has been deallocated or the value is runtime-free.
   /// Prefer ``jsiRuntime`` on hot paths: it costs no reference counting.
@@ -119,6 +122,45 @@ public final class JavaScriptValue: JavaScriptType, Equatable, Escapable {
     }
   }
 
+  /// Calls `body` with a `JavaScriptUnownedValue` that borrows this value's `jsi::Value`, without
+  /// copying it. The unowned value is valid only for the duration of the closure and must not be
+  /// stored or escaped.
+  ///
+  /// `runtime` must be the runtime the value belongs to. It is passed in because a runtime-free value
+  /// (undefined, null, a boolean or a number) doesn't hold one.
+  ///
+  /// Inlinable, so the closure and `R` specialize in the caller; only `borrowUnownedValue(in:)` is a
+  /// call into this module.
+  @inlinable
+  public func withUnownedValue<R>(
+    in runtime: borrowing JavaScriptRuntime,
+    _ body: (borrowing JavaScriptUnownedValue) throws -> R
+  ) rethrows -> R {
+    let unownedValue = borrowUnownedValue(in: runtime)
+    // The unowned value points into `self`, so `self` must outlive `body`.
+    defer { withExtendedLifetime(self) {} }
+    return try body(unownedValue)
+  }
+
+  /// A `JavaScriptUnownedValue` pointing at the stored `jsi::Value`. It stays valid while `self` is
+  /// alive: the value is a stored property of this instance, so its address doesn't change, and
+  /// `withUnsafeBytes(of:)` yields that address because a `jsi::Value` can't be copied. Not inlinable,
+  /// since it touches the JSI types; `withUnownedValue(in:_:)` is the only caller.
+  @usableFromInline
+  internal func borrowUnownedValue(in runtime: borrowing JavaScriptRuntime) -> JavaScriptUnownedValue {
+    let pointer = withUnsafeBytes(of: pointee) { bytes in
+      // `withUnsafeBytes(of:)` rather than `withUnsafePointer(to:)`, for the same SIL optimizer crash
+      // `withUnsafePointee(_:)` avoids.
+      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"
+        )
+      }
+      return baseAddress.assumingMemoryBound(to: facebook.jsi.Value.self)
+    }
+    return JavaScriptUnownedValue(runtime.pointee, pointer)
+  }
+
   // MARK: - Type checks
 
   public func isUndefined() -> Bool {
@@ -534,6 +576,17 @@ public final class JavaScriptValue: JavaScriptType, Equatable, Escapable {
     return copy()
   }
 
+  /// Writes `value` into a host callback's result slot. A uniquely referenced instance, the normal
+  /// case for a value the callback just created, has its engine value moved out instead of cloned,
+  /// since the instance is deallocated right after. Shared instances go through ``writeJSIValue(to:)``.
+  internal static func write(_ value: inout JavaScriptValue, to slot: UnsafeMutablePointer<facebook.jsi.Value>) {
+    if value.runtimeHandle != nil, isKnownUniquelyReferenced(&value) {
+      expo.emplaceMovedValue(slot, &value.pointee)
+    } else {
+      value.writeJSIValue(to: slot)
+    }
+  }
+
   /// Writes this value into a host callback's result slot. Undefined, null, booleans and numbers are
   /// emplaced with the engine's inline constructors, so the common results skip the out-of-line
   /// `jsi::Value` move and destroy that assigning to the slot would cost; everything else is copied

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/String+JSI.swift

@@ -69,9 +69,10 @@ private func appendEngineStringChunk(ctx: UnsafeMutableRawPointer?, ascii: Bool,
   let chunk: String
   if ascii {
     let bytes = UnsafeBufferPointer(start: data.assumingMemoryBound(to: UInt8.self), count: count)
-    chunk = String(unsafeUninitializedCapacity: count) { buffer in
-      return buffer.initialize(fromContentsOf: bytes)
-    }
+    // `String(decoding:as:)` re-validates bytes the engine already guarantees to be ASCII, but it
+    // builds short strings inline. `String(unsafeUninitializedCapacity:)` always allocates heap
+    // storage first, which measured 5 to 10 ns slower for 6 and 22 byte strings.
+    chunk = String(decoding: bytes, as: UTF8.self)
   } else {
     let units = UnsafeBufferPointer(start: data.assumingMemoryBound(to: UInt16.self), count: count)
     if count < 512 {

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
+  }
+}