expo-modules-core 55.0.2 → 55.0.3

package/CHANGELOG.md

@@ -10,6 +10,12 @@
 
 ### 💡 Others
 
+## 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.3'
 
 def isExpoModulesCoreTests = {
   Gradle gradle = getGradle()
@@ -96,7 +96,7 @@ android {
   defaultConfig {
     consumerProguardFiles 'proguard-rules.pro'
     versionCode 1
-    versionName "55.0.2"
+    versionName "55.0.3"
     buildConfigField "String", "EXPO_MODULES_CORE_VERSION", "\"${versionName}\""
     buildConfigField "boolean", "IS_NEW_ARCHITECTURE_ENABLED", "true"
 

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/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
   );
 

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

@@ -2,7 +2,6 @@
 
 #include "TypedArray.h"
 #include "JavaScriptObject.h"
-#include "WeakRuntimeHolder.h"
 
 #include <fbjni/fbjni.h>
 #include <fbjni/ByteBuffer.h>
@@ -36,11 +35,6 @@ public:
     std::shared_ptr<jsi::Object> jsObject
   );
 
-  JavaScriptTypedArray(
-    WeakRuntimeHolder runtime,
-    std::shared_ptr<jsi::Object> jsObject
-  );
-
   /**
    * Gets a raw kind of the underlying typed array.
    */

package/android/src/main/cpp/JavaScriptValue.cpp

@@ -39,14 +39,7 @@ JavaScriptValue::JavaScriptValue(
   std::weak_ptr<JavaScriptRuntime> runtime,
   std::shared_ptr<jsi::Value> jsValue
 ) : runtimeHolder(std::move(runtime)), jsValue(std::move(jsValue)) {
-  runtimeHolder.ensureRuntimeIsValid();
-}
-
-JavaScriptValue::JavaScriptValue(
-  WeakRuntimeHolder runtime,
-  std::shared_ptr<jsi::Value> jsValue
-) : runtimeHolder(std::move(runtime)), jsValue(std::move(jsValue)) {
-  runtimeHolder.ensureRuntimeIsValid();
+  assert((!runtimeHolder.expired()) && "JS Runtime was used after deallocation");
 }
 
 std::shared_ptr<jsi::Value> JavaScriptValue::get() {
@@ -113,8 +106,11 @@ bool JavaScriptValue::isSymbol() {
 
 bool JavaScriptValue::isFunction() {
   if (jsValue->isObject()) {
-    auto &jsRuntime = runtimeHolder.getJSRuntime();
-    return jsValue->asObject(jsRuntime).isFunction(jsRuntime);
+    auto runtime = runtimeHolder.lock();
+    assert((runtime != nullptr) && "JS Runtime was used after deallocation");
+    auto &rawRuntime = runtime->get();
+
+    return jsValue->asObject(rawRuntime).isFunction(rawRuntime);
   }
 
   return false;
@@ -122,8 +118,11 @@ bool JavaScriptValue::isFunction() {
 
 bool JavaScriptValue::isArray() {
   if (jsValue->isObject()) {
-    auto &jsRuntime = runtimeHolder.getJSRuntime();
-    return jsValue->asObject(jsRuntime).isArray(jsRuntime);
+    auto runtime = runtimeHolder.lock();
+    assert((runtime != nullptr) && "JS Runtime was used after deallocation");
+    auto &rawRuntime = runtime->get();
+
+    return jsValue->asObject(rawRuntime).isArray(rawRuntime);
   }
 
   return false;
@@ -135,8 +134,11 @@ bool JavaScriptValue::isObject() {
 
 bool JavaScriptValue::isTypedArray() {
   if (jsValue->isObject()) {
-    jsi::Runtime &jsRuntime = runtimeHolder.getJSRuntime();
-    return expo::isTypedArray(jsRuntime, jsValue->getObject(jsRuntime));
+    auto runtime = runtimeHolder.lock();
+    assert((runtime != nullptr) && "JS Runtime was used after deallocation");
+    auto &rawRuntime = runtime->get();
+
+    return expo::isTypedArray(rawRuntime, jsValue->getObject(rawRuntime));
   }
   return false;
 }
@@ -150,46 +152,57 @@ double JavaScriptValue::getDouble() {
 }
 
 std::string JavaScriptValue::getString() {
-  auto &jsRuntime = runtimeHolder.getJSRuntime();
-  return jsValue->getString(jsRuntime).utf8(jsRuntime);
+  auto runtime = runtimeHolder.lock();
+  assert((runtime != nullptr) && "JS Runtime was used after deallocation");
+  auto &rawRuntime = runtime->get();
+
+  return jsValue->getString(rawRuntime).utf8(rawRuntime);
 }
 
 jni::local_ref<JavaScriptObject::javaobject> JavaScriptValue::getObject() {
-  auto &jsRuntime = runtimeHolder.getJSRuntime();
-  auto jsObject = std::make_shared<jsi::Object>(jsValue->getObject(jsRuntime));
+  auto runtime = runtimeHolder.lock();
+  assert((runtime != nullptr) && "JS Runtime was used after deallocation");
+  auto &rawRuntime = runtime->get();
+
+  auto jsObject = std::make_shared<jsi::Object>(jsValue->getObject(rawRuntime));
   return JavaScriptObject::newInstance(
-    runtimeHolder.getJSIContext(),
+    expo::getJSIContext(rawRuntime),
     runtimeHolder,
     jsObject
   );
 }
 
 jni::local_ref<JavaScriptFunction::javaobject> JavaScriptValue::jniGetFunction() {
-  auto &jsRuntime = runtimeHolder.getJSRuntime();
+  auto runtime = runtimeHolder.lock();
+  assert((runtime != nullptr) && "JS Runtime was used after deallocation");
+  auto &rawRuntime = runtime->get();
+
   auto jsFunction = std::make_shared<jsi::Function>(
-    jsValue->getObject(jsRuntime).asFunction(jsRuntime));
+    jsValue->getObject(rawRuntime).asFunction(rawRuntime));
   return JavaScriptFunction::newInstance(
-    runtimeHolder.getJSIContext(),
+    expo::getJSIContext(rawRuntime),
     runtimeHolder,
     jsFunction
   );
 }
 
 jni::local_ref<jni::JArrayClass<JavaScriptValue::javaobject>> JavaScriptValue::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 = jsValue
-    ->getObject(jsRuntime)
-    .asArray(jsRuntime);
-  size_t size = jsArray.size(jsRuntime);
+    ->getObject(rawRuntime)
+    .asArray(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());
@@ -208,10 +221,13 @@ jni::local_ref<jstring> JavaScriptValue::jniGetString() {
 }
 
 jni::local_ref<JavaScriptTypedArray::javaobject> JavaScriptValue::getTypedArray() {
-  auto &jsRuntime = runtimeHolder.getJSRuntime();
-  auto jsObject = std::make_shared<jsi::Object>(jsValue->getObject(jsRuntime));
+  auto runtime = runtimeHolder.lock();
+  assert((runtime != nullptr) && "JS Runtime was used after deallocation");
+  auto &rawRuntime = runtime->get();
+
+  auto jsObject = std::make_shared<jsi::Object>(jsValue->getObject(rawRuntime));
   return JavaScriptTypedArray::newInstance(
-    runtimeHolder.getJSIContext(),
+    expo::getJSIContext(rawRuntime),
     runtimeHolder,
     jsObject
   );

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

@@ -3,7 +3,6 @@
 #pragma once
 
 #include "JSIObjectWrapper.h"
-#include "WeakRuntimeHolder.h"
 #include "JavaScriptTypedArray.h"
 #include "JavaScriptArrayBuffer.h"
 #include "JNIDeallocator.h"
@@ -49,11 +48,6 @@ public:
     std::shared_ptr<jsi::Value> jsValue
   );
 
-  JavaScriptValue(
-    WeakRuntimeHolder runtime,
-    std::shared_ptr<jsi::Value> jsValue
-  );
-
   std::shared_ptr<jsi::Value> get() override;
 
   std::string kind();
@@ -95,7 +89,7 @@ public:
 private:
   friend HybridBase;
 
-  WeakRuntimeHolder runtimeHolder;
+  std::weak_ptr<JavaScriptRuntime> runtimeHolder;
   std::shared_ptr<jsi::Value> jsValue;
 
   jni::local_ref<jstring> jniKind();

package/android/src/main/cpp/JavaScriptWeakObject.cpp

@@ -7,8 +7,8 @@ namespace expo {
 
 void JavaScriptWeakObject::registerNatives() {
   registerHybrid({
-      makeNativeMethod("lock", JavaScriptWeakObject::lock),
-  });
+                   makeNativeMethod("lock", JavaScriptWeakObject::lock),
+                 });
 }
 
 std::shared_ptr<jsi::WeakObject> JavaScriptWeakObject::getWeak() {
@@ -16,26 +16,30 @@ std::shared_ptr<jsi::WeakObject> JavaScriptWeakObject::getWeak() {
 }
 
 jni::local_ref<JavaScriptObject::javaobject> JavaScriptWeakObject::lock() {
-  jsi::Runtime &rt = _runtimeHolder.getJSRuntime();
+  auto jsRuntime = _runtimeHolder.lock();
+  assert((jsRuntime != nullptr) && "JS Runtime was used after deallocation");
+  auto &rawRuntime = jsRuntime->get();
 
-  jsi::Value value = _weakObject->lock(rt);
+  jsi::Value value = _weakObject->lock(rawRuntime);
   if (value.isUndefined()) {
     return nullptr;
   }
   std::shared_ptr<jsi::Object> objectPtr =
-      std::make_shared<jsi::Object>(value.asObject(rt));
+    std::make_shared<jsi::Object>(value.asObject(rawRuntime));
   if (!objectPtr) {
     return nullptr;
   }
-  return JavaScriptObject::newInstance(_runtimeHolder.getJSIContext(),
-                                       _runtimeHolder, objectPtr);
+  return JavaScriptObject::newInstance(
+    expo::getJSIContext(rawRuntime),
+    _runtimeHolder, objectPtr
+  );
 }
 
 jni::local_ref<jni::HybridClass<JavaScriptWeakObject, Destructible>::javaobject>
 JavaScriptWeakObject::newInstance(
-    JSIContext *jSIContext,
-    std::weak_ptr<JavaScriptRuntime> runtime,
-    std::shared_ptr<jsi::Object> jsObject) {
+  JSIContext *jSIContext,
+  std::weak_ptr<JavaScriptRuntime> runtime,
+  std::shared_ptr<jsi::Object> jsObject) {
   auto weakObject = JavaScriptWeakObject::newObjectCxxArgs(std::move(runtime),
                                                            std::move(jsObject));
   jSIContext->jniDeallocator->addReference(weakObject);
@@ -43,12 +47,14 @@ JavaScriptWeakObject::newInstance(
 }
 
 JavaScriptWeakObject::JavaScriptWeakObject(
-    WeakRuntimeHolder runtime,
-    const std::shared_ptr<jsi::Object>& jsObject
+  const std::weak_ptr<JavaScriptRuntime> &runtime,
+  const std::shared_ptr<jsi::Object> &jsObject
 ) : _runtimeHolder(std::move(runtime)) {
-  _runtimeHolder.ensureRuntimeIsValid();
-  jsi::Runtime &rt = _runtimeHolder.getJSRuntime();
-  _weakObject = std::make_shared<jsi::WeakObject>(rt, *jsObject);
+  auto jsRuntime = _runtimeHolder.lock();
+  assert((jsRuntime != nullptr) && "JS Runtime was used after deallocation");
+  auto &rawRuntime = jsRuntime->get();
+
+  _weakObject = std::make_shared<jsi::WeakObject>(rawRuntime, *jsObject);
 }
 
 } // namespace expo

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

@@ -4,7 +4,6 @@
 
 #include "JNIDeallocator.h"
 #include "JavaScriptObject.h"
-#include "WeakRuntimeHolder.h"
 
 #include <fbjni/fbjni.h>
 #include <jsi/jsi.h>
@@ -22,32 +21,36 @@ class JavaScriptObject;
  * Represents to a jsi::WeakObject.
  */
 class JavaScriptWeakObject
-    : public jni::HybridClass<JavaScriptWeakObject, Destructible> {
+  : public jni::HybridClass<JavaScriptWeakObject, Destructible> {
 public:
   static auto constexpr kJavaDescriptor =
-      "Lexpo/modules/kotlin/jni/JavaScriptWeakObject;";
+    "Lexpo/modules/kotlin/jni/JavaScriptWeakObject;";
   static auto constexpr TAG = "JavaScriptWeakObject";
 
   static void registerNatives();
 
   static jni::local_ref<
-      jni::HybridClass<JavaScriptWeakObject, Destructible>::javaobject>
-  newInstance(JSIContext *jSIContext,
-              std::weak_ptr<JavaScriptRuntime> runtime,
-              std::shared_ptr<jsi::Object> jsObject);
+    jni::HybridClass<JavaScriptWeakObject, Destructible>::javaobject
+  > newInstance(
+    JSIContext *jSIContext,
+    std::weak_ptr<JavaScriptRuntime> runtime,
+    std::shared_ptr<jsi::Object> jsObject
+  );
 
   jni::local_ref<JavaScriptObject::javaobject> lock();
 
   std::shared_ptr<jsi::WeakObject> getWeak();
 
 private:
-  JavaScriptWeakObject(WeakRuntimeHolder runtime,
-                       const std::shared_ptr<jsi::Object>& jsObject);
+  JavaScriptWeakObject(
+    const std::weak_ptr<JavaScriptRuntime> &runtime,
+    const std::shared_ptr<jsi::Object> &jsObject
+  );
 
 private:
   friend HybridBase;
 
-  WeakRuntimeHolder _runtimeHolder;
+  std::weak_ptr<JavaScriptRuntime> _runtimeHolder;
   std::shared_ptr<jsi::WeakObject> _weakObject;
 };
 

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

@@ -1,13 +1,13 @@
 package expo.modules.kotlin.jni
 
+import com.facebook.jni.HybridData
 import expo.modules.core.interfaces.DoNotStrip
 import java.lang.ref.PhantomReference
 import java.lang.ref.ReferenceQueue
-import java.lang.ref.WeakReference
 
 @DoNotStrip
 interface Destructible {
-  fun deallocate()
+  fun getHybridDataForJNIDeallocator(): HybridData
 }
 
 @DoNotStrip
@@ -24,7 +24,7 @@ class JNIDeallocator(shouldCreateDestructorThread: Boolean = true) : AutoCloseab
   /**
    * A registry to keep all active [Destructible] objects and their [PhantomReference]s
    */
-  private val destructorMap = mutableMapOf<PhantomReference<Destructible>, WeakReference<Destructible>>()
+  private val destructorMap = mutableMapOf<PhantomReference<Destructible>, HybridData>()
 
   /**
    * A thread that clears your registry when an object has been garbage collected
@@ -43,9 +43,8 @@ class JNIDeallocator(shouldCreateDestructorThread: Boolean = true) : AutoCloseab
    */
   @DoNotStrip
   fun addReference(destructible: Destructible): Unit = synchronized(this) {
-    val weakRef = WeakReference(destructible)
     val phantomRef = PhantomReference(destructible, referenceQueue)
-    destructorMap[phantomRef] = weakRef
+    destructorMap[phantomRef] = destructible.getHybridDataForJNIDeallocator()
   }
 
   /**
@@ -53,7 +52,7 @@ class JNIDeallocator(shouldCreateDestructorThread: Boolean = true) : AutoCloseab
    */
   internal fun deallocate() = synchronized(this) {
     destructorMap.values.forEach {
-      it.get()?.deallocate()
+      it.resetNative()
     }
     destructorMap.clear()
     destructorThread?.interrupt()
@@ -64,15 +63,17 @@ class JNIDeallocator(shouldCreateDestructorThread: Boolean = true) : AutoCloseab
    * and are present in the memory.
    */
   fun inspectMemory() = synchronized(this) {
-    destructorMap.values.mapNotNull { it.get() }
+    destructorMap
+      .values
+      .filter { synchronized(it) { it.isValid } }
+      .map { it }
   }
 
   private fun Thread.deallocator() {
     while (!isInterrupted) {
       try {
-        // Referent of PhantomReference were garbage collected so we can remove it from our registry.
-        // Note that we don't have to call `deallocate` method - it was called [com.facebook.jni.HybridData].
         val current = referenceQueue.remove()
+        destructorMap[current]?.resetNative()
         synchronized(this@JNIDeallocator) {
           destructorMap.remove(current)
         }

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

@@ -124,14 +124,14 @@ class JSIContext @DoNotStrip internal constructor(
 
   @Throws(Throwable::class)
   protected fun finalize() {
-    deallocate()
+    close()
   }
 
-  override fun deallocate() {
+  override fun close() {
     mHybridData.resetNative()
   }
 
-  override fun close() {
-    deallocate()
+  override fun getHybridDataForJNIDeallocator(): HybridData {
+    return mHybridData
   }
 }

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

@@ -115,10 +115,10 @@ class JavaCallback @DoNotStrip internal constructor(@DoNotStrip private val mHyb
 
   @Throws(Throwable::class)
   protected fun finalize() {
-    deallocate()
+    mHybridData.resetNative()
   }
 
-  override fun deallocate() {
-    mHybridData.resetNative()
+  override fun getHybridDataForJNIDeallocator(): HybridData {
+    return mHybridData
   }
 }

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

@@ -26,10 +26,10 @@ class JavaScriptArrayBuffer @DoNotStrip private constructor(@DoNotStrip private
 
   @Throws(Throwable::class)
   protected fun finalize() {
-    deallocate()
+    mHybridData.resetNative()
   }
 
-  override fun deallocate() {
-    mHybridData.resetNative()
+  override fun getHybridDataForJNIDeallocator(): HybridData {
+    return mHybridData
   }
 }

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

@@ -42,10 +42,10 @@ class JavaScriptFunction<ReturnType : Any?> @DoNotStrip private constructor(@DoN
 
   @Throws(Throwable::class)
   protected fun finalize() {
-    deallocate()
+    mHybridData.resetNative()
   }
 
-  override fun deallocate() {
-    mHybridData.resetNative()
+  override fun getHybridDataForJNIDeallocator(): HybridData {
+    return mHybridData
   }
 }

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

@@ -34,14 +34,14 @@ class JavaScriptModuleObject(
 
   @Throws(Throwable::class)
   protected fun finalize() {
-    deallocate()
-  }
-
-  override fun deallocate() {
     mHybridData.resetNative()
   }
 
   override fun toString(): String {
     return "JavaScriptModuleObject_$name"
   }
+
+  override fun getHybridDataForJNIDeallocator(): HybridData {
+    return mHybridData
+  }
 }

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

@@ -144,11 +144,11 @@ open class JavaScriptObject @DoNotStrip internal constructor(@DoNotStrip private
 
   @Throws(Throwable::class)
   protected fun finalize() {
-    deallocate()
+    mHybridData.resetNative()
   }
 
-  override fun deallocate() {
-    mHybridData.resetNative()
+  override fun getHybridDataForJNIDeallocator(): HybridData {
+    return mHybridData
   }
 }
 

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

@@ -56,10 +56,10 @@ class JavaScriptValue @DoNotStrip private constructor(@DoNotStrip private val mH
 
   @Throws(Throwable::class)
   protected fun finalize() {
-    deallocate()
+    mHybridData.resetNative()
   }
 
-  override fun deallocate() {
-    mHybridData.resetNative()
+  override fun getHybridDataForJNIDeallocator(): HybridData {
+    return mHybridData
   }
 }

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

@@ -12,11 +12,12 @@ import expo.modules.core.interfaces.DoNotStrip
 class JavaScriptWeakObject @DoNotStrip internal constructor(@DoNotStrip private val mHybridData: HybridData) : Destructible {
   @Throws(Throwable::class)
   protected fun finalize() {
-    deallocate()
+    mHybridData.resetNative()
   }
 
-  override fun deallocate() {
-    mHybridData.resetNative()
+  override fun getHybridDataForJNIDeallocator(): HybridData {
+    return mHybridData
   }
+
   external fun lock(): JavaScriptObject
 }

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

@@ -44,11 +44,11 @@ class NativeArrayBuffer : Destructible, ArrayBuffer {
 
   @Throws(Throwable::class)
   protected fun finalize() {
-    deallocate()
+    mHybridData.resetNative()
   }
 
-  override fun deallocate() {
-    mHybridData.resetNative()
+  override fun getHybridDataForJNIDeallocator(): HybridData {
+    return mHybridData
   }
 
   companion object {

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

@@ -98,13 +98,13 @@ class JSDecoratorsBridgingObject(jniDeallocator: JNIDeallocator) : Destructible
     )
   }
 
-  override fun deallocate() {
+  @Throws(Throwable::class)
+  protected fun finalize() {
     mHybridData.resetNative()
   }
 
-  @Throws(Throwable::class)
-  protected fun finalize() {
-    deallocate()
+  override fun getHybridDataForJNIDeallocator(): HybridData {
+    return mHybridData
   }
 
   fun ObjectDefinitionData.exportConstants() {

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

@@ -36,10 +36,10 @@ class Serializable @DoNotStrip private constructor(
 
   @Throws(Throwable::class)
   protected fun finalize() {
-    deallocate()
+    mHybridData.resetNative()
   }
 
-  override fun deallocate() {
-    mHybridData.resetNative()
+  override fun getHybridDataForJNIDeallocator(): HybridData {
+    return mHybridData
   }
 }

package/package.json

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

package/android/src/main/cpp/WeakRuntimeHolder.cpp

@@ -1,24 +0,0 @@
-#include "WeakRuntimeHolder.h"
-#include "JavaScriptRuntime.h"
-#include "JSIContext.h"
-
-namespace expo {
-WeakRuntimeHolder::WeakRuntimeHolder(std::weak_ptr<JavaScriptRuntime> runtime)
-  : std::weak_ptr<JavaScriptRuntime>(std::move(runtime)) {}
-
-jsi::Runtime &WeakRuntimeHolder::getJSRuntime() const {
-  auto runtime = lock();
-  assert((runtime != nullptr) && "JS Runtime was used after deallocation");
-  return runtime->get();
-}
-
-void WeakRuntimeHolder::ensureRuntimeIsValid() {
-  assert((!expired()) && "JS Runtime was used after deallocation");
-}
-
-JSIContext *WeakRuntimeHolder::getJSIContext() {
-  auto runtime = lock();
-  assert((runtime != nullptr) && "JS Runtime was used after deallocation");
-  return expo::getJSIContext(runtime->get());
-}
-} // namespace expo

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

@@ -1,40 +0,0 @@
-// Copyright © 2021-present 650 Industries, Inc. (aka Expo)
-
-#pragma once
-
-#include <jsi/jsi.h>
-
-#include <memory>
-
-namespace jsi = facebook::jsi;
-
-namespace expo {
-
-class JavaScriptRuntime;
-
-class JSIContext;
-
-/**
- * A convenient class to access underlying jni::Runtime and hold a weak reference to expo::JavaScriptRuntime.
- * It's working like std::weak_ptr but can have more helper methods.
- */
-class WeakRuntimeHolder : public std::weak_ptr<JavaScriptRuntime> {
-public:
-  WeakRuntimeHolder() = default;
-
-  WeakRuntimeHolder(WeakRuntimeHolder const &) = default;
-
-  WeakRuntimeHolder(WeakRuntimeHolder &&) = default;
-
-  WeakRuntimeHolder(std::weak_ptr<JavaScriptRuntime> runtime);
-
-  /**
-   * @return an reference to the jsi::Runtime.
-   */
-  jsi::Runtime &getJSRuntime() const;
-
-  JSIContext *getJSIContext();
-
-  void ensureRuntimeIsValid();
-};
-} // namespace expo