expo-modules-jsi 57.0.7 → 57.1.0

package/apple/Benchmarks/StringConversionBenchmarks.swift

@@ -0,0 +1,245 @@
+// Copyright 2026-present 650 Industries. All rights reserved.
+
+import ExpoModulesJSI
+import Testing
+
+/// Benchmarks for the places where strings cross between the engine and Swift outside of plain
+/// `getString()`: property name enumeration, the `JavaScriptRepresentable` conformance of `String`,
+/// and `JavaScriptPropNameID`. Each one isolates a single conversion so regressions can be
+/// attributed precisely.
+extension JSIBenchmarks {
+  // MARK: - Property names
+
+  @Test
+  func `property names of an object with ASCII keys`() async throws {
+    try await benchmarkCase { runtime in
+      let object = try runtime.eval(
+        "({ alpha: 1, beta: 2, gamma: 3, delta: 4, epsilon: 5, zeta: 6, eta: 7, theta: 8, iota: 9, kappa: 10 })"
+      ).getObject()
+      try benchmark("JavaScriptObject.getPropertyNames(): 10 ASCII keys", runtime: runtime) { iterations in
+        for _ in 0..<iterations {
+          _ = object.getPropertyNames()
+        }
+      }
+    }
+  }
+
+  @Test
+  func `property names of an object with non-ASCII keys`() async throws {
+    try await benchmarkCase { runtime in
+      let object = try runtime.eval(
+        "({ 'ąlpha': 1, 'bęta': 2, 'gąmma': 3, 'dęlta': 4, 'ępsilon': 5, 'zęta': 6, 'ęta': 7, 'thęta': 8, 'iotą': 9, 'kąppa': 10 })"
+      ).getObject()
+      try benchmark("JavaScriptObject.getPropertyNames(): 10 non-ASCII keys", runtime: runtime) { iterations in
+        for _ in 0..<iterations {
+          _ = object.getPropertyNames()
+        }
+      }
+    }
+  }
+
+  // MARK: - Property access by name
+
+  @Test
+  func `object property by non-ASCII name`() async throws {
+    try await benchmarkCase { runtime in
+      let object = try runtime.eval("({ 'odpowiedź': 42 })").getObject()
+      try benchmark("JavaScriptObject.getProperty(_:): non-ASCII name", runtime: runtime) { iterations in
+        for _ in 0..<iterations {
+          _ = object.getProperty("odpowiedź")
+        }
+      }
+    }
+  }
+
+  @Test
+  func `has object property by name`() async throws {
+    try await benchmarkCase { runtime in
+      let object = try runtime.eval("({ answer: 42 })").getObject()
+      try benchmark("JavaScriptObject.hasProperty(_:)", runtime: runtime) { iterations in
+        for _ in 0..<iterations {
+          _ = object.hasProperty("answer")
+        }
+      }
+    }
+  }
+
+  @Test
+  func `set object property by name`() async throws {
+    try await benchmarkCase { runtime in
+      let object = JavaScriptObject(runtime)
+      try benchmark("JavaScriptObject.setProperty(_:value:): double", runtime: runtime) { iterations in
+        for _ in 0..<iterations {
+          object.setProperty("answer", value: 42.0)
+        }
+      }
+    }
+  }
+
+  // MARK: - String as JavaScriptRepresentable
+
+  @Test
+  func `string from JavaScriptValue via JavaScriptRepresentable`() async throws {
+    try await benchmarkCase { runtime in
+      let value = try runtime.eval("'benchmark string value'")
+      try benchmark("String.fromJavaScriptValue(): 22B ASCII", runtime: runtime) { iterations in
+        for _ in 0..<iterations {
+          _ = String.fromJavaScriptValue(value)
+        }
+      }
+    }
+  }
+
+  @Test
+  func `256B string from JavaScriptValue via JavaScriptRepresentable`() async throws {
+    try await benchmarkCase { runtime in
+      let value = try runtime.eval("'a'.repeat(256)")
+      try benchmark("String.fromJavaScriptValue(): 256B ASCII", runtime: runtime) { iterations in
+        for _ in 0..<iterations {
+          _ = String.fromJavaScriptValue(value)
+        }
+      }
+    }
+  }
+
+  @Test
+  func `non-ASCII string from JavaScriptValue via JavaScriptRepresentable`() async throws {
+    try await benchmarkCase { runtime in
+      let value = try runtime.eval("'ąęó'.repeat(4)")
+      try benchmark("String.fromJavaScriptValue(): 12 non-ASCII chars", runtime: runtime) { iterations in
+        for _ in 0..<iterations {
+          _ = String.fromJavaScriptValue(value)
+        }
+      }
+    }
+  }
+
+  /// Sizes below the 512-code-unit threshold, where UTF-16 is transcoded by hand instead of by
+  /// `String(decoding:as:)`.
+  @Test
+  func `64 non-ASCII chars from JavaScriptValue via JavaScriptRepresentable`() async throws {
+    try await benchmarkCase { runtime in
+      let value = try runtime.eval("'zażółć gęślą jaźń '.repeat(4).slice(0, 64)")
+      try benchmark("String.fromJavaScriptValue(): 64 non-ASCII chars", runtime: runtime) { iterations in
+        for _ in 0..<iterations {
+          _ = String.fromJavaScriptValue(value)
+        }
+      }
+    }
+  }
+
+  @Test
+  func `256 non-ASCII chars from JavaScriptValue via JavaScriptRepresentable`() async throws {
+    try await benchmarkCase { runtime in
+      let value = try runtime.eval("'zażółć gęślą jaźń '.repeat(16).slice(0, 256)")
+      try benchmark("String.fromJavaScriptValue(): 256 non-ASCII chars", runtime: runtime) { iterations in
+        for _ in 0..<iterations {
+          _ = String.fromJavaScriptValue(value)
+        }
+      }
+    }
+  }
+
+  @Test
+  func `128 emoji from JavaScriptValue via JavaScriptRepresentable`() async throws {
+    try await benchmarkCase { runtime in
+      let value = try runtime.eval("'🎉'.repeat(128)")
+      try benchmark("String.fromJavaScriptValue(): 128 emoji (256 code units)", runtime: runtime) { iterations in
+        for _ in 0..<iterations {
+          _ = String.fromJavaScriptValue(value)
+        }
+      }
+    }
+  }
+
+  @Test
+  func `string to JavaScriptValue via JavaScriptRepresentable`() async throws {
+    try await benchmarkCase { runtime in
+      let string = "benchmark string value"
+      try benchmark("String.toJavaScriptValue(in:): 22B ASCII", runtime: runtime) { iterations in
+        for _ in 0..<iterations {
+          _ = string.toJavaScriptValue(in: runtime)
+        }
+      }
+    }
+  }
+
+  @Test
+  func `256B string to JavaScriptValue via JavaScriptRepresentable`() async throws {
+    try await benchmarkCase { runtime in
+      let string = String(repeating: "a", count: 256)
+      try benchmark("String.toJavaScriptValue(in:): 256B ASCII", runtime: runtime) { iterations in
+        for _ in 0..<iterations {
+          _ = string.toJavaScriptValue(in: runtime)
+        }
+      }
+    }
+  }
+
+  @Test
+  func `string dictionary from JavaScriptValue`() async throws {
+    try await benchmarkCase { runtime in
+      let value = try runtime.eval(
+        """
+        ({ alpha: 'one', beta: 'two', gamma: 'three', delta: 'four', epsilon: 'five',
+           zeta: 'six', eta: 'seven', theta: 'eight', iota: 'nine', kappa: 'ten' })
+        """
+      )
+      try benchmark("[String: String].fromJavaScriptValue(): 10 entries", runtime: runtime) { iterations in
+        for _ in 0..<iterations {
+          _ = [String: String].fromJavaScriptValue(value)
+        }
+      }
+    }
+  }
+
+  // MARK: - PropNameID
+
+  @Test
+  func `PropNameID to string`() async throws {
+    try await benchmarkCase { runtime in
+      let propName = JavaScriptPropNameID(runtime, string: "propertyName")
+      try benchmark("JavaScriptPropNameID.utf8(): ASCII", runtime: runtime) { iterations in
+        for _ in 0..<iterations {
+          _ = propName.utf8()
+        }
+      }
+    }
+  }
+
+  @Test
+  func `non-ASCII PropNameID to string`() async throws {
+    try await benchmarkCase { runtime in
+      let propName = JavaScriptPropNameID(runtime, string: "właściwość")
+      try benchmark("JavaScriptPropNameID.utf8(): non-ASCII", runtime: runtime) { iterations in
+        for _ in 0..<iterations {
+          _ = propName.utf8()
+        }
+      }
+    }
+  }
+
+  @Test
+  func `PropNameID to string via utf16`() async throws {
+    try await benchmarkCase { runtime in
+      let propName = JavaScriptPropNameID(runtime, string: "propertyName")
+      try benchmark("JavaScriptPropNameID.utf16(): ASCII", runtime: runtime) { iterations in
+        for _ in 0..<iterations {
+          _ = propName.utf16()
+        }
+      }
+    }
+  }
+
+  @Test
+  func `PropNameID from string`() async throws {
+    try await benchmarkCase { runtime in
+      let string = "propertyName"
+      try benchmark("JavaScriptPropNameID(runtime, string:): ASCII", runtime: runtime) { iterations in
+        for _ in 0..<iterations {
+          _ = JavaScriptPropNameID(runtime, string: string)
+        }
+      }
+    }
+  }
+}

package/apple/Benchmarks/ValueAccessBenchmarks.swift

@@ -0,0 +1,132 @@
+// Copyright 2026-present 650 Industries. All rights reserved.
+
+import ExpoModulesJSI
+import Testing
+
+/// Micro benchmarks for converting and accessing JavaScript values from Swift.
+/// Each one isolates a single accessor so regressions can be attributed precisely.
+extension JSIBenchmarks {
+  @Test
+  func `value to object`() async throws {
+    try await benchmarkCase { runtime in
+      let value = try runtime.eval("({ answer: 42 })")
+      try benchmark("JavaScriptValue.getObject()", runtime: runtime) { iterations in
+        for _ in 0..<iterations {
+          _ = value.getObject()
+        }
+      }
+    }
+  }
+
+  @Test
+  func `value to array`() async throws {
+    try await benchmarkCase { runtime in
+      let value = try runtime.eval("[1, 2, 3, 4, 5]")
+      try benchmark("JavaScriptValue.getArray()", runtime: runtime) { iterations in
+        for _ in 0..<iterations {
+          _ = value.getArray()
+        }
+      }
+    }
+  }
+
+  @Test
+  func `value to string`() async throws {
+    try await benchmarkCase { runtime in
+      let value = try runtime.eval("'benchmark string value'")
+      try benchmark("JavaScriptValue.getString()", runtime: runtime) { iterations in
+        for _ in 0..<iterations {
+          _ = value.getString()
+        }
+      }
+    }
+  }
+
+  @Test
+  func `value to double`() async throws {
+    try await benchmarkCase { runtime in
+      let value = try runtime.eval("123.45")
+      try benchmark("JavaScriptValue.getDouble()", runtime: runtime) { iterations in
+        for _ in 0..<iterations {
+          _ = value.getDouble()
+        }
+      }
+    }
+  }
+
+  @Test
+  func `object property by name`() async throws {
+    try await benchmarkCase { runtime in
+      let object = try runtime.eval("({ answer: 42 })").getObject()
+      try benchmark("JavaScriptObject.getProperty(_:)", runtime: runtime) { iterations in
+        for _ in 0..<iterations {
+          _ = object.getProperty("answer")
+        }
+      }
+    }
+  }
+
+  /// Unlike a number, a string or object property is a pointer value: wrapping it in a
+  /// ``JavaScriptValue`` must not clone the engine handle it already owns.
+  @Test
+  func `object string property by name`() async throws {
+    try await benchmarkCase { runtime in
+      let object = try runtime.eval("({ answer: 'forty-two' })").getObject()
+      try benchmark("JavaScriptObject.getProperty(_:): string value", runtime: runtime) { iterations in
+        for _ in 0..<iterations {
+          _ = object.getProperty("answer")
+        }
+      }
+    }
+  }
+
+  @Test
+  func `object object property by name`() async throws {
+    try await benchmarkCase { runtime in
+      let object = try runtime.eval("({ answer: { value: 42 } })").getObject()
+      try benchmark("JavaScriptObject.getProperty(_:): object value", runtime: runtime) { iterations in
+        for _ in 0..<iterations {
+          _ = object.getProperty("answer")
+        }
+      }
+    }
+  }
+
+  @Test
+  func `nested property traversal`() async throws {
+    try await benchmarkCase { runtime in
+      let object = try runtime.eval("({ a: { b: { c: { d: 42 } } } })").getObject()
+      try benchmark("JavaScriptObject nested subscript (4 keys)", runtime: runtime) { iterations in
+        for _ in 0..<iterations {
+          _ = object["a", "b", "c", "d"]
+        }
+      }
+    }
+  }
+
+  @Test
+  func `property names enumeration`() async throws {
+    try await benchmarkCase { runtime in
+      let object = try runtime.eval(
+        "({ one: 1, two: 2, three: 3, four: 4, five: 5, six: 6, seven: 7, eight: 8 })"
+      ).getObject()
+      try benchmark("JavaScriptObject.getPropertyNames() (8 properties)", runtime: runtime) { iterations in
+        for _ in 0..<iterations {
+          _ = object.getPropertyNames()
+        }
+      }
+    }
+  }
+
+  @Test
+  func `array element access`() async throws {
+    try await benchmarkCase { runtime in
+      let array = try runtime.eval("[1, 2, 3, 4, 5]").getArray()
+      try benchmark("JavaScriptArray.getValue(at:)", runtime: runtime) { iterations in
+        for _ in 0..<iterations {
+          _ = try array.getValue(at: 0)
+        }
+      }
+    }
+  }
+}

package/apple/Package.swift

@@ -138,6 +138,16 @@ let package = Package(
     .testTarget(
       name: "Tests",
       dependencies: testFrameworks.dependencies,
+      path: "Tests",
+    ),
+
+    // Benchmarks are opt-in: their suites are gated on the `EXPO_BENCHMARK` environment
+    // variable, so regular test runs build them but skip every suite. Run `pnpm benchmark`
+    // to execute them in the Release configuration.
+    .testTarget(
+      name: "Benchmarks",
+      dependencies: testFrameworks.dependencies,
+      path: "Benchmarks",
     ),
   ] + testFrameworks.binaryTargets,
   swiftLanguageModes: [.v6],

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

@@ -1,15 +1,15 @@
 // Copyright 2025-present 650 Industries. All rights reserved.
 
-// `JavaScriptCodable` conformances for the standard container and wrapper types — `Array`,
-// `Optional`, and `Dictionary` — each conditional on its element/wrapped type conforming, and
-// each recursing statically into that element's conversion.
+// `JavaScriptCodable` conformances for the standard container and wrapper types (`Array`,
+// `Optional`, `Dictionary`), each recursing statically into its element/wrapped type's conversion.
 //
-// `JavaScriptCodable` is a composition type alias, so a conformance clause spells out both halves:
-// `extension Array: JavaScriptDecodable, JavaScriptEncodable where Element: JavaScriptCodable`.
+// The decodable and encodable halves are separate conditional conformances, each gated only on the
+// half it needs. A type conforming to both still gets both halves, but an encode-only element type
+// (e.g. `Task`, which has no `decode`) can still be carried through a container's encode.
 
 // MARK: - Array
 
-extension Array: JavaScriptDecodable, JavaScriptEncodable where Element: JavaScriptCodable {
+extension Array: JavaScriptDecodable where Element: JavaScriptDecodable {
   @JavaScriptActor
   @inlinable
   public static func decode(_ value: borrowing JavaScriptValue, in runtime: borrowing JavaScriptRuntime) throws
@@ -26,7 +26,9 @@ extension Array: JavaScriptDecodable, JavaScriptEncodable where Element: JavaScr
       return try Element.decode(element, in: runtime)
     }
   }
+}
 
+extension Array: JavaScriptEncodable where Element: JavaScriptEncodable {
   @JavaScriptActor
   @inlinable
   public static func encode(_ value: [Element], in runtime: borrowing JavaScriptRuntime) throws
@@ -42,7 +44,7 @@ extension Array: JavaScriptDecodable, JavaScriptEncodable where Element: JavaScr
 
 // MARK: - Optional
 
-extension Optional: JavaScriptDecodable, JavaScriptEncodable where Wrapped: JavaScriptCodable {
+extension Optional: JavaScriptDecodable where Wrapped: JavaScriptDecodable {
   // Optional copies nothing itself, so it overrides the zero-copy overload too and forwards the
   // borrowed value straight through — a wrapped primitive argument stays fully zero-copy.
   @JavaScriptActor
@@ -66,7 +68,9 @@ extension Optional: JavaScriptDecodable, JavaScriptEncodable where Wrapped: Java
     }
     return try Wrapped.decode(value, in: runtime)
   }
+}
 
+extension Optional: JavaScriptEncodable where Wrapped: JavaScriptEncodable {
   @JavaScriptActor
   @inlinable
   public static func encode(_ value: Wrapped?, in runtime: borrowing JavaScriptRuntime) throws
@@ -82,7 +86,7 @@ extension Optional: JavaScriptDecodable, JavaScriptEncodable where Wrapped: Java
 
 // MARK: - Dictionary
 
-extension Dictionary: JavaScriptDecodable, JavaScriptEncodable where Key == String, Value: JavaScriptCodable {
+extension Dictionary: JavaScriptDecodable where Key == String, Value: JavaScriptDecodable {
   @JavaScriptActor
   @inlinable
   public static func decode(_ value: borrowing JavaScriptValue, in runtime: borrowing JavaScriptRuntime) throws
@@ -102,7 +106,9 @@ extension Dictionary: JavaScriptDecodable, JavaScriptEncodable where Key == Stri
     }
     return result
   }
+}
 
+extension Dictionary: JavaScriptEncodable where Key == String, Value: JavaScriptEncodable {
   @JavaScriptActor
   @inlinable
   public static func encode(_ value: [String: Value], in runtime: borrowing JavaScriptRuntime) throws

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

@@ -0,0 +1,35 @@
+// Copyright 2025-present 650 Industries. All rights reserved.
+
+// `JavaScriptEncodable` conformance for `Task`, encoding it to a JavaScript `Promise`. This lets
+// native code hand JavaScript a promise as a value: the return of a synchronous `@JS func` whose
+// result type is `Task`, or a `Task` nested inside another encoded value. `createAsyncFunction`
+// only wraps a function's own return in a promise, so a `Task` is how to produce one anywhere else.
+//
+// Encode-only: a promise decodes by awaiting it through `JavaScriptPromise`, not by reconstructing
+// a `Task`. One conditional conformance covers throwing and non-throwing tasks (Swift forbids two
+// conformances even with disjoint bounds, and `Task.value` is `async throws` for any `Failure`).
+
+/// Encodes a `Task` to a JavaScript promise that settles with the task's result.
+extension Task: JavaScriptEncodable where Success: JavaScriptEncodable, Failure: Error {
+  /// Returns a pending promise immediately and settles it on the JavaScript thread once the task
+  /// completes: fulfilling with the encoded `Success` value, or rejecting with the thrown error.
+  @JavaScriptActor
+  public static func encode(_ value: Task<Success, Failure>, in runtime: borrowing JavaScriptRuntime) throws
+    -> JavaScriptValue
+  {
+    let promise = try JavaScriptPromise(copy runtime)
+    // A detached task awaits the result off the JavaScript thread, then settles the promise. It must
+    // not inherit `@JavaScriptActor`: that actor runs jobs synchronously on the current thread rather
+    // than hopping to the JS thread, so a resumed continuation would land on whatever thread the task
+    // finished on. `resolve`/`reject` hop to the JS thread internally (and the encodable `resolve`
+    // encodes there), so settling from here is safe regardless of this task's thread.
+    Task<Void, Never>.detached {
+      do {
+        promise.resolve(try await value.value)
+      } catch {
+        promise.reject(error)
+      }
+    }
+    return promise.asValue()
+  }
+}

package/apple/Sources/ExpoModulesJSI/Contexts/HostCallbackContext.swift

@@ -0,0 +1,28 @@
+/// A context object handed to JSI as an opaque pointer, owned by the JSI host function or host
+/// object it was created for and freed from that owner's deallocate callback.
+internal protocol HostCallbackContext: AnyObject {
+  /// The runtime the owner was installed in. Stored as `Unmanaged` rather than `weak`: the owner
+  /// lives in the runtime's heap, so a callback can only run while the runtime is alive and
+  /// executing JS, and a `weak` load plus a strong release per call was the largest single cost
+  /// of a no-op host call.
+  var runtime: Unmanaged<JavaScriptRuntime> { get }
+}
+
+/// Runs `body` with guaranteed references to the context behind `pointer` and to its runtime.
+/// `_withUnsafeGuaranteedRef` promises the compiler that both objects outlive the closure, so no
+/// retain or release is emitted for either. Both promises hold for a JSI callback: the JSI owner
+/// of the context is the caller, and a synchronous callback runs while the runtime executes JS,
+/// with the wrapper owned for the runtime's whole lifetime. The body's result must be `Copyable`
+/// because `_withUnsafeGuaranteedRef` requires it; callbacks write their `jsi::Value` result into the
+/// slot the C++ caller provides and return only whether an error was stored.
+@inline(__always)
+internal func withGuaranteedContext<Context: HostCallbackContext, Result>(
+  _ pointer: UnsafeMutableRawPointer,
+  _ body: (_ context: Context, _ runtime: JavaScriptRuntime) -> Result
+) -> Result {
+  return Unmanaged<Context>.fromOpaque(pointer)._withUnsafeGuaranteedRef { context in
+    return context.runtime._withUnsafeGuaranteedRef { runtime in
+      return body(context, runtime)
+    }
+  }
+}

package/apple/Sources/ExpoModulesJSI/Contexts/HostFunctionContext.swift

@@ -1,11 +1,15 @@
 /// Context that captures Swift values to pass them to JSI host function as an unmanaged pointer for interoperability with C++.
-internal final class HostFunctionContext: Sendable {
-  weak let runtime: JavaScriptRuntime?
+internal final class HostFunctionContext: HostCallbackContext, Sendable {
+  // Stored as `Unmanaged` rather than `weak`, for the same reason as in
+  // ``UnownedThisHostFunctionContext`` below: the JSI host function owns the context and cannot
+  // outlive its runtime, and the per-call weak load plus strong release measured at about 10 ns
+  // of a no-op call through this form.
+  let runtime: Unmanaged<JavaScriptRuntime>
   let name: String?
   let call: JavaScriptRuntime.SyncFunctionClosure
 
   init(runtime: JavaScriptRuntime, name: String? = nil, _ function: @escaping JavaScriptRuntime.SyncFunctionClosure) {
-    self.runtime = runtime
+    self.runtime = Unmanaged.passUnretained(runtime)
     self.name = name
     self.call = function
   }
@@ -13,8 +17,16 @@ internal final class HostFunctionContext: Sendable {
 
 /// Counterpart to ``HostFunctionContext`` for host functions whose closure receives `this` as a
 /// borrowed ``JavaScriptUnownedValue`` (see ``JavaScriptRuntime/UnownedThisSyncFunctionClosure``).
-internal final class UnownedThisHostFunctionContext: Sendable {
-  weak let runtime: JavaScriptRuntime?
+internal final class UnownedThisHostFunctionContext: HostCallbackContext, Sendable {
+  // Stored as `Unmanaged` rather than `weak`: the context lives exactly as long as the JSI host
+  // function that owns it (freed from the `deallocate` callback), and the host function cannot
+  // outlive the runtime it was installed in. A `weak` reference here cost a `swift_weakLoadStrong`
+  // plus a strong release on every host call, and profiling showed that pair as the largest single
+  // item on the no-op `@JS` call floor. Callers read it through `_withUnsafeGuaranteedRef`, which
+  // also skips the strong retain/release a plain `unowned(unsafe)` load would still emit. Those go
+  // through the refcount side table (other wrappers hold the runtime `weak`), so they were the next
+  // largest item once the weak load was gone.
+  let runtime: Unmanaged<JavaScriptRuntime>
   let name: String?
   let call: JavaScriptRuntime.UnownedThisSyncFunctionClosure
 
@@ -22,7 +34,7 @@ internal final class UnownedThisHostFunctionContext: Sendable {
     runtime: JavaScriptRuntime, name: String? = nil,
     _ function: @escaping JavaScriptRuntime.UnownedThisSyncFunctionClosure
   ) {
-    self.runtime = runtime
+    self.runtime = Unmanaged.passUnretained(runtime)
     self.name = name
     self.call = function
   }

package/apple/Sources/ExpoModulesJSI/Contexts/HostObjectContext.swift

@@ -1,11 +1,15 @@
 /// Context that captures Swift types to pass them to JSI host object as an unmanaged pointer for interoperability with C++.
-internal final class HostObjectContext: Sendable {
+internal final class HostObjectContext: HostCallbackContext, Sendable {
   typealias Getter = @JavaScriptActor (_ propertyName: String) throws -> JavaScriptValue
   typealias Setter = @JavaScriptActor (_ propertyName: String, _ value: JavaScriptValue) throws -> Void
   typealias PropertyNamesGetter = @JavaScriptActor () -> [String]
   typealias Deallocator = @JavaScriptActor () -> Void
 
-  weak let runtime: JavaScriptRuntime?
+  // Stored as `Unmanaged` rather than `weak`: the JSI host object owns the context (freed from the
+  // `deallocate` callback when the JS object is collected) and lives in the runtime's heap, so a
+  // getter or setter can only run while the runtime is alive and executing JS. Skips a weak load
+  // plus a strong release on every property access; see ``UnownedThisHostFunctionContext``.
+  let runtime: Unmanaged<JavaScriptRuntime>
   let get: Getter
   let set: Setter?
   let getPropertyNames: PropertyNamesGetter
@@ -18,7 +22,7 @@ internal final class HostObjectContext: Sendable {
     _ getPropertyNames: @escaping PropertyNamesGetter,
     _ dealloc: @escaping Deallocator
   ) {
-    self.runtime = runtime
+    self.runtime = Unmanaged.passUnretained(runtime)
     self.get = get
     self.set = set
     self.getPropertyNames = getPropertyNames

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

@@ -84,11 +84,25 @@ extension CGFloat: JSIRepresentableNumber {}
 
 extension String: JSIRepresentable {
   static func fromJSIValue(_ value: borrowing facebook.jsi.Value, in runtime: facebook.jsi.IRuntime) -> String {
-    return String(value.getString(runtime).utf8(runtime))
+    return String(jsiString: value.getString(runtime), in: runtime)
   }
 
   func toJSIValue(in runtime: facebook.jsi.IRuntime) -> facebook.jsi.Value {
-    return facebook.jsi.Value(runtime, facebook.jsi.String.createFromUtf8(runtime, std.string(self)))
+    // Hand JSI the Swift string's own UTF-8 storage instead of going through `std::string`: the engine
+    // copies the bytes into its heap right away, so the intermediate `std::string` was one extra
+    // allocation, copy and free per string. `withUTF8` is mutating (it makes a bridged string
+    // contiguous first), hence the local copy; native strings are already contiguous and pay nothing.
+    // The value is moved out through a local because `withUTF8` needs a `Copyable` closure result.
+    var string = self
+    var value = facebook.jsi.Value.undefined()
+    string.withUTF8 { utf8 in
+      guard let base = utf8.baseAddress else {
+        value = facebook.jsi.Value(runtime, facebook.jsi.String.createFromAscii(runtime, "", 0))
+        return
+      }
+      value = facebook.jsi.Value(runtime, facebook.jsi.String.createFromUtf8(runtime, base, utf8.count))
+    }
+    return value
   }
 }
 
@@ -137,16 +151,10 @@ extension Dictionary: JSIRepresentable where Key == String, Value: JSIRepresenta
     var result: Self = [:]
 
     for index in 0..<size {
-      let jsiKey = propertyNames.getValueAtIndex(runtime, index)
-      let key = String.fromJSIValue(jsiKey, in: runtime)
-      #if os(macOS)
-      // TODO: remove when bumping to react-native-macos 0.85
-      let jsiValue = expo.getProperty(runtime, object, key)
-      #else
+      // Look the value up by the key string the engine handed back, so any name round-trips exactly.
+      let jsiKey = propertyNames.getValueAtIndex(runtime, index).getString(runtime)
       let jsiValue = object.getProperty(runtime, jsiKey)
-      #endif
-
-      result[key] = Value.fromJSIValue(jsiValue, in: runtime)
+      result[String(jsiString: jsiKey, in: runtime)] = Value.fromJSIValue(jsiValue, in: runtime)
     }
     return result
   }
@@ -155,8 +163,7 @@ extension Dictionary: JSIRepresentable where Key == String, Value: JSIRepresenta
     let object = facebook.jsi.Object(runtime)
 
     for (key, value) in self {
-      let keyString = String(describing: key)
-      expo.setProperty(runtime, object, keyString, value.toJSIValue(in: runtime))
+      expo.setProperty(runtime, object, key.toJSIPropNameID(in: runtime), value.toJSIValue(in: runtime))
     }
     return facebook.jsi.Value(runtime, object)
   }