expo-modules-jsi 57.0.7 → 57.0.8

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/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 returns nothing because
+/// `_withUnsafeGuaranteedRef` needs a `Copyable` result; callbacks write their `jsi::Value`
+/// result into the slot the C++ caller provides instead.
+@inline(__always)
+internal func withGuaranteedContext<Context: HostCallbackContext>(
+  _ pointer: UnsafeMutableRawPointer,
+  _ body: (_ context: Context, _ runtime: JavaScriptRuntime) -> Void
+) {
+  Unmanaged<Context>.fromOpaque(pointer)._withUnsafeGuaranteedRef { context in
+    context.runtime._withUnsafeGuaranteedRef { runtime in
+      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)
   }

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

@@ -39,11 +39,23 @@ extension Array: JavaScriptRepresentable where Element: JavaScriptRepresentable
 
 extension Dictionary: JavaScriptRepresentable where Key == String, Value: JavaScriptRepresentable {
   public static func fromJavaScriptValue(_ value: JavaScriptValue) -> Self {
-    let object = value.getObject()
+    guard let runtime = value.runtime else {
+      FatalError.runtimeLost()
+    }
+    let jsiRuntime = runtime.pointee
+    let object = value.pointee.getObject(jsiRuntime)
+    let propertyNames = object.getPropertyNames(jsiRuntime)
+    let size = propertyNames.size(jsiRuntime)
     var result: Self = [:]
 
-    for key in object.getPropertyNames() {
-      result[key] = Value.fromJavaScriptValue(object.getProperty(key))
+    result.reserveCapacity(size)
+
+    for index in 0..<size {
+      // 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))
+      result[String(jsiString: jsiKey, in: jsiRuntime)] = Value.fromJavaScriptValue(jsiValue)
     }
     return result
   }

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

@@ -1,3 +1,4 @@
+internal import ExpoModulesJSI_Cxx
 internal import jsi
 
 /// Represents something that can be a JS property key.
@@ -14,23 +15,26 @@ public final class JavaScriptPropNameID: JavaScriptType {
   /// Creates a PropNameID from the string.
   public init(_ runtime: JavaScriptRuntime, string: String) {
     self.runtime = runtime
-    self.pointee = facebook.jsi.PropNameID.forUtf8(runtime.pointee, string, string.count)
+    self.pointee = string.toJSIPropNameID(in: runtime.pointee)
   }
 
-  /// Copies the data in a PropNameID as UTF8 into a string.
+  /// Copies the contents of the PropNameID into a string.
   public func utf8() -> String {
     guard let runtime else {
       FatalError.runtimeLost()
     }
+    // Property names are almost always short ASCII identifiers, and the engine's own `utf8()` is the
+    // fastest way to read those: the `std::string` stays inline and so does the resulting Swift
+    // string. Reading the internal representation through `getPropNameIdData`, as `String(jsiString:in:)`
+    // does for regular strings, measured about 40% slower for this case.
     return String(pointee.utf8(runtime.pointee))
   }
 
-  /// Copies the data in a PropNameID as UTF16 into a string.
+  /// Copies the contents of the PropNameID into a string. Same result as ``utf8()``.
   public func utf16() -> String {
-    guard let runtime else {
-      FatalError.runtimeLost()
-    }
-    return String(pointee.utf16(runtime.pointee))
+    // The engine's `utf16()` builds a `std::u16string` that Swift then has to transcode, which is
+    // several times slower than going through UTF-8 for the same result.
+    return utf8()
   }
 
   // MARK: - JavaScriptType