fix(🐛): prevent EXC_BAD_ACCESS in Promise destructor after runtime teardown

Replace the memory-leak workaround (heap-leaking JSI Function pointers) with proper lifecycle management via RuntimeLifecycleMonitor. The Promise now registers as a listener and releases its JSI objects in onRuntimeDestroyed while the runtime is still valid.

- Register/unregister with RuntimeLifecycleMonitor in constructor/destructor
- Guard resolve/reject with mutex and runtimeDestroyed_ flag
- Release JSI Functions in onRuntimeDestroyed before the runtime is torn down
- Call removeListener outside the lock to keep locking hierarchy simple
- Add debug-only logging for dropped resolve/reject calls during teardown

Author: tbrushwyler

packages/skia/cpp/jsi/JsiPromises.cpp

@@ -1,16 +1,65 @@
 #include "JsiPromises.h"
 
+#ifndef NDEBUG
+#include "utils/RNSkLog.h"
+#endif
+
 namespace RNJsi {
 
 JsiPromises::Promise::Promise(jsi::Runtime &rt, jsi::Function resolve,
                               jsi::Function reject)
-    : runtime_(rt), resolve_(std::move(resolve)), reject_(std::move(reject)) {}
+    : runtime_(rt), resolve_(std::move(resolve)), reject_(std::move(reject)) {
+  RuntimeLifecycleMonitor::addListener(rt, this);
+}
+
+JsiPromises::Promise::~Promise() {
+  bool shouldRemove = false;
+  {
+    std::lock_guard<std::mutex> lock(mutex_);
+    shouldRemove = !runtimeDestroyed_;
+  }
+  // Call removeListener outside the lock to avoid holding mutex_ across
+  // an external call. This keeps the locking hierarchy simple and avoids
+  // potential issues if RuntimeLifecycleMonitor's internals change.
+  if (shouldRemove) {
+    RuntimeLifecycleMonitor::removeListener(runtime_, this);
+  }
+}
+
+void JsiPromises::Promise::onRuntimeDestroyed(jsi::Runtime *) {
+  std::lock_guard<std::mutex> lock(mutex_);
+  // Release JSI Function objects now while the runtime is still alive
+  // enough to handle invalidation. After a move, the source jsi::Function
+  // is in a valid but empty state, making its eventual destruction in
+  // ~Promise() a safe no-op.
+  runtimeDestroyed_ = true;
+  {
+    jsi::Function r(std::move(resolve_));
+    jsi::Function j(std::move(reject_));
+  }
+}
 
 void JsiPromises::Promise::resolve(const jsi::Value &result) {
+  std::lock_guard<std::mutex> lock(mutex_);
+  if (runtimeDestroyed_) {
+#ifndef NDEBUG
+    RNSkia::RNSkLogger::logToConsole(
+        "Promise::resolve() dropped — runtime already torn down");
+#endif
+    return;
+  }
   resolve_.call(runtime_, result);
 }
 
 void JsiPromises::Promise::reject(const std::string &message) {
+  std::lock_guard<std::mutex> lock(mutex_);
+  if (runtimeDestroyed_) {
+#ifndef NDEBUG
+    RNSkia::RNSkLogger::logToConsole(
+        "Promise::reject() dropped — runtime already torn down");
+#endif
+    return;
+  }
   jsi::Object error(runtime_);
   error.setProperty(runtime_, "message",
                     jsi::String::createFromUtf8(runtime_, message));

packages/skia/cpp/jsi/JsiPromises.h

@@ -1,11 +1,13 @@
 #pragma once
 
 #include <memory>
+#include <mutex>
 #include <string>
 #include <utility>
 
 #include <jsi/jsi.h>
 
+#include "RuntimeLifecycleMonitor.h"
 #include "third_party/base64.h"
 
 namespace RNJsi {
@@ -29,15 +31,20 @@ class LongLivedObject {
 
 class JsiPromises {
 public:
-  struct Promise : public LongLivedObject {
+  struct Promise : public LongLivedObject, public RuntimeLifecycleListener {
     Promise(jsi::Runtime &rt, jsi::Function resolve, jsi::Function reject);
+    ~Promise();
+
+    void onRuntimeDestroyed(jsi::Runtime *) override;
 
     void resolve(const jsi::Value &result);
     void reject(const std::string &error);
 
     jsi::Runtime &runtime_;
+    std::mutex mutex_;
     jsi::Function resolve_;
     jsi::Function reject_;
+    bool runtimeDestroyed_{false};
   };
 
   using PromiseSetupFunctionType =