expo-modules-jsi 57.0.7 → 57.0.8

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

@@ -178,16 +178,19 @@ open class JavaScriptRuntime: Equatable, Identifiable, @unchecked Sendable {
     getPropertyNames: @escaping @JavaScriptActor () -> [String] = { [] },
     dealloc: @escaping @JavaScriptActor () -> Void = {}
   ) -> JavaScriptObject {
-    func getter(context: UnsafeMutableRawPointer, propertyName: UnsafePointer<CChar>) -> facebook.jsi.Value {
-      let context = Unmanaged<HostObjectContext>.fromOpaque(context).takeUnretainedValue()
+    func getter(
+      context: UnsafeMutableRawPointer,
+      propertyName: UnsafePointer<CChar>,
+      resultPtr: UnsafeMutablePointer<facebook.jsi.Value>
+    ) {
       let propertyName = String(cString: propertyName)
+      nonisolated(unsafe) let resultPtr = resultPtr
 
-      guard let runtime = context.runtime else {
-        FatalError.runtimeLost()
-      }
-      return JavaScriptActor.assumeIsolated {
-        return forwardingSwiftErrorsToJS(runtime: runtime) {
-          return try context.get(propertyName).asJSIValue()
+      withGuaranteedContext(context) { (context: HostObjectContext, runtime) in
+        resultPtr.pointee = JavaScriptActor.assumeIsolated {
+          return forwardingSwiftErrorsToJS(runtime: runtime) {
+            return try context.get(propertyName).asJSIValue()
+          }
         }
       }
     }
@@ -195,34 +198,33 @@ open class JavaScriptRuntime: Equatable, Identifiable, @unchecked Sendable {
     func setter(
       context: UnsafeMutableRawPointer, propertyName: UnsafePointer<CChar>, valuePointer: UnsafeMutableRawPointer
     ) {
-      let context = Unmanaged<HostObjectContext>.fromOpaque(context).takeUnretainedValue()
-
-      guard let runtime = context.runtime else {
-        FatalError.runtimeLost()
-      }
-      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
-        // `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.
-        FatalError.readOnlyHostObjectSetterInvoked()
-      }
-      let value = JavaScriptValue(runtime, valuePointer.assumingMemoryBound(to: facebook.jsi.Value.self).move())
       let propertyName = String(cString: propertyName)
 
-      JavaScriptActor.assumeIsolated {
-        forwardingSwiftErrorsToJS(runtime: runtime) {
-          try set(propertyName, value)
+      withGuaranteedContext(context) { (context: HostObjectContext, runtime) in
+        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
+          // `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.
+          FatalError.readOnlyHostObjectSetterInvoked()
+        }
+        let value = JavaScriptValue(runtime, valuePointer.assumingMemoryBound(to: facebook.jsi.Value.self).move())
+
+        JavaScriptActor.assumeIsolated {
+          forwardingSwiftErrorsToJS(runtime: runtime) {
+            try set(propertyName, value)
+          }
         }
       }
     }
 
     func propertyNamesGetter(context: UnsafeMutableRawPointer) -> expo.HostObjectCallbacks.PropNameIds {
       let context = Unmanaged<HostObjectContext>.fromOpaque(context).takeUnretainedValue()
-
-      guard let runtime = context.runtime else {
-        FatalError.runtimeLost()
+      // `IRuntime` is an immortal reference, so reading it through the guaranteed wrapper
+      // reference costs no reference counting here either.
+      let iRuntime = context.runtime._withUnsafeGuaranteedRef { runtime in
+        return runtime.pointee
       }
       // Get property names within the actor isolation, but build the vector outside
       // to avoid returning a non-copyable C++ type through `assumeIsolated`
@@ -235,7 +237,7 @@ open class JavaScriptRuntime: Equatable, Identifiable, @unchecked Sendable {
       vector.reserve(propertyNames.count)
 
       for propertyName in propertyNames {
-        let propNameId = facebook.jsi.PropNameID.forUtf8(runtime.pointee, std.string(propertyName))
+        let propNameId = facebook.jsi.PropNameID.forUtf8(iRuntime, std.string(propertyName))
         vector.push_back(consuming: propNameId)
       }
       return vector
@@ -646,6 +648,22 @@ open class JavaScriptRuntime: Equatable, Identifiable, @unchecked Sendable {
     return result.is("Promise") ? try await result.getPromise().await() : result
   }
 
+  // MARK: - Garbage collection
+
+  /// Requests a full, synchronous garbage collection of the JavaScript heap.
+  ///
+  /// Intended for tests and memory diagnostics. The engine collects on its own, so calling this in
+  /// production code usually costs more than it saves.
+  ///
+  /// - Note: This is a no-op on engines whose runtime doesn't implement GC instrumentation. JSI's
+  ///   default implementation does nothing; Hermes overrides it with a real collection.
+  /// - Parameter cause: Reason for the collection, as the engine should report it in its logs.
+  ///   Defaults to the calling function's name.
+  @JavaScriptActor
+  public func collectGarbage(cause: String = #function) {
+    expo.collectGarbage(pointee, std.string(cause))
+  }
+
   // MARK: - Equatable
 
   public static func == (lhs: JavaScriptRuntime, rhs: JavaScriptRuntime) -> Bool {
@@ -727,15 +745,12 @@ private func createFunctionClosure(
   let context = Unmanaged.passRetained(HostFunctionContext(runtime: runtime, name: name, closure)).toOpaque()
 
   func call(
-    context: UnsafeMutableRawPointer, thisPtr: UnsafePointer<facebook.jsi.Value>,
-    argumentsPtr: UnsafePointer<facebook.jsi.Value>, argumentsCount: Int
-  ) -> facebook.jsi.Value {
-    let context = Unmanaged<HostFunctionContext>.fromOpaque(context).takeUnretainedValue()
-
-    guard let runtime = context.runtime else {
-      FatalError.runtimeLost()
-    }
-
+    context: UnsafeMutableRawPointer,
+    thisPtr: UnsafePointer<facebook.jsi.Value>,
+    argumentsPtr: UnsafePointer<facebook.jsi.Value>,
+    argumentsCount: Int,
+    resultPtr: UnsafeMutablePointer<facebook.jsi.Value>
+  ) {
     // `assumeIsolated` runs `operation` synchronously, in this very scope — it never escapes and never
     // hops threads (see `JavaScriptActor.assumeIsolated`). So rather than materializing the move-only
     // `JavaScriptValuesBuffer` out here and smuggling it across the closure boundary through a
@@ -747,13 +762,18 @@ private func createFunctionClosure(
     // floor.
     nonisolated(unsafe) let thisPtr = thisPtr
     nonisolated(unsafe) let argumentsPtr = argumentsPtr
+    nonisolated(unsafe) let resultPtr = resultPtr
 
-    return JavaScriptActor.assumeIsolated {
-      return forwardingSwiftErrorsToJS(runtime: runtime) {
-        let this = UnsafeMutablePointer(mutating: thisPtr).move()
-        let arguments = JavaScriptValuesBuffer(runtime, start: argumentsPtr, count: argumentsCount)
-        let thisValue = JavaScriptValue(runtime, this)
-        return try context.call(thisValue, consume arguments).asJSIValue()
+    // 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.
+    withGuaranteedContext(context) { (context: HostFunctionContext, runtime) in
+      resultPtr.pointee = JavaScriptActor.assumeIsolated {
+        return forwardingSwiftErrorsToJS(runtime: runtime) {
+          let this = UnsafeMutablePointer(mutating: thisPtr).move()
+          let arguments = JavaScriptValuesBuffer(runtime, start: argumentsPtr, count: argumentsCount)
+          let thisValue = JavaScriptValue(runtime, this)
+          return try context.call(thisValue, consume arguments).asJSIValue()
+        }
       }
     }
   }
@@ -772,15 +792,12 @@ private func createFunctionClosure(
   let context = Unmanaged.passRetained(UnownedThisHostFunctionContext(runtime: runtime, name: name, closure)).toOpaque()
 
   func call(
-    context: UnsafeMutableRawPointer, thisPtr: UnsafePointer<facebook.jsi.Value>,
-    argumentsPtr: UnsafePointer<facebook.jsi.Value>, argumentsCount: Int
-  ) -> facebook.jsi.Value {
-    let context = Unmanaged<UnownedThisHostFunctionContext>.fromOpaque(context).takeUnretainedValue()
-
-    guard let runtime = context.runtime else {
-      FatalError.runtimeLost()
-    }
-
+    context: UnsafeMutableRawPointer,
+    thisPtr: UnsafePointer<facebook.jsi.Value>,
+    argumentsPtr: UnsafePointer<facebook.jsi.Value>,
+    argumentsCount: Int,
+    resultPtr: UnsafeMutablePointer<facebook.jsi.Value>
+  ) {
     // Same call-scoped reasoning as the owning-`this` overload above (see its comment) for why the
     // buffer is built inside the synchronous `assumeIsolated` closure. Here `this` is additionally
     // handed in as a borrowed `JavaScriptUnownedValue` pointing straight at the C++-owned `this` slot:
@@ -788,12 +805,17 @@ private func createFunctionClosure(
     // 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
 
-    return JavaScriptActor.assumeIsolated {
-      return forwardingSwiftErrorsToJS(runtime: runtime) {
-        let arguments = JavaScriptValuesBuffer(runtime, start: argumentsPtr, count: argumentsCount)
-        let thisValue = JavaScriptUnownedValue(runtime.pointee, thisPtr)
-        return try context.call(thisValue, consume arguments).asJSIValue()
+    // 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.
+    withGuaranteedContext(context) { (context: UnownedThisHostFunctionContext, runtime) in
+      resultPtr.pointee = JavaScriptActor.assumeIsolated {
+        return forwardingSwiftErrorsToJS(runtime: runtime) {
+          let arguments = JavaScriptValuesBuffer(runtime, start: argumentsPtr, count: argumentsCount)
+          let thisValue = JavaScriptUnownedValue(runtime.pointee, thisPtr)
+          return try context.call(thisValue, consume arguments).asJSIValue()
+        }
       }
     }
   }

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

@@ -6,7 +6,12 @@ internal import jsi
 public struct JavaScriptValuesBuffer: JavaScriptType, ~Copyable {
   // Safe to use unowned — the buffer's lifetime is scoped to a host function call,
   // so the runtime is always alive while the buffer exists.
-  internal unowned let runtime: JavaScriptRuntime
+  //
+  // `unowned(unsafe)` rather than `unowned`: the runtime object carries a refcount side table (other
+  // wrappers hold it `weak`), so a safe `unowned` retain/release on it takes the slow side-table path
+  // on every buffer construction and destruction. Profiling showed that pair as roughly a third of the
+  // native-side cost of a no-op `@JS` host call. `unowned(unsafe)` is a plain pointer store/load.
+  internal unowned(unsafe) let runtime: JavaScriptRuntime
 
   // The raw `facebook.jsi.IRuntime`, cached alongside the `JavaScriptRuntime` wrapper. `IRuntime` is
   // an immortal reference (`jsi.apinotes`), so reading it costs no ARC, whereas reading `.pointee`
@@ -65,7 +70,7 @@ public struct JavaScriptValuesBuffer: JavaScriptType, ~Copyable {
   }
 
   public subscript(index: Int) -> JavaScriptValue {
-    return JavaScriptValue(runtime, bufferPointer[index])
+    return JavaScriptValue(runtime, copying: bufferPointer[index])
   }
 
   /// Returns a non-owning, non-copyable value borrowing the element at `index` for the zero-copy decode

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

@@ -404,7 +404,7 @@ public struct JavaScriptArray: JavaScriptType, ~Copyable {
       guard let runtime else {
         FatalError.runtimeLost()
       }
-      let jsiValue = expo.getProperty(runtime.pointee, pointee, .forUtf8(runtime.pointee, key, key.count))
+      let jsiValue = expo.getProperty(runtime.pointee, pointee, key.toJSIPropNameID(in: runtime.pointee))
       return JavaScriptValue(runtime, jsiValue)
     }
     nonmutating set(newValue) {
@@ -412,7 +412,7 @@ public struct JavaScriptArray: JavaScriptType, ~Copyable {
         FatalError.runtimeLost()
       }
       let jsiValue = newValue.toJSIValue(in: runtime.pointee)
-      expo.setProperty(runtime.pointee, pointee, key, jsiValue)
+      expo.setProperty(runtime.pointee, pointee, key.toJSIPropNameID(in: runtime.pointee), jsiValue)
     }
   }
 

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

@@ -231,8 +231,7 @@ public struct JavaScriptBigInt: JavaScriptType, Sendable, ~Copyable {
     guard radix >= 2 && radix <= 36 else {
       throw BigIntConversionError.invalidRadix(radix)
     }
-    let jsiString = pointee.toString(runtime.pointee, Int32(radix))
-    return String(jsiString.utf16(runtime.pointee))
+    return String(jsiString: pointee.toString(runtime.pointee, Int32(radix)), in: runtime.pointee)
   }
 
   // MARK: - JavaScriptType

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

@@ -105,7 +105,7 @@ public struct JavaScriptObject: JavaScriptType, Sendable, ~Copyable {
     guard let runtime else {
       FatalError.runtimeLost()
     }
-    return pointee.hasProperty(runtime.pointee, name)
+    return pointee.hasProperty(runtime.pointee, name.toJSIPropNameID(in: runtime.pointee))
   }
 
   /// Returns the property of the object with the given name,
@@ -114,7 +114,7 @@ public struct JavaScriptObject: JavaScriptType, Sendable, ~Copyable {
     guard let runtime else {
       FatalError.runtimeLost()
     }
-    return JavaScriptValue(runtime, pointee.getProperty(runtime.pointee, name))
+    return JavaScriptValue(runtime, pointee.getProperty(runtime.pointee, name.toJSIPropNameID(in: runtime.pointee)))
   }
 
   /// Returns the property of the object with the given prop name id,
@@ -163,7 +163,7 @@ public struct JavaScriptObject: JavaScriptType, Sendable, ~Copyable {
     let count = propertyNames.size(jsiRuntime)
 
     return (0..<count).map { i in
-      return String(propertyNames.getValueAtIndex(jsiRuntime, i).getString(jsiRuntime).utf8(jsiRuntime))
+      return String(jsiString: propertyNames.getValueAtIndex(jsiRuntime, i).getString(jsiRuntime), in: jsiRuntime)
     }
   }
 
@@ -230,7 +230,12 @@ public struct JavaScriptObject: JavaScriptType, Sendable, ~Copyable {
       FatalError.runtimeLost()
     }
     // This specialization is to avoid copying the value; `asValue()` on `JavaScriptValue` needs to do a copy.
-    expo.setProperty(runtime.pointee, pointee, name, value.toJSIValue(in: runtime.pointee))
+    expo.setProperty(
+      runtime.pointee,
+      pointee,
+      name.toJSIPropNameID(in: runtime.pointee),
+      value.toJSIValue(in: runtime.pointee)
+    )
   }
 
   public func setProperty<T: JavaScriptRepresentable & ~Copyable>(_ name: String, value: consuming T) {
@@ -238,7 +243,7 @@ public struct JavaScriptObject: JavaScriptType, Sendable, ~Copyable {
       FatalError.runtimeLost()
     }
     let jsiValue = value.toJavaScriptValue(in: runtime).toJSIValue(in: runtime.pointee)
-    expo.setProperty(runtime.pointee, pointee, name, jsiValue)
+    expo.setProperty(runtime.pointee, pointee, name.toJSIPropNameID(in: runtime.pointee), jsiValue)
   }
 
   internal func setProperty<T: JavaScriptRepresentable>(_ name: String, value: consuming T) where T: JSIRepresentable {
@@ -246,14 +251,19 @@ public struct JavaScriptObject: JavaScriptType, Sendable, ~Copyable {
       FatalError.runtimeLost()
     }
     let jsiValue = value.toJSIValue(in: runtime.pointee)
-    expo.setProperty(runtime.pointee, pointee, name, jsiValue)
+    expo.setProperty(runtime.pointee, pointee, name.toJSIPropNameID(in: runtime.pointee), jsiValue)
   }
 
   public func setProperty(_ name: String, _ object: consuming JavaScriptObject) {
     guard let runtime else {
       FatalError.runtimeLost()
     }
-    expo.setProperty(runtime.pointee, pointee, name, facebook.jsi.Value(runtime.pointee, object.pointee))
+    expo.setProperty(
+      runtime.pointee,
+      pointee,
+      name.toJSIPropNameID(in: runtime.pointee),
+      facebook.jsi.Value(runtime.pointee, object.pointee)
+    )
   }
 
   /// Sets a property to a synchronous host function created from the given closure. The function
@@ -307,7 +317,7 @@ public struct JavaScriptObject: JavaScriptType, Sendable, ~Copyable {
     guard let runtime else {
       FatalError.runtimeLost()
     }
-    pointee.deleteProperty(runtime.pointee, name)
+    pointee.deleteProperty(runtime.pointee, name.toJSIPropNameID(in: runtime.pointee))
   }
   #endif
 

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

@@ -48,7 +48,7 @@ public struct JavaScriptUnownedValue: ~Copyable {
     assert(
       Unmanaged.passUnretained(runtime.pointee).toOpaque() == Unmanaged.passUnretained(self.runtime).toOpaque(),
       "`copied(in:)` must be passed the runtime that owns the borrowed value")
-    return JavaScriptValue(runtime, pointer.pointee)
+    return JavaScriptValue(runtime, copying: pointer.pointee)
   }
 
   // MARK: - Type checks
@@ -108,7 +108,7 @@ public struct JavaScriptUnownedValue: ~Copyable {
   /// 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).utf8(runtime))
+    return String(jsiString: pointer.pointee.getString(runtime), in: runtime)
   }
 
   /// Returns the value as a ``JavaScriptObject`` *without* materializing an owning ``JavaScriptValue``

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

@@ -10,14 +10,26 @@ public final class JavaScriptValue: JavaScriptType, Equatable, Escapable {
   internal weak let runtime: JavaScriptRuntime?
   internal let pointee: facebook.jsi.Value
 
-  /// Initializer from the existing JSI value.
+  /// Takes ownership of the given JSI value. Only runtime-free values (undefined, null, booleans and
+  /// numbers) pass `nil` here.
   internal init(_ runtime: JavaScriptRuntime?, _ pointee: consuming facebook.jsi.Value) {
     self.runtime = runtime
     self.pointee = pointee
   }
 
-  /// Copy initializer from the existing JSI value.
-  internal init(_ runtime: JavaScriptRuntime, _ pointee: borrowing facebook.jsi.Value) {
+  /// Takes ownership of the given JSI value. Same as the optional-runtime overload, but the exact
+  /// parameter type keeps the caller from promoting its runtime to an optional, which costs a
+  /// retain/release pair around every call on the hot paths (property reads, function results).
+  internal init(_ runtime: JavaScriptRuntime, _ pointee: consuming facebook.jsi.Value) {
+    self.runtime = runtime
+    self.pointee = pointee
+  }
+
+  /// Copies the given JSI value, which asks the engine to clone the handle for pointer values.
+  /// The `copying:` label keeps this initializer from being picked for temporaries: with a plain
+  /// second argument, a non-optional runtime used to win overload resolution over the consuming
+  /// initializer above, cloning every freshly returned value instead of taking it over.
+  internal init(_ runtime: JavaScriptRuntime, copying pointee: borrowing facebook.jsi.Value) {
     self.runtime = runtime
     self.pointee = facebook.jsi.Value(runtime.pointee, pointee)
   }
@@ -31,8 +43,7 @@ public final class JavaScriptValue: JavaScriptType, Equatable, Escapable {
   /// Creates a string JS value.
   public init(_ runtime: JavaScriptRuntime, _ string: String) {
     self.runtime = runtime
-    self.pointee = facebook.jsi.Value(
-      runtime.pointee, facebook.jsi.String.createFromUtf8(runtime.pointee, std.string(string)))
+    self.pointee = string.toJSIValue(in: runtime.pointee)
   }
 
   /// Creates a BigInt JS value from an Int64.
@@ -251,7 +262,7 @@ public final class JavaScriptValue: JavaScriptType, Equatable, Escapable {
       FatalError.runtimeLost()
     }
     assert(isString(), "Value is not a string")
-    return String(pointee.getString(jsiRuntime).utf8(jsiRuntime))
+    return String(jsiString: pointee.getString(jsiRuntime), in: jsiRuntime)
   }
 
   /// Returns the value as a BigInt, or asserts if not a BigInt.
@@ -418,7 +429,7 @@ public final class JavaScriptValue: JavaScriptType, Equatable, Escapable {
     guard let jsiRuntime = runtime?.pointee else {
       FatalError.runtimeLost()
     }
-    return String(pointee.toString(jsiRuntime).utf8(jsiRuntime))
+    return String(jsiString: pointee.toString(jsiRuntime), in: jsiRuntime)
   }
 
   /// Converts the JavaScript value to a JSON string representation.

package/apple/Sources/ExpoModulesJSI/Utilities/String+JSI.swift

@@ -0,0 +1,130 @@
+// Copyright 2026-present 650 Industries. All rights reserved.
+
+internal import ExpoModulesJSI_Cxx
+import Foundation
+internal import jsi
+
+extension String {
+  /// Builds a Swift `String` from a `jsi::String` by reading the engine's internal representation
+  /// through `getStringData`, without materializing a `std::string` first.
+  ///
+  /// Hermes stores strings as either ASCII bytes or UTF-16 code units and hands over whichever it
+  /// has, chunk by chunk (only rope strings arrive in several chunks). ASCII bytes are valid UTF-8 and
+  /// are copied as-is with no validation. UTF-16 is transcoded to UTF-8 on the Swift side, which is
+  /// several times cheaper than letting the engine produce UTF-8 through `utf8()` and validating it
+  /// again in Swift. Measured against `utf8()`: 12-byte ASCII unchanged, 4 KB ASCII 3.7x faster,
+  /// 4 KB non-ASCII 2.4x faster, 12-byte non-ASCII unchanged.
+  internal init(jsiString: borrowing facebook.jsi.String, in runtime: facebook.jsi.IRuntime) {
+    var result = ""
+    withUnsafeMutablePointer(to: &result) { resultPtr in
+      runtime.getStringData(jsiString, UnsafeMutableRawPointer(resultPtr), appendEngineStringChunk)
+    }
+    self = result
+  }
+
+  /// Builds a `jsi::PropNameID` from the string's UTF-8 bytes. This is how every String-keyed
+  /// property API turns its name into a key: JSI's `const char*` overloads treat the bytes as ASCII
+  /// and would mangle any non-ASCII name.
+  internal func toJSIPropNameID(in runtime: facebook.jsi.IRuntime) -> facebook.jsi.PropNameID {
+    // The `(pointer, length)` overload needs the UTF-8 *byte* count, which `withUTF8` provides
+    // exactly; `String.count` would be wrong here because it counts grapheme clusters (e.g. `"café"`
+    // reports 4 for 5 UTF-8 bytes). `withUTF8` is mutating (it makes a bridged string contiguous
+    // first), hence the local copy, and the result leaves the closure through an optional because
+    // it has to be a `Copyable` type.
+    var string = self
+    var propNameID: facebook.jsi.PropNameID? = nil
+    string.withUTF8 { utf8 in
+      guard let base = utf8.baseAddress else {
+        propNameID = facebook.jsi.PropNameID.forAscii(runtime, "", 0)
+        return
+      }
+      propNameID = facebook.jsi.PropNameID.forUtf8(runtime, base, utf8.count)
+    }
+    return propNameID.take()!
+  }
+}
+
+/// Callback for `getStringData`. `ctx` points at the Swift `String` being built; each call appends
+/// one chunk of the engine's internal representation to it.
+private func appendEngineStringChunk(ctx: UnsafeMutableRawPointer?, ascii: Bool, data: UnsafeRawPointer?, count: Int) {
+  guard count > 0, let data else {
+    // An empty chunk adds nothing to the result. Guarding here also keeps the pointer
+    // arithmetic below free of optionals on both paths.
+    return
+  }
+  let out = ctx!.assumingMemoryBound(to: String.self)
+  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)
+    }
+  } else {
+    let units = UnsafeBufferPointer(start: data.assumingMemoryBound(to: UInt16.self), count: count)
+    if count < 512 {
+      // Short strings: transcode straight into the string's UTF-8 storage, sized for the worst case
+      // of 3 UTF-8 bytes per UTF-16 code unit (a surrogate pair is 4 bytes for 2 units). This is
+      // 1.5-1.6x faster than `String(decoding:as:)` up to a few hundred code units, which carries a
+      // fixed setup cost of a few hundred nanoseconds.
+      chunk = String(unsafeUninitializedCapacity: count * 3) { buffer in
+        return transcodeUTF16(units, into: buffer)
+      }
+    } else {
+      // Long strings: the loop and the standard library's bulk decoder run at the same speed here,
+      // but the bulk decoder sizes the storage exactly, while the string above keeps its 3x worst-case
+      // capacity. That matters once strings are kilobytes rather than bytes.
+      chunk = String(decoding: units, as: UTF16.self)
+    }
+  }
+  if out.pointee.isEmpty {
+    out.pointee = chunk
+  } else {
+    out.pointee += chunk
+  }
+}
+
+/// Writes the UTF-8 encoding of `units` into `buffer` and returns the number of bytes written.
+/// Unpaired surrogates become U+FFFD, one per code unit, which is what `String(decoding:as:)` and
+/// `transcode(stoppingOnError: false)` produce. It replaces the standard library's `transcode`, which
+/// calls back once per output byte; this loop writes each scalar's bytes directly.
+/// `buffer` must hold at least 3 bytes per code unit.
+private func transcodeUTF16(
+  _ units: UnsafeBufferPointer<UInt16>,
+  into buffer: UnsafeMutableBufferPointer<UInt8>
+) -> Int {
+  var index = 0
+  var written = 0
+  while index < units.count {
+    let unit = UInt32(units[index])
+    index += 1
+    let scalar: UInt32
+    if unit < 0xD800 || unit > 0xDFFF {
+      scalar = unit
+    } else if unit < 0xDC00, index < units.count, (0xDC00...0xDFFF).contains(units[index]) {
+      scalar = 0x10000 + ((unit - 0xD800) << 10) + (UInt32(units[index]) - 0xDC00)
+      index += 1
+    } else {
+      scalar = 0xFFFD
+    }
+    if scalar < 0x80 {
+      buffer[written] = UInt8(scalar)
+      written += 1
+    } else if scalar < 0x800 {
+      buffer[written] = UInt8(0xC0 | (scalar >> 6))
+      buffer[written + 1] = UInt8(0x80 | (scalar & 0x3F))
+      written += 2
+    } else if scalar < 0x10000 {
+      buffer[written] = UInt8(0xE0 | (scalar >> 12))
+      buffer[written + 1] = UInt8(0x80 | ((scalar >> 6) & 0x3F))
+      buffer[written + 2] = UInt8(0x80 | (scalar & 0x3F))
+      written += 3
+    } else {
+      buffer[written] = UInt8(0xF0 | (scalar >> 18))
+      buffer[written + 1] = UInt8(0x80 | ((scalar >> 12) & 0x3F))
+      buffer[written + 2] = UInt8(0x80 | ((scalar >> 6) & 0x3F))
+      buffer[written + 3] = UInt8(0x80 | (scalar & 0x3F))
+      written += 4
+    }
+  }
+  return written
+}

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

@@ -12,7 +12,10 @@ namespace expo {
  */
 class HostFunctionClosure final : public RetainedSwiftPointer {
 public:
-  using Closure = facebook::jsi::Value(Context context, const facebook::jsi::Value *_Nonnull thisValue, const facebook::jsi::Value *_Nonnull args, size_t count);
+  // The result travels through an out-parameter instead of a return value: the Swift side can then
+  // write it straight into the caller's slot from inside its guaranteed-reference scope, with no
+  // placeholder value to construct and no extra move of the `jsi::Value`.
+  using Closure = void(Context context, const facebook::jsi::Value *_Nonnull thisValue, const facebook::jsi::Value *_Nonnull args, size_t count, facebook::jsi::Value *_Nonnull result);
 
   explicit HostFunctionClosure(Context context, Closure closure, Deallocator deallocator) : RetainedSwiftPointer(context, deallocator), _closure(closure) {};
 
@@ -23,8 +26,8 @@ public:
   /**
    Calls the Swift closure with given `this` value and arguments.
    */
-  inline facebook::jsi::Value call(const facebook::jsi::Value &thisValue, const facebook::jsi::Value *_Nonnull args, size_t count) const {
-    return _closure(_context, &thisValue, args, count);
+  inline void call(const facebook::jsi::Value &thisValue, const facebook::jsi::Value *_Nonnull args, size_t count, facebook::jsi::Value &result) const {
+    _closure(_context, &thisValue, args, count, &result);
   }
 
 private:

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

@@ -23,7 +23,8 @@ public:
   }
 
   inline jsi::Value get(jsi::Runtime &runtime, const jsi::PropNameID &name) override {
-    auto result = _callbacks.get(name.utf8(runtime).c_str());
+    jsi::Value result;
+    _callbacks.get(name.utf8(runtime).c_str(), result);
     // If the Swift getter stored a pending error, rethrow its JSError directly
     // to preserve all properties (message, code, stack, etc.).
     if (auto *error = CppError::getCurrent()) {

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

@@ -16,7 +16,9 @@ class HostObjectCallbacks final {
 public:
   using Context = void *_Nonnull;
   using PropNameIds = std::vector<facebook::jsi::PropNameID>;
-  using Getter = facebook::jsi::Value(Context, const char *_Nonnull name);
+  // The getter writes its result through an out-parameter, like `HostFunctionClosure`, so the
+  // Swift side can fill the caller's slot from inside its guaranteed-reference scope.
+  using Getter = void(Context, const char *_Nonnull name, facebook::jsi::Value *_Nonnull result);
   using Setter = void(Context, const char *_Nonnull name, void *_Nonnull value);
   using PropertyNamesGetter = PropNameIds(Context);
   using Deallocator = void(Context);
@@ -24,8 +26,8 @@ public:
   explicit HostObjectCallbacks(Context context, Getter getter, Setter *_Nullable setter, PropertyNamesGetter propertyNamesGetter, Deallocator deallocator)
   : _context(context), _getter(getter), _setter(setter), _propertyNamesGetter(propertyNamesGetter), _deallocator(deallocator) {}
 
-  inline facebook::jsi::Value get(const char *_Nonnull name) const {
-    return _getter(_context, name);
+  inline void get(const char *_Nonnull name, facebook::jsi::Value &result) const {
+    _getter(_context, name, &result);
   }
 
   /**

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

@@ -5,6 +5,9 @@
 
 #include <TargetConditionals.h>
 
+// `jsi.h` only forward-declares `jsi::Instrumentation`.
+#include <jsi/instrumentation.h>
+
 #include "HostFunctionClosure.h"
 #include "CppError.h"
 #include "IRuntimeCompat.h"
@@ -36,11 +39,13 @@ inline jsi::Value valueFromFunction(jsi::IRuntime &runtime, const jsi::Function
 }
 
 // `jsi::Object::setProperty` is a template function that Swift does not support. We need to provide specialized versions.
-inline void setProperty(jsi::IRuntime &runtime, const jsi::Object &object, const char *name, const jsi::Value value) {
+// They take a `jsi::PropNameID` rather than a `const char *`: JSI treats a `const char *` name as ASCII,
+// which mangles non-ASCII property names coming from Swift strings.
+inline void setProperty(jsi::IRuntime &runtime, const jsi::Object &object, const jsi::PropNameID &name, const jsi::Value &value) {
   object.setProperty(runtime, name, value);
 }
 
-inline void setProperty(jsi::IRuntime &runtime, const jsi::Array &array, const char *name, const jsi::Value &value) {
+inline void setProperty(jsi::IRuntime &runtime, const jsi::Array &array, const jsi::PropNameID &name, const jsi::Value &value) {
   array.setProperty(runtime, name, value);
 }
 
@@ -97,7 +102,8 @@ inline std::shared_ptr<const jsi::Buffer> makeSharedStringBuffer(const std::stri
 inline jsi::Function createHostFunction(jsi::IRuntime &runtime, const jsi::PropNameID &propName, HostFunctionClosure *closure) {
   auto closurePtr = std::shared_ptr<HostFunctionClosure>(closure);
   return jsi::Function::createFromHostFunction(runtime, propName, 0, [closurePtr](jsi::Runtime &runtime, const jsi::Value &thisValue, const jsi::Value *_Nonnull args, size_t count) -> jsi::Value {
-    auto result = closurePtr->call(thisValue, args, count);
+    jsi::Value result;
+    closurePtr->call(thisValue, args, count, result);
 
     // If the Swift closure stored a pending error, rethrow its JSError directly
     // to preserve all properties (message, code, stack, etc.).
@@ -141,6 +147,11 @@ inline jsi::Value evaluateJavaScript(jsi::IRuntime &runtime, const std::shared_p
   });
 }
 
+// `jsi::Instrumentation` is not imported into Swift, so reach it from here.
+inline void collectGarbage(jsi::IRuntime &runtime, const std::string &cause) {
+  runtime.instrumentation().collectGarbage(cause);
+}
+
 inline jsi::Value callFunction(jsi::IRuntime &runtime, const jsi::Function &function, const jsi::Value *_Nullable args, size_t count) {
   return expo::CppError::tryCatch(runtime, [&] {
     return function.call(runtime, args, count);