expo-modules-jsi 57.0.7 → 57.0.8

package/apple/Tests/JavaScriptArrayBufferTests.swift

@@ -182,8 +182,8 @@ struct JavaScriptArrayBufferTests {
       // Buffer goes out of scope here
     }
 
-    // Hermes gc() is synchronous, so the buffer should be collected immediately.
-    try runtime.eval("gc()")
+    // Hermes collects synchronously, so the buffer should be collected immediately.
+    runtime.collectGarbage()
 
     cleanupCalled = flag.pointee
     flag.deallocate()

package/apple/Tests/JavaScriptNativeStateTests.swift

@@ -78,7 +78,7 @@ struct JavaScriptNativeStateTests {
     object1.unsetNativeState()
 
     // Force garbage collection so the previous C++ pointee is dropped.
-    try runtime.eval("gc() && gc() && gc()")
+    runtime.collectGarbage()
 
     // Reattaching transparently materializes a fresh pointee.
     object2.setNativeState(nativeState)
@@ -106,7 +106,7 @@ struct JavaScriptNativeStateTests {
     object.unsetNativeState()
 
     // Force garbage collection
-    try runtime.eval("gc() && gc() && gc()")
+    runtime.collectGarbage()
 
     #expect(deallocatorCalled == true)
   }
@@ -125,12 +125,12 @@ struct JavaScriptNativeStateTests {
 
     // Unset from the first object — deallocator should not fire yet.
     object1.unsetNativeState()
-    try runtime.eval("gc() && gc() && gc()")
+    runtime.collectGarbage()
     #expect(deallocatorCallCount == 0)
 
     // Unset from the second object — now the deallocator should fire exactly once.
     object2.unsetNativeState()
-    try runtime.eval("gc() && gc() && gc()")
+    runtime.collectGarbage()
     #expect(deallocatorCallCount == 1)
   }
 
@@ -141,7 +141,7 @@ struct JavaScriptNativeStateTests {
     object.setNativeState(nativeState)
 
     // GC shouldn't release the underlying C++ pointee while the JS object is reachable.
-    try runtime.eval("gc() && gc() && gc()")
+    runtime.collectGarbage()
 
     #expect(object.getNativeState() === nativeState)
   }
@@ -183,7 +183,7 @@ struct JavaScriptNativeStateTests {
 
     object1.setNativeState(nativeState)
     object1.unsetNativeState()
-    try runtime.eval("gc() && gc() && gc()")
+    runtime.collectGarbage()
     #expect(deallocatorCallCount == 1)
 
     // Re-attaching builds a new C++ pointee; the wrapper-level deallocator
@@ -192,7 +192,7 @@ struct JavaScriptNativeStateTests {
     #expect(object2.getNativeState() === nativeState)
 
     object2.unsetNativeState()
-    try runtime.eval("gc() && gc() && gc()")
+    runtime.collectGarbage()
     #expect(deallocatorCallCount == 2)
   }
 
@@ -209,7 +209,7 @@ struct JavaScriptNativeStateTests {
       // baked into the C++ pointee is the only Swift-side strong reference.
     }
 
-    try runtime.eval("gc() && gc() && gc()")
+    runtime.collectGarbage()
 
     // The wrapper is still alive because the C++ pointee (held by JSI's slot)
     // retains it via Unmanaged. `getNativeState` recovers it.
@@ -219,7 +219,7 @@ struct JavaScriptNativeStateTests {
     // Once detached and GC'd, the C++ pointee dies, releases the Unmanaged,
     // and the Swift wrapper finally deallocates.
     object.unsetNativeState()
-    try runtime.eval("gc() && gc() && gc()")
+    runtime.collectGarbage()
     #expect(weakWrapper == nil)
   }
 
@@ -232,7 +232,7 @@ struct JavaScriptNativeStateTests {
     object2.setNativeState(nativeState)
 
     object1.unsetNativeState()
-    try runtime.eval("gc() && gc() && gc()")
+    runtime.collectGarbage()
 
     #expect(object1.hasNativeState() == false)
     #expect(object2.hasNativeState() == true)

package/apple/Tests/JavaScriptObjectTests.swift

@@ -32,6 +32,71 @@ struct JavaScriptObjectTests {
     #expect(object.getProperty("score").getInt() == 100)
   }
 
+  @Test
+  func `get property names preserves non-ASCII and empty keys`() throws {
+    let object = try runtime.eval("({ 'café': 1, '日本語': 2, '🎉': 3, '': 4 })").getObject()
+    #expect(object.getPropertyNames() == ["café", "日本語", "🎉", ""])
+  }
+
+  // MARK: - Non-ASCII property names
+
+  @Test
+  func `getProperty finds non-ASCII and empty names`() throws {
+    let object = try runtime.eval("({ 'café': 42, '日本語': 'ok', '🎉': true, '': 'empty' })").getObject()
+    #expect(object.getProperty("café").isNumber() == true)
+    #expect(object.getProperty("日本語").isString() == true)
+    #expect(object.getProperty("🎉").isBool() == true)
+    #expect(object.getProperty("").isString() == true)
+    #expect(object.getProperty("cafe").isUndefined() == true)
+  }
+
+  @Test
+  func `hasProperty finds non-ASCII and empty names`() throws {
+    let object = try runtime.eval("({ 'café': 42, '': 'empty' })").getObject()
+    #expect(object.hasProperty("café") == true)
+    #expect(object.hasProperty("") == true)
+    #expect(object.hasProperty("cafe") == false)
+    #expect(object.hasProperty("naïve") == false)
+  }
+
+  @Test
+  func `setProperty with a non-ASCII name is visible to JavaScript`() throws {
+    let object = JavaScriptObject(runtime)
+    object.setProperty("café", value: 42.0)
+    object.setProperty("日本語", value: JavaScriptValue(runtime, "ok"))
+    object.setProperty("🎉", JavaScriptObject(runtime))
+    object.setProperty("", value: true)
+    runtime.global().setProperty("obj", object)
+    #expect(try runtime.eval("obj['café'] === 42 && obj['日本語'] === 'ok' && obj[''] === true").getBool() == true)
+    #expect(try runtime.eval("typeof obj['🎉']").getString() == "object")
+    #expect(try runtime.eval("Object.keys(obj).join(',')").getString() == "café,日本語,🎉,")
+  }
+
+  @Test
+  func `deleteProperty removes a non-ASCII name`() throws {
+    let object = try runtime.eval("({ 'café': 42, 'cafe': 1 })").getObject()
+    object.deleteProperty("café")
+    #expect(object.hasProperty("café") == false)
+    #expect(object.hasProperty("cafe") == true)
+    runtime.global().setProperty("obj", object)
+    #expect(try runtime.eval("'café' in obj").getBool() == false)
+  }
+
+  @Test
+  func `defineProperty with a non-ASCII name is visible to JavaScript`() throws {
+    let object = JavaScriptObject(runtime)
+    object.defineProperty("café", value: 42.0, options: [.enumerable])
+    runtime.global().setProperty("obj", object)
+    #expect(try runtime.eval("obj['café']").getInt() == 42)
+  }
+
+  @Test
+  func `getPropertyAsFunction finds a non-ASCII name`() throws {
+    let object = try runtime.eval("({ 'zażółć': () => 'gęślą jaźń' })").getObject()
+    let function = try object.getPropertyAsFunction("zażółć")
+    #expect(try function.call().getString() == "gęślą jaźń")
+  }
+
   // MARK: - Property Access Tests
 
   @Suite("Property Access")
@@ -199,6 +264,20 @@ struct JavaScriptObjectTests {
       #expect(object.getProperty("pi").getDouble() == 3.14159)
     }
 
+    @Test
+    func `set property with non-ASCII string`() {
+      let object = JavaScriptObject(runtime)
+      object.setProperty("greeting", value: "żółć 世界 🎉")
+      #expect(object.getProperty("greeting").getString() == "żółć 世界 🎉")
+    }
+
+    @Test
+    func `set property with empty string`() {
+      let object = JavaScriptObject(runtime)
+      object.setProperty("empty", value: "")
+      #expect(object.getProperty("empty").getString() == "")
+    }
+
     @Test
     func `set property with JavaScriptValue`() {
       let object = JavaScriptObject(runtime)

package/apple/Tests/JavaScriptPropNameIDTests.swift

@@ -0,0 +1,123 @@
+import ExpoModulesJSI
+import Testing
+
+@Suite
+@JavaScriptActor
+struct JavaScriptPropNameIDTests {
+  let runtime = JavaScriptRuntime()
+
+  // MARK: - UTF-8 round-trip
+
+  @Test
+  func `round-trips an ASCII string`() {
+    let propName = JavaScriptPropNameID(runtime, string: "length")
+    #expect(propName.utf8() == "length")
+  }
+
+  // Regression test for the `forUtf8(pointer, length)` byte-count bug: `String.count` is the
+  // grapheme-cluster count, not the UTF-8 byte count, so non-ASCII keys used to be truncated
+  // (e.g. `"café"` reported 4 for its 5 UTF-8 bytes) and the PropNameID held mangled bytes.
+  @Test(arguments: ["café", "naïve", "Ωμέγα", "日本語", "Grüße", "emoji 🎉", "over\u{2028}line"])
+  func `round-trips a non-ASCII string via utf8`(key: String) {
+    let propName = JavaScriptPropNameID(runtime, string: key)
+    #expect(propName.utf8() == key)
+  }
+
+  // Multi-scalar grapheme clusters (ZWJ sequences, combining marks) have a `count` of 1 but many
+  // UTF-8 bytes — the worst case for the old truncation.
+  @Test(arguments: ["👨‍👩‍👧", "e\u{0301}", "🇵🇱"])
+  func `round-trips a multi-scalar grapheme via utf8`(key: String) {
+    let propName = JavaScriptPropNameID(runtime, string: key)
+    #expect(propName.utf8() == key)
+  }
+
+  @Test(arguments: ["café", "日本語", "🎉"])
+  func `round-trips a non-ASCII string via utf16`(key: String) {
+    let propName = JavaScriptPropNameID(runtime, string: key)
+    #expect(propName.utf16() == key)
+  }
+
+  @Test
+  func `round-trips an empty string`() {
+    let propName = JavaScriptPropNameID(runtime, string: "")
+    #expect(propName.utf8() == "")
+    #expect(propName.utf16() == "")
+  }
+
+  @Test
+  func `round-trips a long non-ASCII string`() {
+    let key = String(repeating: "ą", count: 2000)
+    let propName = JavaScriptPropNameID(runtime, string: key)
+    #expect(propName.utf8() == key)
+    #expect(propName.utf16() == key)
+  }
+
+  // MARK: - Caching
+
+  @Test
+  func `cached returns the same instance for the same string`() {
+    let first = JavaScriptPropNameID.cached(runtime, "café")
+    let second = JavaScriptPropNameID.cached(runtime, "café")
+    #expect(first === second)
+  }
+
+  @Test
+  func `cached round-trips a non-ASCII string`() {
+    let propName = JavaScriptPropNameID.cached(runtime, "café")
+    #expect(propName.utf8() == "café")
+  }
+
+  // MARK: - Property resolution
+
+  // End-to-end: a PropNameID built from a non-ASCII key must resolve the matching JS property.
+  // With the truncation bug the mangled key missed the real property and returned `undefined`.
+  @Test
+  func `resolves a non-ASCII property by PropNameID`() throws {
+    let object = try runtime.eval("({ 'café': 42, '日本語': 'ok', '🎉': true })").getObject()
+
+    #expect(object.getProperty(JavaScriptPropNameID(runtime, string: "café")).getInt() == 42)
+    #expect(object.getProperty(JavaScriptPropNameID(runtime, string: "日本語")).getString() == "ok")
+    #expect(object.getProperty(JavaScriptPropNameID(runtime, string: "🎉")).getBool() == true)
+  }
+
+  @Test
+  func `resolves a non-ASCII property that does not exist as undefined`() throws {
+    let object = try runtime.eval("({ 'café': 42 })").getObject()
+
+    // A different non-ASCII key must not collide with `café` via truncated bytes.
+    #expect(object.getProperty(JavaScriptPropNameID(runtime, string: "caff")).isUndefined() == true)
+    #expect(object.getProperty(JavaScriptPropNameID(runtime, string: "naïve")).isUndefined() == true)
+  }
+
+  @Test
+  func `property type errors report the non-ASCII property name`() throws {
+    let object = try runtime.eval("({ 'café': 42 })").getObject()
+    let propName = JavaScriptPropNameID(runtime, string: "café")
+    let notObject = #expect(throws: JavaScriptObject.PropertyNotObjectError.self) {
+      try object.getPropertyAsObject(propName)
+    }
+    #expect(notObject?.description == "Property 'café' is not an object")
+    let notFunction = #expect(throws: JavaScriptObject.PropertyNotFunctionError.self) {
+      try object.getPropertyAsFunction(propName)
+    }
+    #expect(notFunction?.description == "Property 'café' is not a function")
+  }
+
+  // Second `forUtf8(pointer, length)` call site: the array's string-keyed subscript getter.
+  @Test
+  func `array string subscript reads a non-ASCII custom property`() throws {
+    let array = try runtime.eval("(() => { const a = [10, 20]; a['café'] = 42; a['🎉'] = 'party'; return a; })()")
+      .getArray()
+
+    #expect(array["café"].getInt() == 42)
+    #expect(array["🎉"].getString() == "party")
+  }
+
+  @Test
+  func `array string subscript writes a non-ASCII custom property`() throws {
+    let array = try runtime.eval("[1, 2]").getArray()
+    array["café"] = JavaScriptValue(runtime, "party")
+    runtime.global().setProperty("arr", value: array.asValue())
+    #expect(try runtime.eval("arr['café'] === 'party'").getBool() == true)
+  }
+}

package/apple/Tests/JavaScriptRuntimeTests.swift

@@ -857,6 +857,35 @@ struct JavaScriptRuntimeTests {
     #expect(tracked.released == false)
     #expect(runtime.longLivedObjects.count == 1)
   }
+
+  // MARK: - Garbage collection
+
+  @Test
+  func `collecting garbage releases an unreachable object`() {
+    var weakObject: JavaScriptWeakObject? = nil
+
+    do {
+      let object = runtime.createObject()
+      weakObject = JavaScriptWeakObject(runtime, object)
+      #expect((weakObject?.lock() != nil) == true)
+    }
+
+    runtime.collectGarbage()
+
+    #expect((weakObject?.lock() == nil) == true)
+  }
+
+  @Test
+  func `collecting garbage keeps a reachable object alive`() {
+    let object = runtime.createObject()
+    object.setProperty("survives", value: true)
+    let weakObject = JavaScriptWeakObject(runtime, object)
+
+    runtime.collectGarbage(cause: "test")
+
+    let survives = weakObject.lock()?.getProperty("survives").getBool()
+    #expect(survives == true)
+  }
 }
 
 /// Runs `body` on a freshly spawned synchronous thread and bridges the result back into the

package/apple/Tests/JavaScriptTypedArrayTests.swift

@@ -172,7 +172,7 @@ struct JavaScriptTypedArrayTests {
     let typedArray = try runtime.eval("(() => new Uint8Array([1, 2, 3, 4]))()").getTypedArray()
 
     // The backing ArrayBuffer should remain alive because `JavaScriptTypedArray` holds it.
-    try runtime.eval("gc() && gc() && gc()")
+    runtime.collectGarbage()
 
     typedArray.withUnsafeBytes { bytes in
       #expect(bytes[0] == 1)

package/apple/Tests/JavaScriptUnownedValueTests.swift

@@ -26,6 +26,15 @@ struct JavaScriptUnownedValueTests {
     #expect(bool.getBool() == true)
   }
 
+  @Test
+  func `getString preserves non-ASCII, empty and long strings`() {
+    let long = String(repeating: "ą", count: 2000)
+    let buffer = JavaScriptValuesBuffer.allocate(in: runtime, with: "żółć 世界 🎉", "", long)
+    #expect(buffer.unownedValue(at: 0).getString() == "żółć 世界 🎉")
+    #expect(buffer.unownedValue(at: 1).getString() == "")
+    #expect(buffer.unownedValue(at: 2).getString() == long)
+  }
+
   @Test
   func `recognizes null and undefined`() {
     let buffer = JavaScriptValuesBuffer.allocate(in: runtime, with: JavaScriptValue.null, JavaScriptValue.undefined)

package/apple/Tests/JavaScriptValueTests.swift

@@ -1,4 +1,5 @@
 import ExpoModulesJSI
+import Foundation
 import Testing
 
 @Suite
@@ -156,6 +157,107 @@ struct JavaScriptValueTests {
     #expect(result == "\u{FFFD}")
   }
 
+  @Test
+  func `getString repairs lone surrogates the same way as the standard library`() throws {
+    // High surrogate followed by a non-surrogate, a stray low surrogate, and a high surrogate at the
+    // very end each become one U+FFFD, exactly like `String(decoding:as: UTF16.self)`.
+    let value = try runtime.eval("'a\\uD800b\\uDC00c\\uD83C\\uDF89\\uD800'")
+    let units: [UInt16] = [0x61, 0xD800, 0x62, 0xDC00, 0x63, 0xD83C, 0xDF89, 0xD800]
+    #expect(value.getString() == String(decoding: units, as: UTF16.self))
+    #expect(value.getString() == "a\u{FFFD}b\u{FFFD}c🎉\u{FFFD}")
+  }
+
+  @Test
+  func `getString covers every UTF-8 width below the bulk threshold`() throws {
+    let value = try runtime.eval("'a\\u00E9\\u4E2D\\uD83C\\uDF89'.repeat(100)")
+    #expect(value.getString() == String(repeating: "aé中🎉", count: 100))
+    #expect(value.getString().utf8.count == 1000)
+  }
+
+  @Test
+  func `getString handles long non-ASCII string`() throws {
+    let value = try runtime.eval("'ą'.repeat(2000)")
+    #expect(value.getString() == String(repeating: "ą", count: 2000))
+  }
+
+  @Test
+  func `getString handles string built by concatenation`() throws {
+    let value = try runtime.eval(
+      "(() => { let s = ''; for (let i = 0; i < 300; i++) s += i % 2 ? 'abc' : 'żółć🎉'; return s; })()"
+    )
+    let expected = (0..<300).map { $0 % 2 == 1 ? "abc" : "żółć🎉" }.joined()
+    #expect(value.getString() == expected)
+  }
+
+  @Test
+  func `String(runtime, ...) round-trips an empty string`() {
+    let value = JavaScriptValue(runtime, "")
+    #expect(value.isString() == true)
+    #expect(value.getString() == "")
+  }
+
+  @Test
+  func `String(runtime, ...) round-trips a bridged string`() {
+    let bridged = NSString(string: "café 世界 🎉") as String
+    let value = JavaScriptValue(runtime, bridged)
+    #expect(value.getString() == "café 世界 🎉")
+  }
+
+  @Test
+  func `String(runtime, ...) round-trips a long non-ASCII string`() {
+    let long = String(repeating: "ż", count: 5_000)
+    let value = JavaScriptValue(runtime, long)
+    #expect(value.getString() == long)
+  }
+
+  // MARK: - String as JavaScriptRepresentable
+
+  @Test
+  func `String.fromJavaScriptValue preserves non-ASCII`() throws {
+    let value = try runtime.eval("'żółć 世界 🎉'")
+    #expect(String.fromJavaScriptValue(value) == "żółć 世界 🎉")
+  }
+
+  @Test
+  func `String.toJavaScriptValue preserves non-ASCII`() {
+    let value = "żółć 世界 🎉".toJavaScriptValue(in: runtime)
+    #expect(value.getString() == "żółć 世界 🎉")
+  }
+
+  @Test
+  func `dictionary with ASCII keys and non-ASCII values round-trips through JavaScriptRepresentable`() throws {
+    let value = try runtime.eval("({ a: 'żółć', b: '🎉' })")
+    let dictionary = [String: String].fromJavaScriptValue(value)
+    #expect(dictionary == ["a": "żółć", "b": "🎉"])
+  }
+
+  @Test
+  func `dictionary with non-ASCII keys round-trips through JavaScriptRepresentable`() throws {
+    let value = try runtime.eval("({ 'café': 'one', '日本語': 'two' })")
+    let dictionary = [String: String].fromJavaScriptValue(value)
+    #expect(dictionary == ["café": "one", "日本語": "two"])
+  }
+
+  @Test
+  func `dictionary with non-ASCII keys encodes to JavaScript`() throws {
+    let value = ["café": "one", "": "empty"].toJavaScriptValue(in: runtime)
+    runtime.global().setProperty("dict", value: value)
+    #expect(try runtime.eval("dict['café'] === 'one' && dict[''] === 'empty'").getBool() == true)
+  }
+
+  @Test
+  func `array of non-ASCII strings round-trips through JavaScriptRepresentable`() throws {
+    let value = try runtime.eval("['café', '日本語', '']")
+    #expect([String].fromJavaScriptValue(value) == ["café", "日本語", ""])
+  }
+
+  @Test
+  func `dictionary with an empty key round-trips through JavaScriptRepresentable`() throws {
+    let value = try runtime.eval("({ '': 'empty' })")
+    let dictionary = [String: String].fromJavaScriptValue(value)
+    #expect(dictionary == ["": "empty"])
+  }
+
   // MARK: - Type Checking Tests
 
   @Test

package/apple/Tests/JavaScriptValuesBufferTests.swift

@@ -51,11 +51,11 @@ struct JavaScriptValuesBufferTests {
     // Allocate a buffer that captures the JS object as an argument; the result is
     // discarded and `deinit` runs at the end of this statement. If `deinit` skipped
     // `deinitialize`, the contained `jsi::Value` would still hold a strong ref and
-    // the weak handle would survive `gc()`.
+    // the weak handle would survive the collection below.
     _ = JavaScriptValuesBuffer.allocate(in: runtime, with: object.asValue())
     _ = consume object
 
-    try runtime.eval("gc() && gc() && gc()")
+    runtime.collectGarbage()
 
     let stillAlive = weak.lock() != nil
     #expect(stillAlive == false)

package/apple/Tests/JavaScriptWeakObjectTests.swift

@@ -57,7 +57,7 @@ struct JavaScriptWeakObjectTests {
     #expect((weakObject?.lock() != nil) == true)
 
     // Force garbage collection
-    _ = try! runtime.eval("gc() && gc() && gc()")
+    runtime.collectGarbage()
 
     // Object should be collected now
     // Note: This test may be flaky depending on GC behavior
@@ -79,7 +79,7 @@ struct JavaScriptWeakObjectTests {
     }
 
     // Force garbage collection
-    _ = try! runtime.eval("gc() && gc() && gc()")
+    runtime.collectGarbage()
 
     // After collection, asValue should return undefined
     // Note: This test may be flaky depending on GC behavior

package/apple/scripts/build-xcframework.sh

@@ -204,6 +204,14 @@ build_slice() {
   # SYMROOT/OBJROOT to the paths this script reads from forces products and the
   # generated module maps back into DERIVED_DATA_PATH. On Xcode versions that
   # honor -derivedDataPath these point at the same locations, so it's a no-op.
+  #
+  # Xcode turns coverage mapping on for auto-generated SwiftPM schemes, and that leaks into a
+  # plain `build` of a Release configuration: swiftc gets `-profile-generate
+  # -profile-coverage-mapping` and clang gets `-fprofile-instr-generate`. The result is a counter
+  # increment in every function and branch region of the shipped framework (visible as
+  # `___profc_*` symbols and `__llvm_prf_*` sections) plus ~40% extra binary size. Setting
+  # CLANG_COVERAGE_MAPPING=NO is what removes the flags; CLANG_ENABLE_CODE_COVERAGE=NO alone
+  # does not, and `-enableCodeCoverage NO` is rejected outside of `test`.
   local env_args=(PATH="$PATH" HOME="$HOME" PODS_ROOT="$PODS_ROOT" RN_ROOT="$RN_ROOT")
   if [[ -n "${DEVELOPER_DIR:-}" ]]; then
     env_args+=(DEVELOPER_DIR="$DEVELOPER_DIR")
@@ -229,6 +237,8 @@ build_slice() {
     DEBUG_INFORMATION_FORMAT=dwarf-with-dsym \
     COMPILER_INDEX_STORE_ENABLE=NO \
     SWIFT_COMPILATION_MODE=wholemodule \
+    CLANG_ENABLE_CODE_COVERAGE=NO \
+    CLANG_COVERAGE_MAPPING=NO \
   )
 
   local product_path="${BUILD_PRODUCTS_PATH}/${build_dir_name}"

package/apple/scripts/generate-modulemap.sh

@@ -46,10 +46,19 @@ if [[ ! -f "$JSI_UMBRELLA" ]]; then
 fi
 [[ -f "$JSI_UMBRELLA" ]] || { echo "error: cannot locate jsi.h" >&2; exit 1; }
 
+# The umbrella header doesn't include `instrumentation.h`, so declare it explicitly.
+# Otherwise including it warns about a missing `jsi.instrumentation` submodule.
+JSI_INSTRUMENTATION="$(dirname "$JSI_UMBRELLA")/instrumentation.h"
+JSI_EXTRA_HEADERS=""
+if [[ -f "$JSI_INSTRUMENTATION" ]]; then
+  JSI_EXTRA_HEADERS="
+  header \"${JSI_INSTRUMENTATION}\""
+fi
+
 # Avoid touching the file when contents would be identical, so the xcframework
 # hash cache and Xcode don't see a spurious change when inputs are unchanged.
 NEW_CONTENT="module jsi {
-  umbrella header \"${JSI_UMBRELLA}\"
+  umbrella header \"${JSI_UMBRELLA}\"${JSI_EXTRA_HEADERS}
 
   export *
   module * { export * }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "expo-modules-jsi",
-  "version": "57.0.7",
+  "version": "57.0.8",
   "description": "The JavaScript Interface for Expo Modules",
   "main": "index.js",
   "sideEffects": [],
@@ -41,8 +41,9 @@
       "./apple/scripts/test.sh"
     ]
   },
-  "gitHead": "b76ecf192c5325793bcea31dd9bb8efd91f9ad7f",
+  "gitHead": "d36f125067e9c6e67689f2b75cf4fb19254c3c59",
   "scripts": {
+    "benchmark": "TEST_RUNNER_EXPO_BENCHMARK=1 DESTINATION=\"${DESTINATION:-platform=macOS,variant=Mac Catalyst}\" apple/scripts/test.sh -configuration Release -only-testing Benchmarks -enableCodeCoverage NO",
     "build": "apple/scripts/build-xcframework.sh",
     "clean": "apple/scripts/clear-caches.sh",
     "swift:format": "../../scripts/swift-format.sh",