@@ -19,7 +19,10 @@ namespace facebook::react {
 
 class CallInvoker;
 
-// Helper for passing jsi::Function arg to other methods.
+/**
+ * @deprecated Use LongLivedObjectHandle<jsi::Function> instead.
+ * Access and release this legacy wrapper only on the JavaScript thread.
+ */
 class CallbackWrapper : public LongLivedObject {
  private:
   CallbackWrapper(jsi::Function &&callback, jsi::Runtime &runtime, std::shared_ptr<CallInvoker> jsInvoker)
 
@@ -10,7 +10,7 @@
 #include <react/cxxstableapi/UmbrellaGuard.h>
 
 #include <react/bridging/Base.h>
-#include <react/bridging/CallbackWrapper.h>
+#include <react/bridging/CallbackWrapper.h> // Retain the legacy transitive include.
 
 #include <ReactCommon/CallInvoker.h>
 #include <ReactCommon/SchedulerPriority.h>
@@ -61,16 +61,18 @@ class AsyncCallback {
 
   void callWithArgs(std::optional<SchedulerPriority> priority, Args... args) const noexcept
   {
-    if (auto wrapper = callback_->wrapper_.lock()) {
-      auto fn = [callback = callback_,
+    auto callback = callback_;
+    if (auto jsInvoker = callback->function_.lockInvoker()) {
+      // The queued function owns the tuple; its lifetime is opaque to the analyzer.
+      // NOLINTNEXTLINE(clang-analyzer-cplusplus.NewDeleteLeaks)
+      auto fn = [callback = std::move(callback),
                  argsPtr = std::make_shared<std::tuple<Args...>>(std::make_tuple(std::forward<Args>(args)...))](
-                    jsi::Runtime &) { callback->apply(std::move(*argsPtr)); };
+                    jsi::Runtime &rt) { callback->apply(rt, std::move(*argsPtr)); };
 
-      auto &jsInvoker = wrapper->jsInvoker();
       if (priority) {
-        jsInvoker.invokeAsync(*priority, std::move(fn));
+        jsInvoker->invokeAsync(*priority, std::move(fn));
       } else {
-        jsInvoker.invokeAsync(std::move(fn));
+        jsInvoker->invokeAsync(std::move(fn));
       }
     }
   }
@@ -79,80 +81,77 @@ class AsyncCallback {
       std::optional<SchedulerPriority> priority,
       std::function<void(jsi::Runtime &, jsi::Function &)> &&callImpl) const noexcept
   {
-    if (auto wrapper = callback_->wrapper_.lock()) {
-      // Capture callback_ and not wrapper_. If callback_ is deallocated or the
-      // JSVM is shutdown before the async task is scheduled, the underlying
-      // function will have been deallocated.
-      auto fn = [callback = callback_, callImpl = std::move(callImpl)](jsi::Runtime &rt) {
-        if (auto wrapper2 = callback->wrapper_.lock()) {
-          callImpl(rt, wrapper2->callback());
+    auto callback = callback_;
+    if (auto jsInvoker = callback->function_.lockInvoker()) {
+      // Retain native ownership until this task is destroyed, without retaining
+      // a JavaScript value while the task is queued or discarded.
+      auto fn = [callback = std::move(callback), callImpl = std::move(callImpl)](jsi::Runtime &rt) {
+        if (auto function = callback->function_.lockOnJS(rt)) {
+          callImpl(rt, function->value);
         }
       };
 
-      auto &jsInvoker = wrapper->jsInvoker();
       if (priority) {
-        jsInvoker.invokeAsync(*priority, std::move(fn));
+        jsInvoker->invokeAsync(*priority, std::move(fn));
       } else {
-        jsInvoker.invokeAsync(std::move(fn));
+        jsInvoker->invokeAsync(std::move(fn));
       }
     }
   }
 };
 
-// You must ensure that when invoking this you're located on the JS thread, or
-// have exclusive control of the JS VM context. If you cannot ensure this, use
-// AsyncCallback instead.
+// Invoke only on the JavaScript thread. Use AsyncCallback from other threads.
 template <typename R, typename... Args>
 class SyncCallback<R(Args...)> {
  public:
   SyncCallback(jsi::Runtime &rt, jsi::Function function, std::shared_ptr<CallInvoker> jsInvoker)
-      : wrapper_(CallbackWrapper::createWeak(std::move(function), rt, std::move(jsInvoker)))
+      : runtime_(&rt), function_(rt, std::move(function), std::move(jsInvoker))
   {
   }
 
-  // Disallow copying, as we can no longer safely destroy the callback
-  // from the destructor if there's multiple copies
   SyncCallback(const SyncCallback &) = delete;
   SyncCallback &operator=(const SyncCallback &) = delete;
+  SyncCallback(SyncCallback &&) noexcept = default;
+  SyncCallback &operator=(SyncCallback &&) noexcept = default;
+  ~SyncCallback() = default;
 
-  // Allow move
-  SyncCallback(SyncCallback &&other) noexcept : wrapper_(std::move(other.wrapper_)) {}
-
-  SyncCallback &operator=(SyncCallback &&other) noexcept
+  R operator()(Args... args) const
   {
-    wrapper_ = std::move(other.wrapper_);
-    return *this;
+    return call(std::forward<Args>(args)...);
   }
 
-  ~SyncCallback()
+  R call(Args... args) const
   {
-    if (auto wrapper = wrapper_.lock()) {
-      wrapper->destroy();
+    if (function_.expired()) {
+      return invalidated();
     }
+    return callWithRuntime(*runtime_, std::forward<Args>(args)...);
   }
 
-  R operator()(Args... args) const
+ private:
+  friend AsyncCallback<Args...>;
+  friend Bridging<SyncCallback>;
+
+  static R invalidated()
   {
-    return call(std::forward<Args>(args)...);
+    if constexpr (std::is_void_v<R>) {
+      return;
+    } else {
+      throw std::runtime_error("Failed to call invalidated sync callback");
+    }
   }
 
-  R call(Args... args) const
+  R callWithRuntime(jsi::Runtime &rt, Args... args) const
   {
-    auto wrapper = wrapper_.lock();
-
-    // If the wrapper has been deallocated, we can no longer provide a return
-    // value consistently, so our only option is to throw
-    if (!wrapper) {
-      if constexpr (std::is_void_v<R>) {
-        return;
-      } else {
-        throw std::runtime_error("Failed to call invalidated sync callback");
-      }
+    auto function = function_.lockOnJS(rt);
+    if (!function) {
+      return invalidated();
     }
 
-    auto &callback = wrapper->callback();
-    auto &rt = wrapper->runtime();
-    auto jsInvoker = wrapper->jsInvokerPtr();
+    // JavaScript can destroy this native callback during the call; use only
+    // the retained value and local runtime/invoker references afterward.
+    auto &callback = function->value;
+    auto jsInvoker = function->jsInvoker;
 
     if constexpr (std::is_void_v<R>) {
       callback.call(rt, bridging::toJs(rt, std::forward<Args>(args), jsInvoker)...);
@@ -162,23 +161,21 @@ class SyncCallback<R(Args...)> {
     }
   }
 
- private:
-  friend AsyncCallback<Args...>;
-  friend Bridging<SyncCallback>;
-
-  R apply(std::tuple<Args...> &&args) const
+  R apply(jsi::Runtime &rt, std::tuple<Args...> &&args) const
   {
-    return apply(std::move(args), std::index_sequence_for<Args...>{});
+    return apply(rt, std::move(args), std::index_sequence_for<Args...>{});
   }
 
   template <size_t... Index>
-  R apply(std::tuple<Args...> &&args, std::index_sequence<Index...> /*unused*/) const
+  R apply(jsi::Runtime &rt, std::tuple<Args...> &&args, std::index_sequence<Index...> /*unused*/) const
   {
-    return call(std::move(std::get<Index>(args))...);
+    return callWithRuntime(rt, std::move(std::get<Index>(args))...);
   }
 
-  // Held weakly so lifetime is managed by LongLivedObjectCollection.
-  std::weak_ptr<CallbackWrapper> wrapper_;
+  // Only the legacy synchronous call needs to recover its construction runtime.
+  // Async calls use the runtime supplied by the executor instead.
+  jsi::Runtime *runtime_;
+  LongLivedObjectHandle<jsi::Function> function_;
 };
 
 template <typename... Args>
@@ -191,7 +188,7 @@ struct Bridging<AsyncCallback<Args...>> {
 
   static jsi::Function toJs(jsi::Runtime &rt, const AsyncCallback<Args...> &value)
   {
-    return value.callback_->function_.getFunction(rt);
+    return Bridging<SyncCallback<void(Args...)>>::toJs(rt, *value.callback_);
   }
 };
 
@@ -205,7 +202,10 @@ struct Bridging<SyncCallback<R(Args...)>> {
 
   static jsi::Function toJs(jsi::Runtime &rt, const SyncCallback<R(Args...)> &value)
   {
-    return value.function_.getFunction(rt);
+    if (auto function = value.function_.lockOnJS(rt)) {
+      return function->value.getFunction(rt);
+    }
+    throw jsi::JSError(rt, "Failed to get invalidated callback");
   }
 };
 
 
@@ -6,6 +6,8 @@
  */
 
 #include "LongLivedObject.h"
+
+#include <ReactCommon/CallInvoker.h>
 #include <unordered_map>
 
 namespace facebook::react {
@@ -35,22 +37,31 @@ void LongLivedObjectCollection::add(std::shared_ptr<LongLivedObject> so) {
 }
 
 void LongLivedObjectCollection::remove(const LongLivedObject* o) {
-  std::scoped_lock lock(collectionMutex_);
-  // Empty owner: lookup-only alias, with no ownership or control block.
-  const std::shared_ptr<LongLivedObject> lookupKey{
-      std::shared_ptr<LongLivedObject>{}, const_cast<LongLivedObject*>(o)};
+  decltype(collection_)::node_type retired;
+  {
+    std::scoped_lock lock(collectionMutex_);
+    // Empty owner: lookup-only alias, with no ownership or control block.
+    const std::shared_ptr<LongLivedObject> lookupKey{
+        std::shared_ptr<LongLivedObject>{},
+        // Lookup never dereferences or mutates the object.
+        // NOLINTNEXTLINE(cppcoreguidelines-pro-type-const-cast)
+        const_cast<LongLivedObject*>(o)};
 
-  // A shared_ptr hashes and compares by the pointer it stores, so a
-  // non-owning shared_ptr to `o` finds its entry without walking the set.
-  auto entry = collection_.find(lookupKey);
-  if (entry != collection_.end()) {
-    collection_.erase(entry);
+    // A shared_ptr hashes and compares by the pointer it stores, so a
+    // non-owning shared_ptr to `o` finds its entry without walking the set.
+    auto entry = collection_.find(lookupKey);
+    if (entry != collection_.end()) {
+      retired = collection_.extract(entry);
+    }
   }
 }
 
 void LongLivedObjectCollection::clear() {
-  std::scoped_lock lock(collectionMutex_);
-  collection_.clear();
+  decltype(collection_) retired;
+  {
+    std::scoped_lock lock(collectionMutex_);
+    retired.swap(collection_);
+  }
 }
 
 size_t LongLivedObjectCollection::size() const {
@@ -64,4 +75,22 @@ void LongLivedObject::allowRelease() {
   LongLivedObjectCollection::get(runtime_).remove(this);
 }
 
+void detail::releaseLongLivedObjectOnJS(
+    std::weak_ptr<LongLivedObject> object,
+    std::weak_ptr<CallInvoker> jsInvoker) noexcept {
+  if (object.expired()) {
+    return;
+  }
+  if (auto invoker = jsInvoker.lock()) {
+    invoker->invokeAsync([object = std::move(object)](jsi::Runtime&) {
+      if (auto locked = object.lock()) {
+        locked->allowRelease();
+      }
+    });
+  }
+  // If dispatch is dropped, runtime cleanup releases the collection. Never
+  // fall back to acquiring or releasing a strong reference on the caller
+  // thread.
+}
+
 } // namespace facebook::react