expo-modules-core 55.0.3 → 55.0.5

package/CHANGELOG.md

@@ -10,6 +10,16 @@
 
 ### 💡 Others
 
+## 55.0.5 — 2026-01-27
+
+_This version does not introduce any user-facing changes._
+
+## 55.0.4 — 2026-01-26
+
+### 🐛 Bug fixes
+
+- [Android] Added missing checks in the promise implementation. ([#42467](https://github.com/expo/expo/pull/42467) by [@lukmccall](https://github.com/lukmccall))
+
 ## 55.0.3 — 2026-01-22
 
 ### 🐛 Bug fixes

package/android/build.gradle

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

package/android/src/main/cpp/JSIContext.cpp

@@ -13,13 +13,13 @@
 #include <fbjni/fbjni.h>
 
 #include <memory>
+#include <shared_mutex>
 
 namespace jni = facebook::jni;
 namespace jsi = facebook::jsi;
 
 namespace expo {
 
-
 void JSIContext::registerNatives() {
   registerHybrid({
                    makeNativeMethod("evaluateScript", JSIContext::evaluateScript),
@@ -263,14 +263,26 @@ bool JSIContext::wasDeallocated() const noexcept {
   return wasDeallocated_;
 }
 
-std::unordered_map<uintptr_t, JSIContext *> jsiContexts;
+static std::unordered_map<uintptr_t, JSIContext *> jsiContexts;
+static std::shared_mutex jsiContextsMutex;
 
 void bindJSIContext(const jsi::Runtime &runtime, JSIContext *jsiContext) {
+  std::unique_lock lock(jsiContextsMutex);
   jsiContexts[reinterpret_cast<uintptr_t>(&runtime)] = jsiContext;
 }
 
 void unbindJSIContext(const jsi::Runtime &runtime) {
+  std::unique_lock lock(jsiContextsMutex);
   jsiContexts.erase(reinterpret_cast<uintptr_t>(&runtime));
 }
 
+JSIContext *getJSIContext(const jsi::Runtime &runtime) {
+  std::shared_lock lock(jsiContextsMutex);
+  const auto iterator = jsiContexts.find(reinterpret_cast<uintptr_t>(&runtime));
+  if (iterator == jsiContexts.end()) {
+    throw std::invalid_argument("JSIContext for the given runtime doesn't exist");
+  }
+  return iterator->second;
+}
+
 } // namespace expo

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

@@ -167,14 +167,9 @@ private:
   ) noexcept;
 };
 
-/**
- * We are binding the JSIContext to the runtime using a thread-local map.
- * This is a simplification of how we're accessing the JSIContext from different places.
- */
-extern std::unordered_map<uintptr_t, JSIContext *> jsiContexts;
-
 /**
  * Binds the JSIContext to the runtime.
+ * Thread-safe: uses exclusive lock.
  * @param runtime
  * @param jsiContext
  */
@@ -182,22 +177,18 @@ void bindJSIContext(const jsi::Runtime &runtime, JSIContext *jsiContext);
 
 /**
  * Unbinds the JSIContext from the runtime.
+ * Thread-safe: uses exclusive lock.
  * @param runtime
  */
 void unbindJSIContext(const jsi::Runtime &runtime);
 
 /**
  * Gets the JSIContext for the given runtime.
+ * Thread-safe: uses exclusive lock.
  * @param runtime
  * @return JSIContext * - it should never be stored when received from this function.
- * It might throw an exception if the JSIContext for the given runtime doesn't exist.
+ * @throws std::invalid_argument if the JSIContext for the given runtime doesn't exist.
  */
-inline JSIContext *getJSIContext(const jsi::Runtime &runtime) {
-  const auto iterator = jsiContexts.find(reinterpret_cast<uintptr_t>(&runtime));
-  if (iterator == jsiContexts.end()) {
-    throw std::invalid_argument("JSIContext for the given runtime doesn't exist");
-  }
-  return iterator->second;
-}
+JSIContext *getJSIContext(const jsi::Runtime &runtime);
 
 } // namespace expo

package/android/src/main/cpp/JavaScriptFunction.cpp

@@ -27,7 +27,7 @@ std::shared_ptr<jsi::Function> JavaScriptFunction::get() {
 
 jobject JavaScriptFunction::invoke(
   jni::alias_ref<JavaScriptObject::javaobject> jsThis,
-  jni::alias_ref<jni::JArrayClass<jni::JObject>> args,
+  jni::alias_ref<jni::JArrayClass<jobject>> args,
   jni::alias_ref<ExpectedType::javaobject> expectedReturnType
 ) {
   auto runtime = runtimeHolder.lock();
@@ -35,28 +35,20 @@ jobject JavaScriptFunction::invoke(
   auto &rawRuntime = runtime->get();
 
   JNIEnv *env = jni::Environment::current();
-
-  size_t size = args->size();
-  std::vector<jsi::Value> convertedArgs;
-  convertedArgs.reserve(size);
-
-  for (size_t i = 0; i < size; i++) {
-    jni::local_ref<jobject> arg = args->getElement(i);
-    convertedArgs.push_back(convert(env, rawRuntime, arg));
-  }
+  std::vector<jsi::Value> convertedArgs = convertArray(env, rawRuntime, args);
 
   // TODO(@lukmccall): add better error handling
   jsi::Value result = jsThis == nullptr ?
     jsFunction->call(
       rawRuntime,
       (const jsi::Value *) convertedArgs.data(),
-      size
+      convertedArgs.size()
     ) :
     jsFunction->callWithThis(
       rawRuntime,
       *(jsThis->cthis()->get()),
       (const jsi::Value *) convertedArgs.data(),
-      size
+      convertedArgs.size()
     );
 
   auto converter = AnyType(jni::make_local(expectedReturnType)).converter;

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

@@ -49,7 +49,7 @@ private:
 
   jobject invoke(
     jni::alias_ref<jni::HybridClass<JavaScriptObject, Destructible>::javaobject> jsThis,
-    jni::alias_ref<jni::JArrayClass<jni::JObject>> args,
+    jni::alias_ref<jni::JArrayClass<jobject>> args,
     jni::alias_ref<ExpectedType::javaobject> expectedReturnType
   );
 };

package/android/src/main/cpp/JavaScriptRuntime.cpp

@@ -14,11 +14,7 @@ namespace expo {
 JavaScriptRuntime::JavaScriptRuntime(
   jsi::Runtime *runtime,
   std::shared_ptr<react::CallInvoker> jsInvoker
-) : jsInvoker(std::move(jsInvoker)) {
-  // Creating a shared pointer that points to the runtime but doesn't own it, thus doesn't release it.
-  // In this code flow, the runtime should be owned by something else like the CatalystInstance.
-  // See explanation for constructor (8): https://en.cppreference.com/w/cpp/memory/shared_ptr/shared_ptr
-  this->runtime = std::shared_ptr<jsi::Runtime>(std::shared_ptr<jsi::Runtime>(), runtime);
+) : jsInvoker(std::move(jsInvoker)), runtime(runtime) {
 }
 
 jsi::Runtime &JavaScriptRuntime::get() const noexcept {

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

@@ -76,6 +76,12 @@ public:
   std::shared_ptr<react::CallInvoker> jsInvoker;
 
 private:
-  std::shared_ptr<jsi::Runtime> runtime;
+  /**
+   * Raw pointer to the runtime. We do not own this - it's managed by React Native.
+   * The runtime's lifetime is guaranteed to exceed JavaScriptRuntime's lifetime,
+   * as JSIContext::prepareForDeallocation() invalidates all weak references before
+   * the runtime is deallocated.
+   */
+  jsi::Runtime *runtime;
 };
 } // namespace expo

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

@@ -32,6 +32,24 @@ jsi::Value convert(
   const jni::local_ref<jobject> &value
 );
 
+template<typename RefType>
+std::vector<jsi::Value> convertArray(
+  JNIEnv *env,
+  jsi::Runtime &rt,
+  RefType &values
+) {
+  size_t size = values->size();
+  std::vector<jsi::Value> convertedValues;
+  convertedValues.reserve(size);
+
+  for (size_t i = 0; i < size; i++) {
+    jni::local_ref<jobject> value = values->getElement(i);
+    convertedValues.push_back(convert(env, rt, value));
+  }
+
+  return convertedValues;
+}
+
 /**
  * Convert a string with FollyDynamicExtensionConverter support.
  */

package/android/src/main/cpp/worklets/Worklet.cpp

@@ -2,12 +2,16 @@
 
 #if WORKLETS_ENABLED
 
+#include "../types/JNIToJSIConverter.h"
+
 namespace expo {
 
 void Worklet::registerNatives() {
   javaClassLocal()->registerNatives({
                                       makeNativeMethod("schedule", Worklet::schedule),
+                                      makeNativeMethod("schedule", Worklet::scheduleWithArgs),
                                       makeNativeMethod("execute", Worklet::execute),
+                                      makeNativeMethod("execute", Worklet::executeWithArgs),
                                     });
 }
 
@@ -17,7 +21,10 @@ void Worklet::schedule(
   jni::alias_ref<Serializable::javaobject> synchronizable
 ) {
   auto workletRuntime = workletRuntimeHolder->cthis()->workletRuntime.lock();
-  auto worklet = std::dynamic_pointer_cast<worklets::SerializableWorklet>(synchronizable->cthis()->getSerializable());
+  auto worklet = std::dynamic_pointer_cast<worklets::SerializableWorklet>(
+    synchronizable->cthis()->getSerializable()
+  );
+
   workletRuntime->schedule(std::move(worklet));
 }
 
@@ -27,11 +34,61 @@ void Worklet::execute(
   jni::alias_ref<Serializable::javaobject> synchronizable
 ) {
   auto workletRuntime = workletRuntimeHolder->cthis()->workletRuntime.lock();
-  auto worklet = std::dynamic_pointer_cast<worklets::SerializableWorklet>(synchronizable->cthis()->getSerializable());
+  auto worklet = std::dynamic_pointer_cast<worklets::SerializableWorklet>(
+    synchronizable->cthis()->getSerializable()
+  );
 
   workletRuntime->runSync(worklet);
 }
 
+void Worklet::scheduleWithArgs(
+  jni::alias_ref<Worklet::javaobject> self,
+  jni::alias_ref<WorkletNativeRuntime::javaobject> workletRuntimeHolder,
+  jni::alias_ref<Serializable::javaobject> synchronizable,
+  jni::alias_ref<jni::JArrayClass<jobject>> args
+) {
+  auto workletRuntime = workletRuntimeHolder->cthis()->workletRuntime.lock();
+  auto worklet = std::dynamic_pointer_cast<worklets::SerializableWorklet>(
+    synchronizable->cthis()->getSerializable()
+  );
+
+  workletRuntime->schedule([&worklet, globalArgs = jni::make_global(args)](jsi::Runtime &rt) mutable {
+    JNIEnv *env = jni::Environment::current();
+    std::vector<jsi::Value> convertedArgs = convertArray(env, rt, globalArgs);
+
+    auto func = worklet->toJSValue(rt).asObject(rt).asFunction(rt);
+    func.call(
+      rt,
+      (const jsi::Value *) convertedArgs.data(),
+      convertedArgs.size()
+    );
+  });
+}
+
+void Worklet::executeWithArgs(
+  jni::alias_ref<Worklet::javaobject> self,
+  jni::alias_ref<WorkletNativeRuntime::javaobject> workletRuntimeHolder,
+  jni::alias_ref<Serializable::javaobject> synchronizable,
+  jni::alias_ref<jni::JArrayClass<jobject>> args
+) {
+  auto workletRuntime = workletRuntimeHolder->cthis()->workletRuntime.lock();
+  auto worklet = std::dynamic_pointer_cast<worklets::SerializableWorklet>(
+    synchronizable->cthis()->getSerializable()
+  );
+
+  workletRuntime->runSync([&args, &worklet](jsi::Runtime &rt) {
+    JNIEnv *env = jni::Environment::current();
+    std::vector<jsi::Value> convertedArgs = convertArray(env, rt, args);
+
+    auto func = worklet->toJSValue(rt).asObject(rt).asFunction(rt);
+    func.call(
+      rt,
+      (const jsi::Value *) convertedArgs.data(),
+      convertedArgs.size()
+    );
+  });
+}
+
 } // namespace expo
 
 #endif

package/android/src/main/cpp/worklets/Worklet.h

@@ -33,6 +33,20 @@ public:
     jni::alias_ref<WorkletNativeRuntime::javaobject> workletRuntimeHolder,
     jni::alias_ref<Serializable::javaobject> synchronizable
   );
+
+  static void scheduleWithArgs(
+    jni::alias_ref<Worklet::javaobject> self,
+    jni::alias_ref<WorkletNativeRuntime::javaobject> workletRuntimeHolder,
+    jni::alias_ref<Serializable::javaobject> synchronizable,
+    jni::alias_ref<jni::JArrayClass<jobject>> args
+  );
+
+  static void executeWithArgs(
+    jni::alias_ref<Worklet::javaobject> self,
+    jni::alias_ref<WorkletNativeRuntime::javaobject> workletRuntimeHolder,
+    jni::alias_ref<Serializable::javaobject> synchronizable,
+    jni::alias_ref<jni::JArrayClass<jobject>> args
+  );
 };
 
 } // namespace expo

package/android/src/main/java/expo/modules/kotlin/AppContext.kt

@@ -264,16 +264,25 @@ class AppContext(
   }
 
   internal fun onDestroy() = trace("AppContext.onDestroy") {
-    hostingRuntimeContext.reactContext?.removeLifecycleEventListener(reactLifecycleDelegate)
-    registry.post(EventName.MODULE_DESTROY)
-    registry.cleanUp()
+    runtime.reactContext?.run {
+      removeLifecycleEventListener(reactLifecycleDelegate)
+      removeActivityEventListener(reactLifecycleDelegate)
+    }
+
+    with(registry) {
+      post(EventName.MODULE_DESTROY)
+      cleanUp()
+    }
+
     modulesQueue.cancel(ContextDestroyedException())
     mainQueue.cancel(ContextDestroyedException())
     backgroundCoroutineScope.cancel(ContextDestroyedException())
-    hostingRuntimeContext.deallocate()
+
+    runtime.deallocate()
     if (uiRuntimeHolder.isInitialized()) {
       uiRuntime.deallocate()
     }
+
     logger.info("✅ AppContext was destroyed")
   }
 

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

@@ -45,11 +45,11 @@ class PromiseImpl @DoNotStrip internal constructor(
     callback.invoke(result)
   }
 
-  override fun resolve(result: Collection<Any?>) {
+  override fun resolve(result: Collection<Any?>) = checkIfWasSettled {
     callback.invoke(result)
   }
 
-  override fun resolve(result: Map<String, Any?>) {
+  override fun resolve(result: Map<String, Any?>) = checkIfWasSettled {
     callback.invoke(result)
   }
 
@@ -62,11 +62,11 @@ class PromiseImpl @DoNotStrip internal constructor(
   private inline fun checkIfWasSettled(body: () -> Unit) {
     if (wasSettled) {
       val exception = PromiseAlreadySettledException(fullFunctionName ?: "unknown")
-      val errorManager = appContextHolder?.get()?.errorManager
+      val jsLogger = appContextHolder?.get()?.jsLogger
       // We want to report that a promise was settled twice in the development build.
       // However, in production, the app should crash.
-      if (BuildConfig.DEBUG && errorManager != null) {
-        errorManager.reportExceptionToLogBox(exception)
+      if (BuildConfig.DEBUG && jsLogger != null) {
+        jsLogger.error("Trying to resolve promise that was already settled", exception)
         logger.error("Trying to resolve promise that was already settled", exception)
         return
       }

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

@@ -1,6 +1,7 @@
 package expo.modules.kotlin.jni.worklets
 
 import expo.modules.kotlin.runtime.WorkletRuntime
+import expo.modules.kotlin.types.JSTypeConverter
 
 class Worklet internal constructor(
   private val serializable: Serializable
@@ -19,13 +20,45 @@ class Worklet internal constructor(
     execute(runtimeHolder, serializable)
   }
 
+  fun schedule(runtime: WorkletRuntime, vararg arguments: Any?) {
+    val runtimeHolder = runtime.enforceHolder
+
+    val convertedArgs = arguments.map {
+      JSTypeConverter.convertToJSValue(it, useExperimentalConverter = true)
+    }.toTypedArray()
+
+    schedule(runtimeHolder, serializable, convertedArgs)
+  }
+
+  fun execute(runtime: WorkletRuntime, vararg arguments: Any?) {
+    val runtimeHolder = runtime.enforceHolder
+
+    val convertedArgs = arguments.map {
+      JSTypeConverter.convertToJSValue(it, useExperimentalConverter = true)
+    }.toTypedArray()
+
+    execute(runtimeHolder, serializable, convertedArgs)
+  }
+
   private external fun schedule(
     workletNativeRuntime: WorkletNativeRuntime,
     serializable: Serializable
   )
 
+  private external fun schedule(
+    workletNativeRuntime: WorkletNativeRuntime,
+    serializable: Serializable,
+    args: Array<Any?>
+  )
+
   private external fun execute(
     workletNativeRuntime: WorkletNativeRuntime,
     serializable: Serializable
   )
+
+  private external fun execute(
+    workletNativeRuntime: WorkletNativeRuntime,
+    serializable: Serializable,
+    args: Array<Any?>
+  )
 }

package/ios/Core/Objects/ConstantDefinition.swift

@@ -10,6 +10,11 @@ protocol AnyConstantDefinition {
    Creates the JavaScript object representing the constant property descriptor.
    */
   func buildDescriptor(appContext: AppContext) throws -> JavaScriptObject
+
+  /**
+   Returns the raw value of the constant for encoding purposes.
+   */
+  func getRawValue() -> Any?
 }
 
 public final class ConstantDefinition<ReturnType>: AnyDefinition, AnyConstantDefinition {
@@ -59,6 +64,10 @@ public final class ConstantDefinition<ReturnType>: AnyDefinition, AnyConstantDef
     return try getter?()
   }
 
+  internal func getRawValue() -> Any? {
+    return try? getter?()
+  }
+
   /**
    Creates the JavaScript function that will be used as a getter of the constant.
    */

package/ios/DevTools/ModuleDefinitionEncoder.swift

@@ -16,7 +16,12 @@ class ModuleDefinitionEncoder: Encodable {
   func encode(to encoder: Encoder) throws {
     var container = encoder.container(keyedBy: CodingKeys.self)
     try container.encode(definition.name, forKey: .name)
-    try container.encode(definition.legacyConstants.map({ LegacyConstantsDefinitionEncoder($0) }), forKey: .constants)
+    var allConstants: [[ConstantEncoder]] = []
+    allConstants.append(contentsOf: definition.legacyConstants.map({ LegacyConstantsDefinitionEncoder($0).getEncoders() }))
+    if !definition.constants.isEmpty {
+      allConstants.append(definition.constants.values.map({ ConstantEncoder($0.name, value: $0.getRawValue()) }))
+    }
+    try container.encode(allConstants, forKey: .constants)
     try container.encode(definition.properties.values.map({ PropertyDefinitionEncoder($0) }), forKey: .properties)
     try container.encode(definition.functions.values.map({ FunctionDefinitionEncoder($0) }), forKey: .functions)
     try container.encode(definition.views.values.map({ ViewDefinitionEncoder($0) }), forKey: .views)
@@ -130,10 +135,10 @@ class ConstantEncoder: Encodable {
     case nil:
       try container.encodeNil(forKey: .value)
       try container.encode("null", forKey: .type)
-    case let value as [String: Any]:
+    case _ as [String: Any]:
       try container.encodeNil(forKey: .value)
       try container.encode("object", forKey: .type)
-    case let value as [Any]:
+    case _ as [Any]:
       try container.encodeNil(forKey: .value)
       try container.encode("array", forKey: .type)
     default:
@@ -143,24 +148,16 @@ class ConstantEncoder: Encodable {
   }
 }
 
-class LegacyConstantsDefinitionEncoder: Encodable {
+class LegacyConstantsDefinitionEncoder {
   private let definition: ConstantsDefinition
 
   init(_ definition: ConstantsDefinition) {
     self.definition = definition
   }
 
-  enum CodingKeys: String, CodingKey {
-    case name
-    case value
-  }
-
-  func encode(to encoder: Encoder) throws {
-    var container = encoder.unkeyedContainer()
+  func getEncoders() -> [ConstantEncoder] {
     let constants = definition.body()
-    for (key, value) in constants {
-      try container.encode(ConstantEncoder(key, value: value))
-    }
+    return constants.map { (key, value) in ConstantEncoder(key, value: value) }
   }
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "expo-modules-core",
-  "version": "55.0.3",
+  "version": "55.0.5",
   "description": "The core of Expo Modules architecture",
   "main": "src/index.ts",
   "types": "build/index.d.ts",
@@ -64,7 +64,7 @@
   },
   "devDependencies": {
     "@testing-library/react-native": "^13.2.0",
-    "expo-module-scripts": "^55.0.1"
+    "expo-module-scripts": "^55.0.2"
   },
-  "gitHead": "4728ba25fbd4d5835780306de78a83bd1628e271"
+  "gitHead": "220594d473a3100248087151004ae4acb7282d5f"
 }