expo-modules-core 57.0.19 → 57.0.20

package/CHANGELOG.md

@@ -10,6 +10,13 @@
 
 ### 💡 Others
 
+## 57.0.20 — 2026-09-29
+
+### 🐛 Bug fixes
+
+- [iOS] Fixed `Exception` reporting `undefined reason` to JavaScript instead of the description it was created with, which also affected every `promise.reject(code, description)` call. ([#50215](https://github.com/expo/expo/pull/50215) by [@Maher-Reven](https://github.com/Maher-Reven))
+- [Android] Fixed async functions rejecting with `Cannot use shared object that was already released`, and `sharedObjectDidRelease` being called in the middle of a pending call, when the garbage collector took the JS object of a shared object receiver or argument before the call finished. ([#50513](https://github.com/expo/expo/pull/50513) by [@lukmccall](https://github.com/lukmccall))
+
 ## 57.0.19 — 2026-09-24
 
 ### 🐛 Bug fixes

package/android/build.gradle

@@ -27,7 +27,7 @@ if (shouldIncludeCompose) {
 }
 
 group = 'host.exp.exponent'
-version = '57.0.19'
+version = '57.0.20'
 
 def isExpoModulesCoreTests = {
   Gradle gradle = getGradle()
@@ -94,7 +94,7 @@ android {
   defaultConfig {
     consumerProguardFiles 'proguard-rules.pro'
     versionCode 1
-    versionName "57.0.19"
+    versionName "57.0.20"
     buildConfigField "String", "EXPO_MODULES_CORE_VERSION", "\"${versionName}\""
     buildConfigField "boolean", "IS_NEW_ARCHITECTURE_ENABLED", "true"
 

package/android/src/main/cpp/JavaCallback.cpp

@@ -12,16 +12,19 @@ JavaCallback::CallbackContext::CallbackContext(
   jsi::Runtime &rt,
   std::weak_ptr<react::CallInvoker> jsCallInvokerHolder,
   std::optional<jsi::Function> resolveHolder,
-  std::optional<jsi::Function> rejectHolder
+  std::optional<jsi::Function> rejectHolder,
+  std::vector<jsi::Value> retainedValues
 ) : react::LongLivedObject(rt),
     rt(rt),
     jsCallInvokerHolder(std::move(jsCallInvokerHolder)),
     resolveHolder(std::move(resolveHolder)),
-    rejectHolder(std::move(rejectHolder)) {}
+    rejectHolder(std::move(rejectHolder)),
+    retainedValues(std::move(retainedValues)) {}
 
 void JavaCallback::CallbackContext::invalidate() {
   resolveHolder.reset();
   rejectHolder.reset();
+  retainedValues.clear();
   allowRelease();
 }
 

package/android/src/main/cpp/JavaCallback.h

@@ -32,13 +32,18 @@ public:
       jsi::Runtime &rt,
       std::weak_ptr<react::CallInvoker> jsCallInvokerHolder,
       std::optional<jsi::Function> resolveHolder,
-      std::optional<jsi::Function> rejectHolder
+      std::optional<jsi::Function> rejectHolder,
+      std::vector<jsi::Value> retainedValues = {}
     );
 
     jsi::Runtime &rt;
     std::weak_ptr<react::CallInvoker> jsCallInvokerHolder;
     std::optional<jsi::Function> resolveHolder;
     std::optional<jsi::Function> rejectHolder;
+    /**
+     * JS values that have to stay alive until the promise is settled.
+     */
+    std::vector<jsi::Value> retainedValues;
 
     void invalidate();
   };

package/android/src/main/cpp/MethodMetadata.cpp

@@ -20,7 +20,8 @@ namespace expo {
 jni::local_ref<JavaCallback::JavaPart> createJavaCallback(
   jsi::Function &&resolveFunction,
   jsi::Function &&rejectFunction,
-  jsi::Runtime &rt
+  jsi::Runtime &rt,
+  std::vector<jsi::Value> &&retainedValues
 ) {
   JSIContext *jsiContext = getJSIContext(rt);
   std::shared_ptr<react::CallInvoker> jsInvoker = jsiContext->runtimeHolder->jsInvoker;
@@ -29,7 +30,8 @@ jni::local_ref<JavaCallback::JavaPart> createJavaCallback(
     rt,
     std::move(jsInvoker),
     std::move(resolveFunction),
-    std::move(rejectFunction)
+    std::move(rejectFunction),
+    std::move(retainedValues)
   );
 
   facebook::react::LongLivedObjectCollection::get(rt).add(callbackContext);
@@ -105,6 +107,11 @@ MethodMetadata::MethodMetadata(
   jni::global_ref<jobject> &&jBodyReference
 ) : info(std::move(info)),
     jBodyReference(std::move(jBodyReference)) {
+  for (size_t index = 0; index < this->info.argTypes.size(); index++) {
+    if (this->info.argTypes[index]->converter->retainsJSValue()) {
+      retainedArgIndices.push_back(index);
+    }
+  }
 }
 
 std::shared_ptr<jsi::Function> MethodMetadata::toJSFunction(
@@ -230,12 +237,18 @@ jsi::Function MethodMetadata::toAsyncFunction(
         auto globalConvertedArgs = (jobjectArray) env->NewGlobalRef(convertedArgs);
         env->DeleteLocalRef(convertedArgs);
 
+        std::shared_ptr<std::vector<jsi::Value>> retainedValues = nullptr;
+        if (!thisPtr->retainedArgIndices.empty()) {
+          retainedValues = std::make_shared<std::vector<jsi::Value>>(
+            thisPtr->retainArguments(rt, thisValue, args, count)
+          );
+        }
+
         // Creates a JSI promise
-        jsi::Value promise = Promise.callAsConstructor(
+        return Promise.callAsConstructor(
           rt,
-          thisPtr->createPromiseBody(rt, globalConvertedArgs)
+          thisPtr->createPromiseBody(rt, globalConvertedArgs, std::move(retainedValues))
         );
-        return promise;
       } catch (jni::JniException &jniException) {
         jni::local_ref<jni::JThrowable> unboxedThrowable = jniException.getThrowable();
         if (!unboxedThrowable->isInstanceOf(CodedException::javaClassLocal())) {
@@ -246,7 +259,7 @@ jsi::Function MethodMetadata::toAsyncFunction(
         auto code = codedException->getCode();
         auto message = codedException->getLocalizedMessage().value_or("");
 
-        jsi::Value promise = Promise.callAsConstructor(
+        return Promise.callAsConstructor(
           rt,
           jsi::Function::createFromHostFunction(
             rt,
@@ -275,22 +288,49 @@ jsi::Function MethodMetadata::toAsyncFunction(
             }
           )
         );
-
-        return promise;
       }
     }
   );
 }
 
+std::vector<jsi::Value> MethodMetadata::retainArguments(
+  jsi::Runtime &rt,
+  const jsi::Value &thisValue,
+  const jsi::Value *args,
+  size_t count
+) const {
+  std::vector<jsi::Value> retained;
+  retained.reserve(retainedArgIndices.size());
+
+  // With an owner, `info.argTypes[0]` describes the receiver and the JS arguments start at index 1.
+  const size_t argsOffset = info.takesOwner ? 1 : 0;
+  for (size_t index : retainedArgIndices) {
+    if (info.takesOwner && index == 0) {
+      if (thisValue.isObject()) {
+        retained.emplace_back(rt, thisValue);
+      }
+      continue;
+    }
+
+    const size_t argIndex = index - argsOffset;
+    if (argIndex < count && args[argIndex].isObject()) {
+      retained.emplace_back(rt, args[argIndex]);
+    }
+  }
+
+  return retained;
+}
+
 jsi::Function MethodMetadata::createPromiseBody(
   jsi::Runtime &runtime,
-  jobjectArray globalArgs
+  jobjectArray globalArgs,
+  std::shared_ptr<std::vector<jsi::Value>> retainedValues
 ) {
   return jsi::Function::createFromHostFunction(
     runtime,
     getJSIContext(runtime)->jsRegistry->getPropNameID(runtime, "promiseFn"),
     2,
-    [this, globalArgs](
+    [this, globalArgs, retainedValues = std::move(retainedValues)](
       jsi::Runtime &rt,
       const jsi::Value &thisVal,
       const jsi::Value *promiseConstructorArgs,
@@ -303,10 +343,12 @@ jsi::Function MethodMetadata::createPromiseBody(
       jsi::Function resolveJSIFn = promiseConstructorArgs[0].getObject(rt).getFunction(rt);
       jsi::Function rejectJSIFn = promiseConstructorArgs[1].getObject(rt).getFunction(rt);
 
+      // The promise constructor calls this body synchronously, so the retained values are moved out once.
       jobject javaCallback = createJavaCallback(
         std::move(resolveJSIFn),
         std::move(rejectJSIFn),
-        rt
+        rt,
+        retainedValues != nullptr ? std::move(*retainedValues) : std::vector<jsi::Value>()
       ).release();
 
       JNIEnv *env = jni::Environment::current();

package/android/src/main/cpp/MethodMetadata.h

@@ -107,9 +107,27 @@ private:
 
   jsi::Function createPromiseBody(
     jsi::Runtime &runtime,
-    jobjectArray globalArgs
+    jobjectArray globalArgs,
+    std::shared_ptr<std::vector<jsi::Value>> retainedValues
   );
 
+  /**
+   * Indexes into `info.argTypes` of the arguments whose JS values have to stay alive until an async call
+   * is settled, computed once from the converters. When the receiver is taken, index 0 is the receiver.
+   */
+  std::vector<size_t> retainedArgIndices;
+
+  /**
+   * Copies the JS values of the arguments listed in `retainedArgIndices`.
+   * They are kept alive until the returned promise is settled.
+   */
+  std::vector<jsi::Value> retainArguments(
+    jsi::Runtime &rt,
+    const jsi::Value &thisValue,
+    const jsi::Value *args,
+    size_t count
+  ) const;
+
   jobjectArray convertJSIArgsToJNI(
     JNIEnv *env,
     jsi::Runtime &rt,

package/android/src/main/cpp/RuntimeHolder.cpp

@@ -9,6 +9,7 @@
 #if USE_HERMES
 
 #include <hermes/hermes.h>
+#include <jsi/instrumentation.h>
 
 #include <utility>
 
@@ -69,6 +70,25 @@ jlong RuntimeHolder::createRuntime() {
   runtime = facebook::jsc::makeJSCRuntime();
 #endif
 
+  // Exposes a `gc()` function, so tests can force a full garbage collection.
+  auto gcPropName = jsi::PropNameID::forUtf8(*runtime, "gc");
+  runtime->global().setProperty(
+    *runtime,
+    gcPropName,
+    jsi::Function::createFromHostFunction(
+      *runtime,
+      gcPropName,
+      0,
+      [](jsi::Runtime &rt,
+         const jsi::Value &thisVal,
+         const jsi::Value *args,
+         size_t count) {
+        rt.instrumentation().collectGarbage("test");
+        return jsi::Value::undefined();
+      }
+    )
+  );
+
   // By default "global" property isn't set.
   runtime->global().setProperty(
     *runtime,

package/android/src/main/cpp/types/FrontendConverter.h

@@ -2,6 +2,8 @@
 
 #pragma once
 
+#include <algorithm>
+
 #include "../ExpoHeader.pch"
 #include "CppType.h"
 
@@ -41,6 +43,16 @@ public:
     JNIEnv *env,
     const jsi::Value &value
   ) const = 0;
+
+  /**
+   * Whether the JS value has to stay alive until an async call that received it is settled.
+   * It's true for converters that pass only a reference to Kotlin, like the shared object id.
+   * The native body works with the object behind that reference, so the JS value must not be
+   * garbage collected before the call ends. Composite converters ask their element converters.
+   */
+  virtual bool retainsJSValue() const {
+    return false;
+  }
 };
 
 /**
@@ -276,6 +288,10 @@ public:
   ) const override;
 
   bool canConvert(jsi::Runtime &rt, const jsi::Value &value) const override;
+
+  bool retainsJSValue() const override {
+    return true;
+  }
 };
 
 /**
@@ -312,6 +328,12 @@ public:
     const jsi::Value &value
   ) const override;
 
+  bool retainsJSValue() const override {
+    return std::any_of(converters.begin(), converters.end(), [](const auto &converter) {
+      return converter->retainsJSValue();
+    });
+  }
+
 private:
   std::vector<std::shared_ptr<FrontendConverter>> converters;
 };
@@ -365,6 +387,10 @@ public:
 
   bool canConvert(jsi::Runtime &rt, const jsi::Value &value) const override;
 
+  bool retainsJSValue() const override {
+    return parameterConverter->retainsJSValue();
+  }
+
 private:
   /**
    * A string representation of desired Java type.
@@ -396,6 +422,10 @@ public:
   ) const override;
 
   bool canConvert(jsi::Runtime &rt, const jsi::Value &value) const override;
+
+  bool retainsJSValue() const override {
+    return parameterConverter->retainsJSValue();
+  }
 private:
   /**
    * Converter used to convert array elements.
@@ -425,6 +455,10 @@ public:
   ) const override;
 
   bool canConvert(jsi::Runtime &rt, const jsi::Value &value) const override;
+
+  bool retainsJSValue() const override {
+    return valueConverter->retainsJSValue();
+  }
 private:
   /**
    * Converter used to convert values.
@@ -464,6 +498,10 @@ public:
   ) const override;
 
   bool canConvert(jsi::Runtime &rt, const jsi::Value &value) const override;
+
+  bool retainsJSValue() const override {
+    return parameterConverter->retainsJSValue();
+  }
 private:
   std::shared_ptr<FrontendConverter> parameterConverter;
 };
@@ -481,6 +519,10 @@ public:
   ) const override;
 
   bool canConvert(jsi::Runtime &rt, const jsi::Value &value) const override;
+
+  bool retainsJSValue() const override {
+    return parameterConverter->retainsJSValue();
+  }
 private:
   std::shared_ptr<FrontendConverter> parameterConverter;
 };

package/android/src/main/java/expo/modules/kotlin/jni/JNIDeallocator.kt

@@ -58,6 +58,20 @@ class JNIDeallocator(shouldCreateDestructorThread: Boolean = true) : AutoCloseab
     destructorThread?.interrupt()
   }
 
+  /**
+   * Deallocates the hybrid objects whose Java wrappers were already garbage collected,
+   * without waiting for the destructor thread. Returns how many objects were deallocated.
+   */
+  internal fun processPendingReferences(): Int = synchronized(this) {
+    var processed = 0
+    while (true) {
+      val current = referenceQueue.poll() ?: break
+      destructorMap.remove(current)?.resetNative()
+      processed++
+    }
+    processed
+  }
+
   /**
    * Returns references to all hybrid objects that contain references to the jsi value
    * and are present in the memory.

package/ios/Core/Exceptions/Exception.swift

@@ -7,7 +7,7 @@ open class Exception: CodedError, ChainableException, CustomStringConvertible, C
    String describing the reason of the exception.
    */
   open var reason: String {
-    "undefined reason"
+    customReason ?? "undefined reason"
   }
 
   /**
@@ -20,6 +20,12 @@ open class Exception: CodedError, ChainableException, CustomStringConvertible, C
    */
   let customCode: String?
 
+  /**
+   A custom reason of the exception, given as the `description` to the initializer that takes a name.
+   When unset, the `reason` is expected to come from an override in a subclass.
+   */
+  let customReason: String?
+
   /**
    The default initializer that captures the place in the code where the exception was created.
    - Warning: Call it only without arguments!
@@ -27,13 +33,14 @@ open class Exception: CodedError, ChainableException, CustomStringConvertible, C
   public init(file: String = #fileID, line: UInt = #line, function: String = #function) {
     self.origin = ExceptionOrigin(file: file, line: line, function: function)
     self.customCode = nil
+    self.customReason = nil
   }
 
   public init(name: String, description: String, code: String? = nil, file: String = #fileID, line: UInt = #line, function: String = #function) {
     self.origin = ExceptionOrigin(file: file, line: line, function: function)
     self.customCode = code
+    self.customReason = description
     self.name = name
-    self.description = description
   }
 
   // MARK: - CodedError

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "expo-modules-core",
-  "version": "57.0.19",
+  "version": "57.0.20",
   "description": "The core of Expo Modules architecture",
   "main": "src/index.ts",
   "types": "build/index.d.ts",
@@ -66,7 +66,7 @@
     "@types/invariant": "^2.2.33",
     "expo-module-scripts": "56.0.3"
   },
-  "gitHead": "9349d1457178dd9cccb8bdd3aed47473c49134e1",
+  "gitHead": "ad1efa3fa5802156660198ba5d787f91014d8df3",
   "scripts": {
     "build": "expo-module build",
     "clean": "expo-module clean",