expo-modules-core 55.0.2 → 55.0.4

package/CHANGELOG.md

@@ -10,6 +10,18 @@
 
 ### 💡 Others
 
+## 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
+
+- [Android] Fixed crashes in JavaScriptValue/JavaScriptObject destructor caused by freeing memory after the runtime is destroyed. ([#42440](https://github.com/expo/expo/pull/42440) by [@lukmccall](https://github.com/lukmccall))
+
 ## 55.0.2 — 2026-01-22
 
 ### 💡 Others

package/android/build.gradle

@@ -29,7 +29,7 @@ if (shouldIncludeCompose) {
 }
 
 group = 'host.exp.exponent'
-version = '55.0.2'
+version = '55.0.4'
 
 def isExpoModulesCoreTests = {
   Gradle gradle = getGradle()
@@ -96,7 +96,7 @@ android {
   defaultConfig {
     consumerProguardFiles 'proguard-rules.pro'
     versionCode 1
-    versionName "55.0.2"
+    versionName "55.0.4"
     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/JavaScriptArrayBuffer.cpp

@@ -22,14 +22,7 @@ JavaScriptArrayBuffer::JavaScriptArrayBuffer(
   std::weak_ptr<JavaScriptRuntime> runtime,
   std::shared_ptr<jsi::ArrayBuffer> jsObject
 ) : runtimeHolder(std::move(runtime)), arrayBuffer(std::move(jsObject)) {
-  runtimeHolder.ensureRuntimeIsValid();
-}
-
-JavaScriptArrayBuffer::JavaScriptArrayBuffer(
-  WeakRuntimeHolder runtime,
-  std::shared_ptr<jsi::ArrayBuffer> jsObject
-) : runtimeHolder(std::move(runtime)), arrayBuffer(std::move(jsObject)) {
-  runtimeHolder.ensureRuntimeIsValid();
+  assert((!runtimeHolder.expired()) && "JS Runtime was used after deallocation");
 }
 
 jni::local_ref<JavaScriptArrayBuffer::javaobject> JavaScriptArrayBuffer::newInstance(
@@ -46,13 +39,19 @@ jni::local_ref<JavaScriptArrayBuffer::javaobject> JavaScriptArrayBuffer::newInst
 }
 
 int JavaScriptArrayBuffer::size() {
-  jsi::Runtime &jsRuntime = runtimeHolder.getJSRuntime();
-  return (int) arrayBuffer->size(jsRuntime);
+  auto runtime = runtimeHolder.lock();
+  assert((runtime != nullptr) && "JS Runtime was used after deallocation");
+  auto &rawRuntime = runtime->get();
+
+  return (int) arrayBuffer->size(rawRuntime);
 }
 
 uint8_t *JavaScriptArrayBuffer::data() {
-  jsi::Runtime &jsRuntime = runtimeHolder.getJSRuntime();
-  return arrayBuffer->data(jsRuntime);
+  auto runtime = runtimeHolder.lock();
+  assert((runtime != nullptr) && "JS Runtime was used after deallocation");
+  auto &rawRuntime = runtime->get();
+
+  return arrayBuffer->data(rawRuntime);
 }
 
 jni::local_ref<jni::JByteBuffer> JavaScriptArrayBuffer::toDirectBuffer() {

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

@@ -1,7 +1,7 @@
 #pragma once
 
-#include "WeakRuntimeHolder.h"
 #include "JNIDeallocator.h"
+#include "JavaScriptRuntime.h"
 
 #include <fbjni/ByteBuffer.h>
 #include <fbjni/fbjni.h>
@@ -35,11 +35,6 @@ public:
     std::shared_ptr<jsi::ArrayBuffer> arrayBuffer
   );
 
-  JavaScriptArrayBuffer(
-    WeakRuntimeHolder runtime,
-    std::shared_ptr<jsi::ArrayBuffer> arrayBuffer
-  );
-
   [[nodiscard]] int size();
 
   [[nodiscard]] uint8_t* data();
@@ -54,7 +49,7 @@ public:
   }
 
 private:
-  WeakRuntimeHolder runtimeHolder;
+  std::weak_ptr<JavaScriptRuntime> runtimeHolder;
   std::shared_ptr<jsi::ArrayBuffer> arrayBuffer;
 };
 } // namespace expo

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

@@ -18,14 +18,7 @@ JavaScriptFunction::JavaScriptFunction(
   std::weak_ptr<JavaScriptRuntime> runtime,
   std::shared_ptr<jsi::Function> jsFunction
 ) : runtimeHolder(std::move(runtime)), jsFunction(std::move(jsFunction)) {
-  runtimeHolder.ensureRuntimeIsValid();
-}
-
-JavaScriptFunction::JavaScriptFunction(
-  WeakRuntimeHolder runtime,
-  std::shared_ptr<jsi::Function> jsFunction
-) : runtimeHolder(std::move(runtime)), jsFunction(std::move(jsFunction)) {
-  runtimeHolder.ensureRuntimeIsValid();
+  assert((!runtimeHolder.expired()) && "JS Runtime was used after deallocation");
 }
 
 std::shared_ptr<jsi::Function> JavaScriptFunction::get() {
@@ -37,7 +30,10 @@ jobject JavaScriptFunction::invoke(
   jni::alias_ref<jni::JArrayClass<jni::JObject>> args,
   jni::alias_ref<ExpectedType::javaobject> expectedReturnType
 ) {
-  auto &rt = runtimeHolder.getJSRuntime();
+  auto runtime = runtimeHolder.lock();
+  assert((runtime != nullptr) && "JS Runtime was used after deallocation");
+  auto &rawRuntime = runtime->get();
+
   JNIEnv *env = jni::Environment::current();
 
   size_t size = args->size();
@@ -46,25 +42,25 @@ jobject JavaScriptFunction::invoke(
 
   for (size_t i = 0; i < size; i++) {
     jni::local_ref<jobject> arg = args->getElement(i);
-    convertedArgs.push_back(convert(env, rt, arg));
+    convertedArgs.push_back(convert(env, rawRuntime, arg));
   }
 
   // TODO(@lukmccall): add better error handling
   jsi::Value result = jsThis == nullptr ?
     jsFunction->call(
-      rt,
+      rawRuntime,
       (const jsi::Value *) convertedArgs.data(),
       size
     ) :
     jsFunction->callWithThis(
-      rt,
+      rawRuntime,
       *(jsThis->cthis()->get()),
       (const jsi::Value *) convertedArgs.data(),
       size
     );
 
   auto converter = AnyType(jni::make_local(expectedReturnType)).converter;
-  auto convertedResult = converter->convert(rt, env, result);
+  auto convertedResult = converter->convert(rawRuntime, env, result);
   return convertedResult;
 }
 

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

@@ -4,7 +4,6 @@
 
 #include "JSIObjectWrapper.h"
 #include "JavaScriptRuntime.h"
-#include "WeakRuntimeHolder.h"
 #include "types/ExpectedType.h"
 
 #include <fbjni/fbjni.h>
@@ -39,18 +38,13 @@ public:
     std::shared_ptr<jsi::Function> jsFunction
   );
 
-  JavaScriptFunction(
-    WeakRuntimeHolder runtime,
-    std::shared_ptr<jsi::Function> jsFunction
-  );
-
   std::shared_ptr<jsi::Function> get() override;
 
 
 private:
   friend HybridBase;
 
-  WeakRuntimeHolder runtimeHolder;
+  std::weak_ptr<JavaScriptRuntime> runtimeHolder;
   std::shared_ptr<jsi::Function> jsFunction;
 
   jobject invoke(

package/android/src/main/cpp/JavaScriptObject.cpp

@@ -51,14 +51,7 @@ JavaScriptObject::JavaScriptObject(
   std::weak_ptr<JavaScriptRuntime> runtime,
   std::shared_ptr<jsi::Object> jsObject
 ) : runtimeHolder(std::move(runtime)), jsObject(std::move(jsObject)) {
-  runtimeHolder.ensureRuntimeIsValid();
-}
-
-JavaScriptObject::JavaScriptObject(
-  WeakRuntimeHolder runtime,
-  std::shared_ptr<jsi::Object> jsObject
-) : runtimeHolder(std::move(runtime)), jsObject(std::move(jsObject)) {
-  runtimeHolder.ensureRuntimeIsValid();
+  assert((!runtimeHolder.expired()) && "JS Runtime was used after deallocation");
 }
 
 std::shared_ptr<jsi::Object> JavaScriptObject::get() {
@@ -66,13 +59,19 @@ std::shared_ptr<jsi::Object> JavaScriptObject::get() {
 }
 
 bool JavaScriptObject::hasProperty(const std::string &name) {
-  auto &jsRuntime = runtimeHolder.getJSRuntime();
-  return jsObject->hasProperty(jsRuntime, name.c_str());
+  auto runtime = runtimeHolder.lock();
+  assert((runtime != nullptr) && "JS Runtime was used after deallocation");
+  auto &rawRuntime = runtime->get();
+
+  return jsObject->hasProperty(rawRuntime, name.c_str());
 }
 
 jsi::Value JavaScriptObject::getProperty(const std::string &name) {
-  auto &jsRuntime = runtimeHolder.getJSRuntime();
-  return jsObject->getProperty(jsRuntime, name.c_str());
+  auto runtime = runtimeHolder.lock();
+  assert((runtime != nullptr) && "JS Runtime was used after deallocation");
+  auto &rawRuntime = runtime->get();
+
+  return jsObject->getProperty(rawRuntime, name.c_str());
 }
 
 bool JavaScriptObject::jniHasProperty(jni::alias_ref<jstring> name) {
@@ -82,26 +81,32 @@ bool JavaScriptObject::jniHasProperty(jni::alias_ref<jstring> name) {
 jni::local_ref<JavaScriptValue::javaobject> JavaScriptObject::jniGetProperty(
   jni::alias_ref<jstring> name
 ) {
+  auto runtime = runtimeHolder.lock();
+  assert((runtime != nullptr) && "JS Runtime was used after deallocation");
+  auto &rawRuntime = runtime->get();
+
   auto result = std::make_shared<jsi::Value>(getProperty(name->toStdString()));
   return JavaScriptValue::newInstance(
-    runtimeHolder.getJSIContext(),
+    expo::getJSIContext(rawRuntime),
     runtimeHolder,
     result
   );
 }
 
 std::vector<std::string> JavaScriptObject::getPropertyNames() {
-  auto &jsRuntime = runtimeHolder.getJSRuntime();
+  auto runtime = runtimeHolder.lock();
+  assert((runtime != nullptr) && "JS Runtime was used after deallocation");
+  auto &rawRuntime = runtime->get();
 
-  jsi::Array properties = jsObject->getPropertyNames(jsRuntime);
-  auto size = properties.size(jsRuntime);
+  jsi::Array properties = jsObject->getPropertyNames(rawRuntime);
+  auto size = properties.size(rawRuntime);
 
   std::vector<std::string> names(size);
   for (size_t i = 0; i < size; i++) {
     auto propertyName = properties
-      .getValueAtIndex(jsRuntime, i)
-      .asString(jsRuntime)
-      .utf8(jsRuntime);
+      .getValueAtIndex(rawRuntime, i)
+      .asString(rawRuntime)
+      .utf8(rawRuntime);
     names[i] = propertyName;
   }
 
@@ -120,33 +125,46 @@ jni::local_ref<jni::JArrayClass<jstring>> JavaScriptObject::jniGetPropertyNames(
 
 jni::local_ref<jni::HybridClass<JavaScriptWeakObject, Destructible>::javaobject>
 JavaScriptObject::createWeak() {
+  auto runtime = runtimeHolder.lock();
+  assert((runtime != nullptr) && "JS Runtime was used after deallocation");
+  auto &rawRuntime = runtime->get();
+
   return JavaScriptWeakObject::newInstance(
-    runtimeHolder.getJSIContext(),
+    expo::getJSIContext(rawRuntime),
     runtimeHolder,
     get()
   );
 }
 
 jni::local_ref<JavaScriptFunction::javaobject> JavaScriptObject::jniAsFunction() {
-  auto &jsRuntime = runtimeHolder.getJSRuntime();
-  auto jsFuncion = std::make_shared<jsi::Function>(jsObject->asFunction(jsRuntime));
+  auto runtime = runtimeHolder.lock();
+  assert((runtime != nullptr) && "JS Runtime was used after deallocation");
+  auto &rawRuntime = runtime->get();
+
+  auto jsFuncion = std::make_shared<jsi::Function>(jsObject->asFunction(rawRuntime));
   return JavaScriptFunction::newInstance(
-    runtimeHolder.getJSIContext(),
+    expo::getJSIContext(rawRuntime),
     runtimeHolder,
     jsFuncion
   );
 }
 
 void JavaScriptObject::setProperty(const std::string &name, jsi::Value value) {
-  auto &jsRuntime = runtimeHolder.getJSRuntime();
-  jsObject->setProperty(jsRuntime, name.c_str(), value);
+  auto runtime = runtimeHolder.lock();
+  assert((runtime != nullptr) && "JS Runtime was used after deallocation");
+  auto &rawRuntime = runtime->get();
+
+  jsObject->setProperty(rawRuntime, name.c_str(), value);
 }
 
 void JavaScriptObject::unsetProperty(jni::alias_ref<jstring> name) {
-  auto &jsRuntime = runtimeHolder.getJSRuntime();
+  auto runtime = runtimeHolder.lock();
+  assert((runtime != nullptr) && "JS Runtime was used after deallocation");
+  auto &rawRuntime = runtime->get();
+
   auto cName = name->toStdString();
   jsObject->setProperty(
-    jsRuntime,
+    rawRuntime,
     cName.c_str(),
     jsi::Value::undefined()
   );
@@ -178,11 +196,14 @@ jni::local_ref<JavaScriptObject::javaobject> JavaScriptObject::newInstance(
 void JavaScriptObject::defineNativeDeallocator(
   jni::alias_ref<JNIFunctionBody::javaobject> deallocator
 ) {
-  auto &rt = runtimeHolder.getJSRuntime();
+  auto runtime = runtimeHolder.lock();
+  assert((runtime != nullptr) && "JS Runtime was used after deallocation");
+  auto &rawRuntime = runtime->get();
+
   jni::global_ref<JNIFunctionBody::javaobject> globalRef = jni::make_global(deallocator);
 
   common::setDeallocator(
-    rt,
+    rawRuntime,
     jsObject,
     [globalRef = std::move(globalRef)]() mutable {
       auto args = jni::Environment::ensureCurrentThreadIsAttached()->NewObjectArray(
@@ -197,28 +218,36 @@ void JavaScriptObject::defineNativeDeallocator(
 }
 
 void JavaScriptObject::setExternalMemoryPressure(int size) {
-  auto &jsRuntime = runtimeHolder.getJSRuntime();
-  jsObject->setExternalMemoryPressure(jsRuntime, size);
+  auto runtime = runtimeHolder.lock();
+  assert((runtime != nullptr) && "JS Runtime was used after deallocation");
+  auto &rawRuntime = runtime->get();
+
+  jsObject->setExternalMemoryPressure(rawRuntime, size);
 }
 
 bool JavaScriptObject::isArray() {
-  auto &jsRuntime = runtimeHolder.getJSRuntime();
-  return jsObject->isArray(jsRuntime);
+  auto runtime = runtimeHolder.lock();
+  assert((runtime != nullptr) && "JS Runtime was used after deallocation");
+  auto &rawRuntime = runtime->get();
+
+  return jsObject->isArray(rawRuntime);
 }
 
 jni::local_ref<jni::JArrayClass<JavaScriptValue::javaobject>> JavaScriptObject::getArray() {
-  auto &jsRuntime = runtimeHolder.getJSRuntime();
-  auto moduleRegistry = runtimeHolder.getJSIContext();
+  auto runtime = runtimeHolder.lock();
+  assert((runtime != nullptr) && "JS Runtime was used after deallocation");
+  auto &rawRuntime = runtime->get();
+  auto jsiContext = expo::getJSIContext(rawRuntime);
 
-  auto jsArray = jsObject->getArray(jsRuntime);
-  size_t size = jsArray.size(jsRuntime);
+  auto jsArray = jsObject->getArray(rawRuntime);
+  size_t size = jsArray.size(rawRuntime);
 
   auto result = jni::JArrayClass<JavaScriptValue::javaobject>::newArray(size);
   for (size_t i = 0; i < size; i++) {
     auto element = JavaScriptValue::newInstance(
-      moduleRegistry,
+      jsiContext,
       runtimeHolder,
-      std::make_shared<jsi::Value>(jsArray.getValueAtIndex(jsRuntime, i))
+      std::make_shared<jsi::Value>(jsArray.getValueAtIndex(rawRuntime, i))
     );
 
     result->setElement(i, element.release());
@@ -227,18 +256,23 @@ jni::local_ref<jni::JArrayClass<JavaScriptValue::javaobject>> JavaScriptObject::
 }
 
 bool JavaScriptObject::isArrayBuffer() {
-  auto &jsRuntime = runtimeHolder.getJSRuntime();
-  return jsObject->isArrayBuffer(jsRuntime);
+  auto runtime = runtimeHolder.lock();
+  assert((runtime != nullptr) && "JS Runtime was used after deallocation");
+  auto &rawRuntime = runtime->get();
+
+  return jsObject->isArrayBuffer(rawRuntime);
 }
 
 jni::local_ref<JavaScriptArrayBuffer::javaobject> JavaScriptObject::getArrayBuffer() {
-  auto &jsRuntime = runtimeHolder.getJSRuntime();
-  auto jsiContext = runtimeHolder.getJSIContext();
+  auto runtime = runtimeHolder.lock();
+  assert((runtime != nullptr) && "JS Runtime was used after deallocation");
+  auto &rawRuntime = runtime->get();
+  auto jsiContext = expo::getJSIContext(rawRuntime);
 
   return JavaScriptArrayBuffer::newInstance(
     jsiContext,
     runtimeHolder,
-    std::make_shared<jsi::ArrayBuffer>(jsObject->getArrayBuffer(jsRuntime))
+    std::make_shared<jsi::ArrayBuffer>(jsObject->getArrayBuffer(rawRuntime))
   );
 }
 

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

@@ -5,7 +5,6 @@
 #include "JSIObjectWrapper.h"
 #include "JSITypeConverter.h"
 #include "JavaScriptRuntime.h"
-#include "WeakRuntimeHolder.h"
 #include "JNIFunctionBody.h"
 #include "JNIDeallocator.h"
 #include "JSIUtils.h"
@@ -47,13 +46,6 @@ public:
     std::shared_ptr<jsi::Object> jsObject
   );
 
-  JavaScriptObject(
-    WeakRuntimeHolder runtime,
-    std::shared_ptr<jsi::Object> jsObject
-  );
-
-  virtual ~JavaScriptObject() = default;
-
   std::shared_ptr<jsi::Object> get() override;
 
   /**
@@ -92,9 +84,8 @@ public:
   [[nodiscard]] jni::local_ref<jni::HybridClass<JavaScriptArrayBuffer, Destructible>::javaobject> getArrayBuffer();
 
 protected:
-  WeakRuntimeHolder runtimeHolder;
+  std::weak_ptr<JavaScriptRuntime> runtimeHolder;
   std::shared_ptr<jsi::Object> jsObject;
-
 private:
   friend HybridBase;
 
@@ -130,13 +121,15 @@ private:
     typename = std::enable_if_t<is_jsi_type_converter_defined<T>>
   >
   void setProperty(jni::alias_ref<jstring> name, T value) {
-    jsi::Runtime &jsRuntime = runtimeHolder.getJSRuntime();
+    auto runtime = runtimeHolder.lock();
+    assert((runtime != nullptr) && "JS Runtime was used after deallocation");
+    auto &rawRuntime = runtime->get();
 
     auto cName = name->toStdString();
     jsObject->setProperty(
-      jsRuntime,
+      rawRuntime,
       cName.c_str(),
-      jsi_type_converter<T>::convert(jsRuntime, value)
+      jsi_type_converter<T>::convert(rawRuntime, value)
     );
   }
 
@@ -145,12 +138,14 @@ private:
     typename = std::enable_if_t<is_jsi_type_converter_defined<T>>
   >
   void defineProperty(jni::alias_ref<jstring> name, T value, int options) {
-    jsi::Runtime &jsRuntime = runtimeHolder.getJSRuntime();
+    auto runtime = runtimeHolder.lock();
+    assert((runtime != nullptr) && "JS Runtime was used after deallocation");
+    auto &rawRuntime = runtime->get();
 
     auto cName = name->toStdString();
-    jsi::Object descriptor = preparePropertyDescriptor(jsRuntime, options);
-    descriptor.setProperty(jsRuntime, "value", jsi_type_converter<T>::convert(jsRuntime, value));
-    common::defineProperty(jsRuntime, jsObject.get(), cName.c_str(), std::move(descriptor));
+    jsi::Object descriptor = preparePropertyDescriptor(rawRuntime, options);
+    descriptor.setProperty(rawRuntime, "value", jsi_type_converter<T>::convert(rawRuntime, value));
+    common::defineProperty(rawRuntime, jsObject.get(), cName.c_str(), std::move(descriptor));
   }
 };
 } // namespace expo

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);
+) : runtime(runtime), jsInvoker(std::move(jsInvoker)) {
 }
 
 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/JavaScriptTypedArray.cpp

@@ -5,24 +5,17 @@
 
 namespace expo {
 
-JavaScriptTypedArray::JavaScriptTypedArray(
-  WeakRuntimeHolder runtime,
-  std::shared_ptr<jsi::Object> jsObject
-) : jni::HybridClass<JavaScriptTypedArray, JavaScriptObject>(std::move(runtime),
-                                                             std::move(jsObject)) {
-  jsi::Runtime &jsRuntime = runtimeHolder.getJSRuntime();
-  typedArrayWrapper = std::make_shared<expo::TypedArray>(jsRuntime, *get());
-  rawPointer = static_cast<char *>(typedArrayWrapper->getRawPointer(jsRuntime));
-}
-
 JavaScriptTypedArray::JavaScriptTypedArray(
   std::weak_ptr<JavaScriptRuntime> runtime,
   std::shared_ptr<jsi::Object> jsObject
 ) : jni::HybridClass<JavaScriptTypedArray, JavaScriptObject>(std::move(runtime),
                                                              std::move(jsObject)) {
-  jsi::Runtime &jsRuntime = runtimeHolder.getJSRuntime();
-  typedArrayWrapper = std::make_shared<expo::TypedArray>(jsRuntime, *get());
-  rawPointer = static_cast<char *>(typedArrayWrapper->getRawPointer(jsRuntime));
+  auto jsRuntime = runtimeHolder.lock();
+  assert((jsRuntime != nullptr) && "JS Runtime was used after deallocation");
+  auto &rawRuntime = jsRuntime->get();
+
+  typedArrayWrapper = std::make_shared<expo::TypedArray>(rawRuntime, *JavaScriptObject::get());
+  rawPointer = static_cast<char *>(typedArrayWrapper->getRawPointer(rawRuntime));
 }
 
 void JavaScriptTypedArray::registerNatives() {
@@ -49,17 +42,22 @@ void JavaScriptTypedArray::registerNatives() {
 }
 
 int JavaScriptTypedArray::getRawKind() {
-  jsi::Runtime &jsRuntime = runtimeHolder.getJSRuntime();
-  return (int) typedArrayWrapper->getKind(jsRuntime);
+  auto runtime = runtimeHolder.lock();
+  assert((runtime != nullptr) && "JS Runtime was used after deallocation");
+  auto &rawRuntime = runtime->get();
+
+  return (int) typedArrayWrapper->getKind(rawRuntime);
 }
 
 jni::local_ref<jni::JByteBuffer> JavaScriptTypedArray::toDirectBuffer() {
-  jsi::Runtime &jsRuntime = runtimeHolder.getJSRuntime();
+  auto runtime = runtimeHolder.lock();
+  assert((runtime != nullptr) && "JS Runtime was used after deallocation");
+  auto &rawRuntime = runtime->get();
 
-  auto byteLength = typedArrayWrapper->byteLength(jsRuntime);
+  auto byteLength = typedArrayWrapper->byteLength(rawRuntime);
 
   auto byteBuffer = jni::JByteBuffer::wrapBytes(
-    static_cast<uint8_t *>(typedArrayWrapper->getRawPointer(jsRuntime)),
+    static_cast<uint8_t *>(typedArrayWrapper->getRawPointer(rawRuntime)),
     byteLength
   );