expo-modules-jsi 58.0.4 → 58.0.6

package/CHANGELOG.md

@@ -1,14 +1,18 @@
 # Changelog
 
-## Unpublished
+## 58.0.6
 
-### 🛠 Breaking changes
+### Patch Changes
 
-### 🎉 New features
+- [iOS] Read host object property names through `getPropNameIdData` instead of building a `std::string` for every access, making property access from JavaScript up to 14% faster for long names. ([#50805](https://github.com/expo/expo/pull/50805) by [@tsapeta](https://github.com/tsapeta))
+- [iOS] The `JavaScriptValue`, `JavaScriptObject` and `JavaScriptArray` initializers now take the runtime as `borrowing`, so callers no longer retain it for the call, making host functions that return strings or numbers up to ~15% faster. ([#50844](https://github.com/expo/expo/pull/50844) by [@tsapeta](https://github.com/tsapeta))
+- [iOS] `JavaScriptValue`, `JavaScriptObject` and `JavaScriptArray` now hold a strong runtime handle instead of a `weak` reference to the runtime, which removes the weak reference traffic and slow-path reference counting from their hot paths (for example `getObject()` ~16×, `getArray()` ~12× and `getProperty(_:)` ~1.8× faster). ([#50806](https://github.com/expo/expo/pull/50806) by [@tsapeta](https://github.com/tsapeta))
 
-### 🐛 Bug fixes
+## 58.0.5
 
-### 💡 Others
+### Patch Changes
+
+- Force-bump all packages, due to migration to changesets. ([#50762](https://github.com/expo/expo/pull/50762) by [@kitten](https://github.com/kitten))
 
 ## 58.0.4 — 2026-09-25
 

package/apple/Benchmarks/HostObjectBenchmarks.swift

@@ -0,0 +1,57 @@
+// Copyright 2026-present 650 Industries. All rights reserved.
+
+import ExpoModulesJSI
+import Testing
+
+/// End-to-end benchmarks for JavaScript accessing properties of a Swift host object. A JavaScript
+/// driver function runs the measured loop, so each operation covers the engine's dispatch to the host
+/// object, handing the property name to Swift, and the result or assigned value crossing back.
+extension JSIBenchmarks {
+  @Test
+  func `host object property get`() async throws {
+    try await benchmarkCase { runtime in
+      let hostObject = runtime.createHostObject(get: { _ in
+        return JavaScriptValue.number(42)
+      })
+      runtime.global().setProperty("benchHostObject", value: hostObject)
+      let driver = try runtime.eval("(function(n) { for (var i = 0; i < n; i++) benchHostObject.answer; })")
+        .getFunction()
+      try benchmark("host object: get", runtime: runtime) { iterations in
+        _ = try driver.call(arguments: iterations)
+      }
+    }
+  }
+
+  @Test
+  func `host object property get with long name`() async throws {
+    try await benchmarkCase { runtime in
+      let hostObject = runtime.createHostObject(get: { _ in
+        return JavaScriptValue.number(42)
+      })
+      runtime.global().setProperty("benchHostObject", value: hostObject)
+      // Longer than the 22-byte inline capacity of libc++'s `std::string`.
+      let driver = try runtime.eval(
+        "(function(n) { for (var i = 0; i < n; i++) benchHostObject.aPropertyNameLongerThanTheInlineCapacity; })"
+      ).getFunction()
+      try benchmark("host object: get, 40B name", runtime: runtime) { iterations in
+        _ = try driver.call(arguments: iterations)
+      }
+    }
+  }
+
+  @Test
+  func `host object property set`() async throws {
+    try await benchmarkCase { runtime in
+      let hostObject = runtime.createHostObject(
+        get: { _ in .undefined },
+        set: { _, _ in }
+      )
+      runtime.global().setProperty("benchHostObject", value: hostObject)
+      let driver = try runtime.eval("(function(n) { for (var i = 0; i < n; i++) benchHostObject.answer = i; })")
+        .getFunction()
+      try benchmark("host object: set", runtime: runtime) { iterations in
+        _ = try driver.call(arguments: iterations)
+      }
+    }
+  }
+}

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

@@ -61,9 +61,7 @@ extension String: JavaScriptCodable {
   public static func encode(_ value: String, in runtime: borrowing JavaScriptRuntime) throws
     -> JavaScriptValue
   {
-    // The `JavaScriptValue(_:_:)` initializer takes the runtime by owned convention (it stores it),
-    // so an owned copy is needed from the borrowed parameter.
-    return JavaScriptValue(copy runtime, value)
+    return JavaScriptValue(runtime, value)
   }
 }
 
@@ -281,7 +279,7 @@ extension Int64: JavaScriptCodable {
   @JavaScriptActor
   @inlinable
   public static func encode(_ value: Int64, in runtime: borrowing JavaScriptRuntime) throws -> JavaScriptValue {
-    return JavaScriptValue(copy runtime, bigInt: value)
+    return JavaScriptValue(runtime, bigInt: value)
   }
 }
 
@@ -405,7 +403,7 @@ extension UInt64: JavaScriptCodable {
   public static func encode(_ value: UInt64, in runtime: borrowing JavaScriptRuntime) throws
     -> JavaScriptValue
   {
-    return JavaScriptValue(copy runtime, bigInt: value)
+    return JavaScriptValue(runtime, bigInt: value)
   }
 }
 
@@ -457,7 +455,7 @@ func decodeWideInteger<T: FixedWidthInteger>(
       // constructing `TypeError` here, which this inlinable helper can't reference.
       return try decodeInteger(value.asDouble(), as: T.self)
     }
-    return try decodeBigInt(value.copied(in: copy runtime).getBigInt(), as: T.self)
+    return try decodeBigInt(value.copied(in: runtime).getBigInt(), as: T.self)
   }
   return try decodeInteger(value.getDouble(), as: T.self)
 }

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

@@ -12,10 +12,10 @@ internal protocol JSIRepresentable: JavaScriptRepresentable, Sendable, ~Copyable
 
 extension JSIRepresentable {
   public static func fromJavaScriptValue(_ value: JavaScriptValue) -> Self {
-    guard let jsiRuntime = value.runtime else {
+    guard let jsiRuntime = value.jsiRuntime else {
       FatalError.runtimeLost()
     }
-    return Self.fromJSIValue(value.pointee, in: jsiRuntime.pointee)
+    return Self.fromJSIValue(value.pointee, in: jsiRuntime)
   }
 
   public func toJavaScriptValue(in runtime: JavaScriptRuntime) -> JavaScriptValue {

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

@@ -39,10 +39,9 @@ extension Array: JavaScriptRepresentable where Element: JavaScriptRepresentable
 
 extension Dictionary: JavaScriptRepresentable where Key == String, Value: JavaScriptRepresentable {
   public static func fromJavaScriptValue(_ value: JavaScriptValue) -> Self {
-    guard let runtime = value.runtime else {
+    guard let runtimeHandle = value.runtimeHandle, let jsiRuntime = runtimeHandle.pointee else {
       FatalError.runtimeLost()
     }
-    let jsiRuntime = runtime.pointee
     let object = value.pointee.getObject(jsiRuntime)
     let propertyNames = object.getPropertyNames(jsiRuntime)
     let size = propertyNames.size(jsiRuntime)
@@ -54,7 +53,7 @@ extension Dictionary: JavaScriptRepresentable where Key == String, Value: JavaSc
       // Look the value up by the key string the engine handed back instead of re-encoding the Swift
       // key: it skips one engine string allocation per entry and round-trips any name exactly.
       let jsiKey = propertyNames.getValueAtIndex(jsiRuntime, index).getString(jsiRuntime)
-      let jsiValue = JavaScriptValue(runtime, object.getProperty(jsiRuntime, jsiKey))
+      let jsiValue = JavaScriptValue(runtimeHandle, object.getProperty(jsiRuntime, jsiKey))
       result[String(jsiString: jsiKey, in: jsiRuntime)] = Value.fromJavaScriptValue(jsiValue)
     }
     return result

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

@@ -38,6 +38,10 @@ open class JavaScriptRuntime: Equatable, Identifiable, @unchecked Sendable {
   internal let runtimePointee: facebook.jsi.Runtime
   internal let scheduler: expo.RuntimeScheduler
 
+  /// Strong handle that values hold instead of a `weak` reference to the runtime. See
+  /// ``JavaScriptRuntimeHandle`` for why.
+  internal let handle: JavaScriptRuntimeHandle
+
   /// Whether this wrapper owns the underlying `jsi::Runtime` and must destroy it on `deinit`. True
   /// only for the standalone `init()`, which creates the runtime via `createHermesRuntime()`. The
   /// other initializers adopt a runtime owned elsewhere (e.g. React Native), which must never be
@@ -62,8 +66,10 @@ open class JavaScriptRuntime: Equatable, Identifiable, @unchecked Sendable {
   internal init(_ runtime: facebook.jsi.Runtime) {
     self.runtimePointee = runtime
     self.pointee = expo.iruntime(runtime)
+    self.handle = JavaScriptRuntimeHandle(self.pointee)
     self.scheduler = expo.RuntimeScheduler()
     self.ownsRuntime = false
+    handle.attach(self)
     installLongLivedObjectsTeardown()
   }
 
@@ -73,8 +79,10 @@ open class JavaScriptRuntime: Equatable, Identifiable, @unchecked Sendable {
     let runtime = expo.createHermesRuntime()
     self.runtimePointee = runtime
     self.pointee = expo.iruntime(runtime)
+    self.handle = JavaScriptRuntimeHandle(self.pointee)
     self.scheduler = expo.RuntimeScheduler()
     self.ownsRuntime = true
+    handle.attach(self)
     installLongLivedObjectsTeardown()
   }
 
@@ -85,8 +93,10 @@ open class JavaScriptRuntime: Equatable, Identifiable, @unchecked Sendable {
     let runtime = unsafeBitCast(unsafePointer, to: facebook.jsi.Runtime.self)
     self.runtimePointee = runtime
     self.pointee = expo.iruntime(runtime)
+    self.handle = JavaScriptRuntimeHandle(self.pointee)
     self.scheduler = expo.RuntimeScheduler()
     self.ownsRuntime = false
+    handle.attach(self)
     installLongLivedObjectsTeardown()
   }
 
@@ -112,12 +122,15 @@ open class JavaScriptRuntime: Equatable, Identifiable, @unchecked Sendable {
     let fn = unsafeBitCast(dispatch, to: expo.RuntimeScheduler.ScheduleFn.self)
     self.runtimePointee = runtime
     self.pointee = expo.iruntime(runtime)
+    self.handle = JavaScriptRuntimeHandle(self.pointee)
     self.scheduler = expo.RuntimeScheduler(scheduler, fn)
     self.ownsRuntime = false
+    handle.attach(self)
     installLongLivedObjectsTeardown()
   }
 
   deinit {
+    handle.detach()
     // Destroy the runtime only if this wrapper created it (standalone `init()`); adopted runtimes
     // are owned elsewhere (e.g. React Native) and must not be freed here.
     guard ownsRuntime else {
@@ -181,13 +194,13 @@ open class JavaScriptRuntime: Equatable, Identifiable, @unchecked Sendable {
   ) -> JavaScriptObject {
     func getter(
       context: UnsafeMutableRawPointer,
-      propertyName: UnsafePointer<CChar>,
+      propertyName: UnsafePointer<facebook.jsi.PropNameID>,
       resultPtr: UnsafeMutablePointer<facebook.jsi.Value>
     ) -> Bool {
-      let propertyName = String(cString: propertyName)
       nonisolated(unsafe) let resultPtr = 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)
@@ -198,15 +211,14 @@ open class JavaScriptRuntime: Equatable, Identifiable, @unchecked Sendable {
 
     func setter(
       context: UnsafeMutableRawPointer,
-      propertyName: UnsafePointer<CChar>,
+      propertyName: UnsafePointer<facebook.jsi.PropNameID>,
       valuePointer: UnsafeMutableRawPointer
     ) -> Bool {
-      let propertyName = String(cString: propertyName)
-
       return withGuaranteedContext(context) { (context: HostObjectContext, runtime) in
+        let propertyName = String(jsiPropNameID: propertyName.pointee, in: runtime.pointee)
         guard let set = context.set else {
           // Unreachable in practice: when the user passed `nil` for `set`, the call site
-          // below at `expo.HostObjectCallbacks(...)` also passes `nil` to C++, and
+          // below creates the read-only `expo.HostObjectCallbacks` without a setter, and
           // `HostObjectCallbacks::set` throws a `jsi::JSError` directly instead of
           // calling back into Swift. Trap loudly so a future C++ refactor can't silently
           // swallow assignments.
@@ -255,17 +267,12 @@ open class JavaScriptRuntime: Equatable, Identifiable, @unchecked Sendable {
 
     let context = Unmanaged.passRetained(HostObjectContext(runtime: self, get, set, getPropertyNames, dealloc))
       .toOpaque()
-    let setterPointer:
-      (@convention(c) (UnsafeMutableRawPointer, UnsafePointer<CChar>, UnsafeMutableRawPointer) -> Bool)? = setter
-    // Pass a null setter to C++ when the Swift setter is nil so that JS assignment
-    // raises a `jsi::JSError` directly, without crossing the Swift boundary.
-    let callbacks = expo.HostObjectCallbacks(
-      context,
-      getter,
-      set == nil ? nil : setterPointer,
-      propertyNamesGetter,
-      deallocate
-    )
+    // Without a Swift setter, use the read-only callbacks so that JS assignment raises a
+    // `jsi::JSError` directly, without crossing the Swift boundary.
+    let callbacks =
+      set == nil
+      ? expo.HostObjectCallbacks(context, getter, propertyNamesGetter, deallocate)
+      : expo.HostObjectCallbacks(context, getter, setter, propertyNamesGetter, deallocate)
     let hostObject = expo.HostObject.makeObject(pointee, consume callbacks)
 
     return JavaScriptObject(self, hostObject)

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

@@ -0,0 +1,67 @@
+// Copyright 2026-present 650 Industries. All rights reserved.
+
+internal import jsi
+
+/// A strong handle to a ``JavaScriptRuntime`` that values hold instead of a `weak` reference to the
+/// runtime itself.
+///
+/// A `weak` reference gives the runtime a side table, and from then on every strong retain and
+/// release of the runtime takes the slow atomic path, on top of the cost of the weak loads, stores and
+/// destroys. Values did all of these on every access. The handle is never weakly referenced, so the
+/// retain and release that storing it costs stay on the inline fast path, and reading the engine
+/// runtime through it costs no ARC at all: `IRuntime` is imported as an immortal reference.
+///
+/// The runtime owns its handle and marks it dead in `deinit`, so values that outlive the runtime still
+/// detect it through ``runtime`` or ``pointee`` returning `nil`.
+///
+/// Unlike a `weak` reference, the liveness check is not atomic and does not keep the runtime alive for
+/// the rest of the call. Values must not be used concurrently with the runtime's `deinit`, which holds
+/// as long as the last reference to the runtime is released on the JavaScript thread (as
+/// `AppContext.destroy()` does).
+///
+/// Not to be confused with the engine's handles to JavaScript values (`jsi::PointerValue`).
+internal final class JavaScriptRuntimeHandle: @unchecked Sendable {
+  /// The runtime that owns this handle, cleared by the runtime's `deinit`. Read it through ``runtime``
+  /// instead.
+  private unowned(unsafe) var unsafeRuntime: JavaScriptRuntime?
+
+  /// The engine runtime, cleared by the runtime's `deinit`. Liveness is checked on this field rather
+  /// than on ``unsafeRuntime``: `IRuntime` is an immortal reference, so reading it and checking it for
+  /// `nil` costs no reference counting, whereas checking the runtime reference for `nil` retains the
+  /// runtime, which is the slow-path traffic this handle exists to avoid.
+  nonisolated(unsafe) private var jsiRuntime: facebook.jsi.IRuntime?
+
+  internal init(_ pointee: facebook.jsi.IRuntime) {
+    self.jsiRuntime = pointee
+  }
+
+  /// Links the handle to its runtime. Called at the end of the runtime's initializers, once `self`
+  /// is available.
+  internal func attach(_ runtime: JavaScriptRuntime) {
+    unsafeRuntime = runtime
+  }
+
+  /// Marks the runtime as gone. Called from the runtime's `deinit`.
+  internal func detach() {
+    jsiRuntime = nil
+    unsafeRuntime = nil
+  }
+
+  /// Whether the runtime that owns this handle is still alive.
+  @inline(__always)
+  internal var isAlive: Bool {
+    return jsiRuntime != nil
+  }
+
+  /// The runtime, or `nil` if it has been deallocated.
+  @inline(__always)
+  internal var runtime: JavaScriptRuntime? {
+    return isAlive ? unsafeRuntime : nil
+  }
+
+  /// The engine runtime, or `nil` if the runtime has been deallocated.
+  @inline(__always)
+  internal var pointee: facebook.jsi.IRuntime? {
+    return jsiRuntime
+  }
+}

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

@@ -191,13 +191,14 @@ public struct JavaScriptValuesBuffer: JavaScriptType, ~Copyable {
 
   /// Allocates a new owning buffer holding a runtime-aware copy of each value's
   /// underlying `facebook.jsi.Value`. The given `JavaScriptValue`s must all belong
-  /// to `runtime`; mixing runtimes will crash deep inside JSI.
+  /// to `runtime` or be runtime-free; mixing runtimes will crash deep inside JSI.
   @JavaScriptActor
   public static func copying(in runtime: JavaScriptRuntime, values: [JavaScriptValue]) -> JavaScriptValuesBuffer {
     let buffer = UnsafeMutableBufferPointer<facebook.jsi.Value>.allocate(capacity: values.count)
     for (index, value) in values.enumerated() {
+      // Runtime-free values (undefined, null, booleans and numbers) have no handle and fit any runtime.
       assert(
-        value.runtime === runtime,
+        value.runtimeHandle == nil || value.runtimeHandle === runtime.handle,
         "JavaScriptValue belongs to a different runtime than the buffer being initialized"
       )
       buffer.initializeElement(at: index, to: facebook.jsi.Value(runtime.pointee, value.pointee))

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

@@ -5,7 +5,19 @@ internal import jsi
 /// and Swift, allowing you to access and manipulate JavaScript array elements from Swift code. It maintains a reference
 /// to the underlying JavaScript array and provides Swift-friendly APIs for common array operations.
 public struct JavaScriptArray: JavaScriptType, ~Copyable {
-  internal weak let runtime: JavaScriptRuntime?
+  /// Handle to the runtime the array belongs to.
+  internal let runtimeHandle: JavaScriptRuntimeHandle
+
+  /// The runtime the array belongs to, or `nil` if it has been deallocated. Prefer ``jsiRuntime`` on
+  /// hot paths: it costs no reference counting.
+  internal var runtime: JavaScriptRuntime? {
+    return runtimeHandle.runtime
+  }
+
+  /// The engine runtime the array belongs to, or `nil` if the runtime has been deallocated.
+  internal var jsiRuntime: facebook.jsi.IRuntime? {
+    return runtimeHandle.pointee
+  }
   internal let pointee: facebook.jsi.Array
 
   /// Creates a new JavaScript array with the specified length.
@@ -33,7 +45,7 @@ public struct JavaScriptArray: JavaScriptType, ~Copyable {
   /// - Note: This initializer creates a new JavaScript array object in the runtime's heap.
   ///   The array's length can be modified later using the `length` property.
   /// - SeeAlso: `init(_:items:)` for creating arrays with initial values
-  public init(_ runtime: JavaScriptRuntime, length: Int = 0) {
+  public init(_ runtime: borrowing JavaScriptRuntime, length: Int = 0) {
     self.init(runtime, facebook.jsi.Array(runtime.pointee, length))
   }
 
@@ -52,8 +64,14 @@ public struct JavaScriptArray: JavaScriptType, ~Copyable {
   ///   by library consumers.
   /// - Note: The `pointee` parameter uses consuming ownership, meaning the JSI array
   ///   object is moved into this structure and the caller's copy is invalidated.
-  internal init(_ runtime: JavaScriptRuntime, _ pointee: consuming facebook.jsi.Array) {
-    self.runtime = runtime
+  internal init(_ runtime: borrowing JavaScriptRuntime, _ pointee: consuming facebook.jsi.Array) {
+    self.runtimeHandle = runtime.handle
+    self.pointee = pointee
+  }
+
+  /// Creates an array from existing JSI array, which belongs to the runtime behind `runtimeHandle`.
+  internal init(_ runtimeHandle: JavaScriptRuntimeHandle, _ pointee: consuming facebook.jsi.Array) {
+    self.runtimeHandle = runtimeHandle
     self.pointee = pointee
   }
 
@@ -85,7 +103,7 @@ public struct JavaScriptArray: JavaScriptType, ~Copyable {
   ///   implementation creates an empty array first and then populates it element by element,
   ///   rather than using JSI's `createWithElements` method directly.
   /// - SeeAlso: `init(_:items:)` for the variadic argument version
-  public init(_ runtime: JavaScriptRuntime, items: [JavaScriptValue]) {
+  public init(_ runtime: borrowing JavaScriptRuntime, items: [JavaScriptValue]) {
     self.init(runtime, length: items.count)
 
     for (i, item) in items.enumerated() {
@@ -121,7 +139,7 @@ public struct JavaScriptArray: JavaScriptType, ~Copyable {
   ///   array-based initializer. If you already have an array of values, consider using
   ///   `init(_:items:)` directly for cleaner syntax.
   /// - SeeAlso: `init(_:items:)` for the array version
-  public init(_ runtime: JavaScriptRuntime, items: JavaScriptValue...) {
+  public init(_ runtime: borrowing JavaScriptRuntime, items: JavaScriptValue...) {
     self.init(runtime, items: items)
   }
 
@@ -159,7 +177,7 @@ public struct JavaScriptArray: JavaScriptType, ~Copyable {
   /// - Note: Unlike the `JavaScriptValue` variadic initializer, this version accepts heterogeneous
   ///   types directly without requiring explicit `JavaScriptValue` wrapping.
   /// - SeeAlso: `init(_:items:)` for the `JavaScriptValue` array version
-  public init<each T: JavaScriptRepresentable>(_ runtime: JavaScriptRuntime, items: repeat each T) {
+  public init<each T: JavaScriptRepresentable>(_ runtime: borrowing JavaScriptRuntime, items: repeat each T) {
     var length: Int = 0
     for _ in repeat each items {
       length += 1
@@ -210,16 +228,16 @@ public struct JavaScriptArray: JavaScriptType, ~Copyable {
   ///   providing the same semantics as `array.length = newValue` in JavaScript.
   public var length: Int {
     get {
-      guard let runtime else {
+      guard let jsiRuntime else {
         FatalError.runtimeLost()
       }
-      return pointee.size(runtime.pointee)
+      return pointee.size(jsiRuntime)
     }
     nonmutating set(newLength) {
-      guard let runtime else {
+      guard let jsiRuntime else {
         FatalError.runtimeLost()
       }
-      expo.setArrayLength(runtime.pointee, pointee, newLength)
+      expo.setArrayLength(jsiRuntime, pointee, newLength)
     }
   }
 
@@ -230,22 +248,22 @@ public struct JavaScriptArray: JavaScriptType, ~Copyable {
   /// - Throws: `JavaScriptArray.Errors.indexOutOfRange` if the index is negative or
   ///   greater than or equal to the array's length
   public func getValue(at index: Int) throws -> JavaScriptValue {
-    guard let runtime else {
+    guard let jsiRuntime else {
       FatalError.runtimeLost()
     }
     let length = self.length
     guard (0..<length).contains(index) else {
       throw Errors.indexOutOfRange(index: index, length: length)
     }
-    return JavaScriptValue(runtime, pointee.getValueAtIndex(runtime.pointee, index))
+    return JavaScriptValue(runtimeHandle, pointee.getValueAtIndex(jsiRuntime, index))
   }
 
   /// Returns the value at the given index without bounds-checking. Used by the iteration
   /// helpers (`map`, `forEach`, `reduce`, `filter`, `enumerated`) which iterate
   /// `0..<length` and never produce an out-of-range index. Skipping the redundant bounds
   /// check avoids a weak-runtime load on every element on the hot path.
-  internal func getValueUnchecked(at index: Int, in runtime: JavaScriptRuntime) -> JavaScriptValue {
-    return JavaScriptValue(runtime, pointee.getValueAtIndex(runtime.pointee, index))
+  internal func getValueUnchecked(at index: Int, in jsiRuntime: facebook.jsi.IRuntime) -> JavaScriptValue {
+    return JavaScriptValue(runtimeHandle, pointee.getValueAtIndex(jsiRuntime, index))
   }
 
   /// Sets the element at the specified index.
@@ -305,13 +323,13 @@ public struct JavaScriptArray: JavaScriptType, ~Copyable {
       return (try? self.getValue(at: index)) ?? .undefined
     }
     nonmutating set {
-      guard let runtime else {
+      guard let jsiRuntime else {
         FatalError.runtimeLost()
       }
       if index >= length {
         self.length = index + 1
       }
-      expo.setValueAtIndex(runtime.pointee, pointee, index, newValue.pointee)
+      expo.setValueAtIndex(jsiRuntime, pointee, index, newValue.pointee)
     }
   }
 
@@ -401,18 +419,18 @@ public struct JavaScriptArray: JavaScriptType, ~Copyable {
   ///   array elements by index, use the numeric subscript `array[0]` instead of `array["0"]`.
   public subscript(key: String) -> JavaScriptValue {
     get {
-      guard let runtime else {
+      guard let jsiRuntime else {
         FatalError.runtimeLost()
       }
-      let jsiValue = expo.getProperty(runtime.pointee, pointee, key.toJSIPropNameID(in: runtime.pointee))
-      return JavaScriptValue(runtime, jsiValue)
+      let jsiValue = expo.getProperty(jsiRuntime, pointee, key.toJSIPropNameID(in: jsiRuntime))
+      return JavaScriptValue(runtimeHandle, jsiValue)
     }
     nonmutating set(newValue) {
-      guard let runtime else {
+      guard let jsiRuntime else {
         FatalError.runtimeLost()
       }
-      let jsiValue = newValue.toJSIValue(in: runtime.pointee)
-      expo.setProperty(runtime.pointee, pointee, key.toJSIPropNameID(in: runtime.pointee), jsiValue)
+      let jsiValue = newValue.toJSIValue(in: jsiRuntime)
+      expo.setProperty(jsiRuntime, pointee, key.toJSIPropNameID(in: jsiRuntime), jsiValue)
     }
   }
 
@@ -429,14 +447,14 @@ public struct JavaScriptArray: JavaScriptType, ~Copyable {
   /// - Note: This method uses Swift's standard `map` semantics and follows the `rethrows`
   ///   pattern, meaning it only throws if the transform closure throws.
   public func map<T>(_ transform: (_ value: JavaScriptValue) throws -> T) rethrows -> [T] {
-    guard let runtime else {
+    guard let jsiRuntime else {
       FatalError.runtimeLost()
     }
     let count = self.length
     var result: [T] = []
     result.reserveCapacity(count)
     for index in 0..<count {
-      let value = getValueUnchecked(at: index, in: runtime)
+      let value = getValueUnchecked(at: index, in: jsiRuntime)
       result.append(try transform(value))
     }
     return result
@@ -449,10 +467,10 @@ public struct JavaScriptArray: JavaScriptType, ~Copyable {
   ///   array, so modifications to the array in JavaScript will be reflected in the value.
   /// - SeeAlso: `JavaScriptValue.getArray()` for the inverse operation
   public func asValue() -> JavaScriptValue {
-    guard let runtime else {
+    guard let jsiRuntime else {
       FatalError.runtimeLost()
     }
-    return JavaScriptValue(runtime, expo.valueFromArray(runtime.pointee, pointee))
+    return JavaScriptValue(runtimeHandle, expo.valueFromArray(jsiRuntime, pointee))
   }
 
   /// Converts the array to a `JavaScriptObject`.
@@ -509,38 +527,38 @@ extension JavaScriptArray {
   ///
   /// - Note: Eagerly evaluates all elements. For large arrays, prefer `forEach(_:)`.
   public func enumerated() -> [(offset: Int, element: JavaScriptValue)] {
-    guard let runtime else {
+    guard let jsiRuntime else {
       FatalError.runtimeLost()
     }
     let count = self.length
     var result: [(offset: Int, element: JavaScriptValue)] = []
     result.reserveCapacity(count)
     for index in 0..<count {
-      result.append((offset: index, element: getValueUnchecked(at: index, in: runtime)))
+      result.append((offset: index, element: getValueUnchecked(at: index, in: jsiRuntime)))
     }
     return result
   }
 
   /// Calls the given closure on each element in the array.
   public func forEach(_ body: (JavaScriptValue) throws -> Void) rethrows {
-    guard let runtime else {
+    guard let jsiRuntime else {
       FatalError.runtimeLost()
     }
     let count = self.length
     for index in 0..<count {
-      try body(getValueUnchecked(at: index, in: runtime))
+      try body(getValueUnchecked(at: index, in: jsiRuntime))
     }
   }
 
   /// Returns an array of elements satisfying the given predicate.
   public func filter(_ isIncluded: (JavaScriptValue) throws -> Bool) rethrows -> [JavaScriptValue] {
-    guard let runtime else {
+    guard let jsiRuntime else {
       FatalError.runtimeLost()
     }
     let count = self.length
     var result: [JavaScriptValue] = []
     for index in 0..<count {
-      let value = getValueUnchecked(at: index, in: runtime)
+      let value = getValueUnchecked(at: index, in: jsiRuntime)
       if try isIncluded(value) {
         result.append(value)
       }
@@ -552,13 +570,13 @@ extension JavaScriptArray {
   public func reduce<Result>(_ initialResult: Result, _ nextPartialResult: (Result, JavaScriptValue) throws -> Result)
     rethrows -> Result
   {
-    guard let runtime else {
+    guard let jsiRuntime else {
       FatalError.runtimeLost()
     }
     let count = self.length
     var result = initialResult
     for index in 0..<count {
-      result = try nextPartialResult(result, getValueUnchecked(at: index, in: runtime))
+      result = try nextPartialResult(result, getValueUnchecked(at: index, in: jsiRuntime))
     }
     return result
   }

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

@@ -92,10 +92,10 @@ public struct JavaScriptFunction: JavaScriptType, ~Copyable {
   // MARK: - Conversions
 
   public func asValue() -> JavaScriptValue {
-    guard let jsiRuntime = runtime?.pointee else {
+    guard let runtime else {
       FatalError.runtimeLost()
     }
-    return JavaScriptValue(runtime, expo.valueFromFunction(jsiRuntime, pointee))
+    return JavaScriptValue(runtime, expo.valueFromFunction(runtime.pointee, pointee))
   }
 
   /// Returns the function as a `facebook.jsi.Value` instance.