expo-modules-jsi 58.0.1 → 58.0.3

package/CHANGELOG.md

@@ -10,6 +10,18 @@
 
 ### 💡 Others
 
+## 58.0.3 — 2026-09-21
+
+### 🐛 Bug fixes
+
+- [iOS] Fix `pod install` failing when the Command Line Tools SDK is newer than the selected Xcode. ([#50316](https://github.com/expo/expo/pull/50316) by [@alanjhughes](https://github.com/alanjhughes))
+
+## 58.0.2 — 2026-09-15
+
+### 🎉 New features
+
+- [iOS] Add a `JavaScriptRuntime.collectGarbage(passes:cause:until:)` overload that collects repeatedly until the given condition holds, for tests asserting on a release that a single collection doesn't always complete. ([#50188](https://github.com/expo/expo/pull/50188) by [@tsapeta](https://github.com/tsapeta))
+
 ## 58.0.1 — 2026-09-14
 
 _This version does not introduce any user-facing changes._

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

@@ -691,10 +691,15 @@ open class JavaScriptRuntime: Equatable, Identifiable, @unchecked Sendable {
 
   // MARK: - Garbage collection
 
+  // Both `collectGarbage` overloads below are for tests and memory diagnostics only. Don't call
+  // either from production code: a forced collection stops the world for as long as the heap takes
+  // to trace, and the engine already collects on its own schedule with far better information about
+  // when that is worth paying for.
+
   /// 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.
+  /// - Important: For tests and memory diagnostics only. This blocks the JavaScript thread for the
+  ///   length of a full collection, so calling it in production code 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.
@@ -705,6 +710,49 @@ open class JavaScriptRuntime: Equatable, Identifiable, @unchecked Sendable {
     expo.collectGarbage(pointee, std.string(cause))
   }
 
+  /// Collects garbage repeatedly until `condition` holds, or until the pass budget runs out.
+  ///
+  /// - Important: For tests and memory diagnostics only, and more so than the single-pass overload:
+  ///   this runs up to `passes` full collections back to back, blocking the JavaScript thread for
+  ///   all of them. A production caller that reaches for this wants a weak reference or an explicit
+  ///   release hook, not a forced collection.
+  ///
+  /// One collection does not always finish the job. Releasing a detached native state means
+  /// finalizing the decoration that owns its `shared_ptr`, and a single pass does not always get
+  /// there: measured over 3000 attempts against a populated heap, 4.4% needed a second pass and a
+  /// handful needed a third. Asserting on a release after exactly one collection therefore tests
+  /// the engine's scheduling as much as the code under test, which is what made several suites
+  /// flaky on busy CI machines.
+  ///
+  /// Collecting again is what makes progress here; waiting does not substitute for it. The same
+  /// measurement with a microtask drain and a millisecond of sleep in place of the extra passes
+  /// left 18 times as many unreleased.
+  ///
+  /// This does not weaken the assertion that follows it: a value that is genuinely leaked never
+  /// satisfies `condition`, exhausts the budget, and still fails.
+  ///
+  /// - Note: This is a no-op on engines whose runtime doesn't implement GC instrumentation, in
+  ///   which case `condition` is evaluated once per pass and the budget is spent in full.
+  /// - Parameters:
+  ///   - passes: Maximum number of collections to run. The default sits far above what an
+  ///     unleaked value needs, so exhausting it means the value is leaked, not merely unlucky.
+  ///   - cause: Reason for the collection, as the engine should report it in its logs.
+  ///     Defaults to the calling function's name.
+  ///   - condition: Evaluated after each collection. Collecting stops as soon as it returns `true`.
+  @JavaScriptActor
+  public func collectGarbage(
+    passes: Int = 10,
+    cause: String = #function,
+    until condition: () -> Bool
+  ) {
+    for _ in 0..<passes {
+      collectGarbage(cause: cause)
+      if condition() {
+        return
+      }
+    }
+  }
+
   // MARK: - Equatable
 
   public static func == (lhs: JavaScriptRuntime, rhs: JavaScriptRuntime) -> Bool {

package/apple/Tests/JavaScriptArrayBufferTests.swift

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

package/apple/Tests/JavaScriptNativeStateTests.swift

@@ -73,12 +73,18 @@ struct JavaScriptNativeStateTests {
   func `reattaches after the previous pointee was released`() throws {
     let object1 = runtime.createObject()
     let object2 = runtime.createObject()
+    var previousPointeeReleased = false
     let nativeState = CustomNativeState()
+    nativeState.setDeallocator { _ in
+      previousPointeeReleased = true
+    }
     object1.setNativeState(nativeState)
     object1.unsetNativeState()
 
-    // Force garbage collection so the previous C++ pointee is dropped.
-    runtime.collectGarbage()
+    // Collect until the previous C++ pointee is dropped, so the reattach below exercises the
+    // expired-weak-pointer path rather than reusing a pointee that happens to still be alive.
+    runtime.collectGarbage { previousPointeeReleased }
+    #expect(previousPointeeReleased == true)
 
     // Reattaching transparently materializes a fresh pointee.
     object2.setNativeState(nativeState)
@@ -105,8 +111,7 @@ struct JavaScriptNativeStateTests {
     object.setNativeState(nativeState)
     object.unsetNativeState()
 
-    // Force garbage collection
-    runtime.collectGarbage()
+    runtime.collectGarbage { deallocatorCalled }
 
     #expect(deallocatorCalled == true)
   }
@@ -123,14 +128,17 @@ struct JavaScriptNativeStateTests {
     object1.setNativeState(nativeState)
     object2.setNativeState(nativeState)
 
-    // Unset from the first object — deallocator should not fire yet.
+    // Unset from the first object — deallocator should not fire yet. `object2` still holds a
+    // strong ref, so no number of collections may release the pointee; this assertion keeps a
+    // fixed collection rather than a retry loop, because it waits for something that must
+    // never happen.
     object1.unsetNativeState()
     runtime.collectGarbage()
     #expect(deallocatorCallCount == 0)
 
     // Unset from the second object — now the deallocator should fire exactly once.
     object2.unsetNativeState()
-    runtime.collectGarbage()
+    runtime.collectGarbage { deallocatorCallCount == 1 }
     #expect(deallocatorCallCount == 1)
   }
 
@@ -183,7 +191,7 @@ struct JavaScriptNativeStateTests {
 
     object1.setNativeState(nativeState)
     object1.unsetNativeState()
-    runtime.collectGarbage()
+    runtime.collectGarbage { deallocatorCallCount == 1 }
     #expect(deallocatorCallCount == 1)
 
     // Re-attaching builds a new C++ pointee; the wrapper-level deallocator
@@ -192,7 +200,7 @@ struct JavaScriptNativeStateTests {
     #expect(object2.getNativeState() === nativeState)
 
     object2.unsetNativeState()
-    runtime.collectGarbage()
+    runtime.collectGarbage { deallocatorCallCount == 2 }
     #expect(deallocatorCallCount == 2)
   }
 
@@ -219,7 +227,7 @@ struct JavaScriptNativeStateTests {
     // Once detached and GC'd, the C++ pointee dies, releases the Unmanaged,
     // and the Swift wrapper finally deallocates.
     object.unsetNativeState()
-    runtime.collectGarbage()
+    runtime.collectGarbage { weakWrapper == nil }
     #expect(weakWrapper == nil)
   }
 

package/apple/Tests/JavaScriptRuntimeTests.swift

@@ -1031,7 +1031,7 @@ struct JavaScriptRuntimeTests {
       #expect((weakObject?.lock() != nil) == true)
     }
 
-    runtime.collectGarbage()
+    runtime.collectGarbage { weakObject?.lock() == nil }
 
     #expect((weakObject?.lock() == nil) == true)
   }

package/apple/Tests/JavaScriptValuesBufferTests.swift

@@ -55,7 +55,7 @@ struct JavaScriptValuesBufferTests {
     _ = JavaScriptValuesBuffer.allocate(in: runtime, with: object.asValue())
     _ = consume object
 
-    runtime.collectGarbage()
+    runtime.collectGarbage { weak.lock() == nil }
 
     let stillAlive = weak.lock() != nil
     #expect(stillAlive == false)

package/apple/Tests/JavaScriptWeakObjectTests.swift

@@ -56,12 +56,8 @@ struct JavaScriptWeakObjectTests {
 
     #expect((weakObject?.lock() != nil) == true)
 
-    // Force garbage collection
-    runtime.collectGarbage()
+    runtime.collectGarbage { weakObject?.lock() == nil }
 
-    // Object should be collected now
-    // Note: This test may be flaky depending on GC behavior
-    // In practice, lock() should return nil after GC, but timing may vary
     #expect((weakObject?.lock() == nil) == true)
   }
 
@@ -78,11 +74,8 @@ struct JavaScriptWeakObjectTests {
       #expect(value?.isObject() == true)
     }
 
-    // Force garbage collection
-    runtime.collectGarbage()
+    runtime.collectGarbage { weakObject?.asValue().isUndefined() == true }
 
-    // After collection, asValue should return undefined
-    // Note: This test may be flaky depending on GC behavior
     #expect(weakObject?.asValue().isUndefined() == true)
   }
 

package/apple/scripts/create-stub-xcframework.sh

@@ -31,7 +31,7 @@ echo -e "${BLUE}[Expo]${RESET} Ensuring required slices in ${PACKAGE_NAME}.xcfra
 # reuse the same binary for every slice that needs stamping.
 mkdir -p "$XCFRAMEWORK_PATH"
 STUB_SOURCE="${XCFRAMEWORK_PATH}/.stub-binary"
-echo "" | clang -x c - -dynamiclib \
+echo "" | xcrun --sdk macosx clang -x c - -dynamiclib \
   -o "$STUB_SOURCE" \
   -install_name "@rpath/${PACKAGE_NAME}.framework/${PACKAGE_NAME}"
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "expo-modules-jsi",
-  "version": "58.0.1",
+  "version": "58.0.3",
   "description": "The JavaScript Interface for Expo Modules",
   "main": "index.js",
   "sideEffects": [],
@@ -41,7 +41,7 @@
       "./apple/scripts/test.sh"
     ]
   },
-  "gitHead": "e4b50c311af4e076b49a532ba2dca72546783e46",
+  "gitHead": "ebb1fd7569c9c9e172cb9abd73dfede027c1d674",
   "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:xcframework": "apple/scripts/build-xcframework.sh",

package/.npmignore

@@ -1,19 +0,0 @@
-# @generated by expo-module-scripts
-
-# Exclude all top-level hidden directories by convention
-/.*/
-
-# Exclude tarballs generated by `npm pack`
-/*.tgz
-
-__mocks__
-__tests__
-__rsc_tests__
-
-/e2e
-/e2e-cli
-/babel.config.js
-/oxlint.config.mjs
-/android/src/androidTest/
-/android/src/test/
-/ios/Tests

package/apple/.gitignore

@@ -1,16 +0,0 @@
-.DS_Store
-.build
-.DerivedData
-.swiftpm
-
-# Generated module map for the `jsi` Clang module (written by build-xcframework.sh)
-.generated
-
-# Staged slices for incremental xcframework builds
-.xcframework-slices
-
-# Symlinks to host-app xcframeworks used by the test target (written by scripts/test.sh)
-.test-frameworks
-
-# Built xcframework output
-Products

package/turbo.json

@@ -1,22 +0,0 @@
-{
-  "$schema": "https://turborepo.dev/schema.json",
-  "extends": ["//"],
-  "tasks": {
-    "precompile-ios": {
-      "inputs": [
-        "spm.config.json",
-        "*.podspec",
-        "apple/**",
-        "!apple/.DerivedData/**",
-        "!apple/.build/**",
-        "!apple/.swiftpm/**",
-        "!apple/.generated/**",
-        "!apple/Products/**",
-        "node_modules/react-native/package.json",
-        "node_modules/react-native/sdks/hermes-engine/version.properties",
-        "$TURBO_ROOT$/tools/src/prebuilds/**"
-      ],
-      "dependsOn": []
-    }
-  }
-}