@@ -35,6 +35,33 @@
 
 namespace facebook::react {
 
+namespace {
+
+std::shared_ptr<const MountingCoordinator> getRunningMountingCoordinator(
+    const std::variant<
+        SurfaceHandler,
+        jni::weak_ref<SurfaceHandlerBinding::jhybridobject>>& registryEntry) {
+  const auto* surfaceHandler = std::get_if<SurfaceHandler>(&registryEntry);
+  jni::local_ref<SurfaceHandlerBinding::jhybridobject> javaSurfaceHandler;
+  if (surfaceHandler == nullptr) {
+    javaSurfaceHandler =
+        std::get<jni::weak_ref<SurfaceHandlerBinding::jhybridobject>>(
+            registryEntry)
+            .lockLocal();
+    if (!javaSurfaceHandler) {
+      return nullptr;
+    }
+    surfaceHandler = &javaSurfaceHandler->cthis()->getSurfaceHandler();
+  }
+  // Callers hold the registry lock, and a surface leaves it before it stops.
+  if (surfaceHandler->getStatus() != SurfaceHandler::Status::Running) {
+    return nullptr;
+  }
+  return surfaceHandler->getMountingCoordinator();
+}
+
+} // namespace
+
 void FabricUIManagerBinding::initHybrid(jni::alias_ref<jhybridobject> jobj) {
   setCxxInstance(jobj);
 }
@@ -89,22 +116,10 @@ void FabricUIManagerBinding::reportMount(SurfaceId surfaceId) {
     std::shared_lock lock(surfaceHandlerRegistryMutex_);
     auto iterator = surfaceHandlerRegistry_.find(surfaceId);
     if (iterator != surfaceHandlerRegistry_.end()) {
-      const auto* surfaceHandler =
-          std::get_if<SurfaceHandler>(&iterator->second);
-      if (surfaceHandler == nullptr) {
-        auto javaSurfaceHandler =
-            std::get<jni::weak_ref<SurfaceHandlerBinding::jhybridobject>>(
-                iterator->second)
-                .lockLocal();
-        if (javaSurfaceHandler) {
-          surfaceHandler = &javaSurfaceHandler->cthis()->getSurfaceHandler();
-        }
-      }
-      if (surfaceHandler != nullptr) {
-        auto mountingCoordinator = surfaceHandler->getMountingCoordinator();
-        if (mountingCoordinator != nullptr) {
-          mountingCoordinator->didPerformAsyncTransactions();
-        }
+      auto mountingCoordinator =
+          getRunningMountingCoordinator(iterator->second);
+      if (mountingCoordinator != nullptr) {
+        mountingCoordinator->didPerformAsyncTransactions();
       }
     } else {
       LOG(ERROR) << "FabricUIManagerBinding::reportMount: Surface with id "
@@ -130,20 +145,7 @@ void FabricUIManagerBinding::pullAndExecuteTransaction(SurfaceId surfaceId) {
     if (iterator == surfaceHandlerRegistry_.end()) {
       return;
     }
-    const auto* surfaceHandler = std::get_if<SurfaceHandler>(&iterator->second);
-    jni::local_ref<SurfaceHandlerBinding::jhybridobject> javaSurfaceHandler;
-    if (surfaceHandler == nullptr) {
-      javaSurfaceHandler =
-          std::get<jni::weak_ref<SurfaceHandlerBinding::jhybridobject>>(
-              iterator->second)
-              .lockLocal();
-      if (javaSurfaceHandler) {
-        surfaceHandler = &javaSurfaceHandler->cthis()->getSurfaceHandler();
-      }
-    }
-    if (surfaceHandler != nullptr) {
-      mountingCoordinator = surfaceHandler->getMountingCoordinator();
-    }
+    mountingCoordinator = getRunningMountingCoordinator(iterator->second);
   }
 
   if (mountingCoordinator == nullptr) {
@@ -169,6 +171,11 @@ void FabricUIManagerBinding::pullAndExecuteTransaction(SurfaceId surfaceId) {
   }
 }
 
+bool FabricUIManagerBinding::isSurfaceRegistered(SurfaceId surfaceId) {
+  std::shared_lock lock(surfaceHandlerRegistryMutex_);
+  return surfaceHandlerRegistry_.contains(surfaceId);
+}
+
 #pragma mark - Surface management
 
 // Used by bridgeless
@@ -195,6 +202,13 @@ void FabricUIManagerBinding::startSurfaceWithSurfaceHandler(
         << "FabricUIManagerBinding::startSurfaceWithSurfaceHandler: scheduler disappeared";
     return;
   }
+
+  {
+    std::unique_lock lock(surfaceHandlerRegistryMutex_);
+    surfaceHandlerRegistry_.emplace(
+        surfaceId, jni::make_weak(surfaceHandlerBinding));
+  }
+
   scheduler->registerSurface(surfaceHandler);
 
   auto mountingManager = getMountingManager("startSurfaceWithSurfaceHandler");
@@ -208,12 +222,6 @@ void FabricUIManagerBinding::startSurfaceWithSurfaceHandler(
     surfaceHandler.getMountingCoordinator()->setMountingOverrideDelegate(
         animationDriver_);
   }
-
-  {
-    std::unique_lock lock(surfaceHandlerRegistryMutex_);
-    surfaceHandlerRegistry_.emplace(
-        surfaceId, jni::make_weak(surfaceHandlerBinding));
-  }
 }
 
 // Used by non-bridgeless+Fabric
@@ -459,23 +467,25 @@ void FabricUIManagerBinding::stopSurface(jint surfaceId) {
     return;
   }
 
+  // The surface leaves the registry before it stops: the stop commit reads the
+  // registry on this thread.
+  decltype(surfaceHandlerRegistry_)::node_type registryEntry;
   {
     std::unique_lock lock(surfaceHandlerRegistryMutex_);
-    auto iterator = surfaceHandlerRegistry_.find(surfaceId);
-    if (iterator == surfaceHandlerRegistry_.end()) {
-      LOG(ERROR)
-          << "FabricUIManagerBinding::stopSurface: Surface with given id is not found";
-      return;
-    }
+    registryEntry = surfaceHandlerRegistry_.extract(surfaceId);
+  }
+  if (registryEntry.empty()) {
+    LOG(ERROR)
+        << "FabricUIManagerBinding::stopSurface: Surface with given id is not found";
+    return;
+  }
 
-    auto* surfaceHandler = std::get_if<SurfaceHandler>(&iterator->second);
-    if (surfaceHandler != nullptr) {
-      surfaceHandler->stop();
-      scheduler->unregisterSurface(*surfaceHandler);
-    } else {
-      LOG(ERROR) << "Java-owned SurfaceHandler found in stopSurface";
-    }
-    surfaceHandlerRegistry_.erase(iterator);
+  auto* surfaceHandler = std::get_if<SurfaceHandler>(&registryEntry.mapped());
+  if (surfaceHandler != nullptr) {
+    surfaceHandler->stop();
+    scheduler->unregisterSurface(*surfaceHandler);
+  } else {
+    LOG(ERROR) << "Java-owned SurfaceHandler found in stopSurface";
   }
 
   auto mountingManager = getMountingManager("stopSurface");
@@ -727,7 +737,11 @@ void FabricUIManagerBinding::schedulerShouldRenderTransactions(
     }
   }
 
-  if (ReactNativeFeatureFlags::enableMountingCoordinatorPullModelAndroid()) {
+  // The UI thread pulls only a registered surface, so a commit of a surface
+  // outside the registry, such as the commit that stops it, is pulled below,
+  // on the commit thread.
+  if (ReactNativeFeatureFlags::enableMountingCoordinatorPullModelAndroid() &&
+      isSurfaceRegistered(mountingCoordinator->getSurfaceId())) {
     // Pull model: do NOT pull the transaction or build the batch here (on the
     // commit thread). Just notify Java that a transaction is available; the UI
     // thread calls back into `pullAndExecuteTransaction` at its next mount
 
@@ -137,6 +137,8 @@ class FabricUIManagerBinding : public jni::HybridClass<FabricUIManagerBinding>,
 
   void pullAndExecuteTransaction(SurfaceId surfaceId);
 
+  bool isSurfaceRegistered(SurfaceId surfaceId);
+
   jint findNextFocusableElement(jint parentTag, jint focusedTag, jint direction);
 
   jintArray getRelativeAncestorList(jint rootTag, jint childTag);
 
@@ -7,14 +7,56 @@
 
 #include "FabricMountingManagerTestHelper.h"
 
+#include <react/fabric/FabricUIManagerBinding.h>
 #include <react/renderer/animationbackend/AnimatedProps.h>
+#include <react/renderer/componentregistry/ComponentDescriptorProviderRegistry.h>
+#include <react/renderer/components/root/RootShadowNode.h>
 #include <react/renderer/components/view/ViewComponentDescriptor.h>
 #include <react/renderer/components/view/ViewProps.h>
 #include <react/renderer/core/ComponentDescriptor.h>
+#include <react/renderer/mounting/MountingOverrideDelegate.h>
 #include <react/renderer/mounting/ShadowView.h>
+#include <react/renderer/scheduler/Scheduler.h>
+
+#include <thread>
 
 namespace facebook::react {
 
+class FabricMountingManagerTestHelper::DeleteRecorder
+    : public MountingOverrideDelegate {
+ public:
+  bool shouldOverridePullTransaction() const override {
+    return true;
+  }
+
+  std::optional<MountingTransaction> pullTransaction(
+      SurfaceId surfaceId,
+      MountingTransaction::Number number,
+      const TransactionTelemetry& telemetry,
+      ShadowViewMutationList mutations) const override {
+    for (const auto& mutation : mutations) {
+      if (mutation.type == ShadowViewMutation::Delete) {
+        deletedTags.push_back(mutation.oldChildShadowView.tag);
+      }
+    }
+    return MountingTransaction{
+        surfaceId, number, std::move(mutations), telemetry};
+  }
+
+  mutable std::vector<Tag> deletedTags;
+};
+
+namespace {
+
+void runNoJavaScript(std::function<void(jsi::Runtime& runtime)>&& /*unused*/) {}
+
+std::vector<Tag> toTags(jni::alias_ref<jni::JArrayInt> tags) {
+  auto region = tags->getRegion(0, static_cast<jsize>(tags->size()));
+  return {region.get(), region.get() + tags->size()};
+}
+
+} // namespace
+
 FabricMountingManagerTestHelper::FabricMountingManagerTestHelper(
     jni::alias_ref<JFabricUIManager::javaobject> jFabricUIManager)
     : javaUIManager_(jni::make_global(jFabricUIManager)) {
@@ -81,6 +123,109 @@ void FabricMountingManagerTestHelper::synchronouslyUpdateAnimatedProps(
   mountingManager_->synchronouslyUpdateAnimatedProps(updates);
 }
 
+jni::local_ref<JRuntimeExecutor::jhybridobject>
+FabricMountingManagerTestHelper::createRuntimeExecutor() {
+  return JRuntimeExecutor::newObjectCxxArgs(runNoJavaScript);
+}
+
+jni::local_ref<JRuntimeScheduler::jhybridobject>
+FabricMountingManagerTestHelper::createRuntimeScheduler() {
+  runtimeScheduler_ = std::make_shared<RuntimeScheduler>(runNoJavaScript);
+  return JRuntimeScheduler::newObjectCxxArgs(runtimeScheduler_);
+}
+
+void FabricMountingManagerTestHelper::registerViewComponent(
+    ComponentFactory* componentFactory) {
+  componentFactory->buildRegistryFunction =
+      [](const EventDispatcher::Weak& eventDispatcher,
+         const std::shared_ptr<const ContextContainer>& contextContainer) {
+        auto providerRegistry =
+            std::make_shared<ComponentDescriptorProviderRegistry>();
+        providerRegistry->add(
+            concreteComponentDescriptorProvider<ViewComponentDescriptor>());
+        return providerRegistry->createComponentDescriptorRegistry(
+            {.eventDispatcher = eventDispatcher,
+             .contextContainer = contextContainer,
+             .flavor = nullptr});
+      };
+}
+
+void FabricMountingManagerTestHelper::commitViews(
+    jint surfaceId,
+    jni::alias_ref<jni::JArrayInt> tags) {
+  commitViewTags(surfaceId, toTags(tags));
+}
+
+void FabricMountingManagerTestHelper::commitViewsOnSurfaceStart(
+    jni::alias_ref<jni::JArrayInt> tags) {
+  javaUIManager_->getBinding()
+      ->getScheduler()
+      ->getUIManager()
+      ->addOnSurfaceStartCallback(
+          [this, tags = toTags(tags)](const ShadowTree& shadowTree) {
+            std::thread([&] {
+              jni::ThreadScope::WithClassLoader(
+                  [&] { commitViewTags(shadowTree.getSurfaceId(), tags); });
+            }).join();
+          });
+}
+
+void FabricMountingManagerTestHelper::stopSurfaceHandler(
+    jni::alias_ref<SurfaceHandlerBinding::jhybridobject>
+        surfaceHandlerBinding) {
+  surfaceHandlerBinding->cthis()->getSurfaceHandler().stop();
+}
+
+void FabricMountingManagerTestHelper::commitViewTags(
+    SurfaceId surfaceId,
+    const std::vector<Tag>& tags) {
+  auto children =
+      std::make_shared<std::vector<std::shared_ptr<const ShadowNode>>>();
+  for (auto tag : tags) {
+    auto props = std::make_shared<ViewProps>();
+    props->collapsable = false;
+    children->push_back(viewComponentDescriptor_->createShadowNode(
+        {.props = props},
+        viewComponentDescriptor_->createFamily(
+            {.tag = tag, .surfaceId = surfaceId, .instanceHandle = nullptr})));
+  }
+  javaUIManager_->getBinding()
+      ->getScheduler()
+      ->getUIManager()
+      ->getShadowTreeRegistry()
+      .visit(surfaceId, [&](const ShadowTree& shadowTree) {
+        shadowTree.commit(
+            [&](const RootShadowNode& oldRootShadowNode) {
+              return std::make_shared<RootShadowNode>(
+                  oldRootShadowNode,
+                  ShadowNodeFragment{
+                      .props = ShadowNodeFragment::propsPlaceholder(),
+                      .children = children});
+            },
+            {});
+      });
+}
+
+void FabricMountingManagerTestHelper::recordPulledDeletes(jint surfaceId) {
+  deleteRecorder_ = std::make_shared<DeleteRecorder>();
+  javaUIManager_->getBinding()
+      ->getScheduler()
+      ->getUIManager()
+      ->getShadowTreeRegistry()
+      .visit(surfaceId, [&](const ShadowTree& shadowTree) {
+        shadowTree.getMountingCoordinator()->setMountingOverrideDelegate(
+            deleteRecorder_);
+      });
+}
+
+jni::local_ref<jni::JArrayInt>
+FabricMountingManagerTestHelper::pulledDeleteTags() {
+  const auto& tags = deleteRecorder_->deletedTags;
+  auto array = jni::JArrayInt::newArray(tags.size());
+  array->setRegion(0, static_cast<jsize>(tags.size()), tags.data());
+  return array;
+}
+
 void FabricMountingManagerTestHelper::registerNatives() {
   registerHybrid({
       makeNativeMethod(
@@ -99,6 +244,29 @@ void FabricMountingManagerTestHelper::registerNatives() {
       makeNativeMethod(
           "synchronouslyUpdateAnimatedProps",
           FabricMountingManagerTestHelper::synchronouslyUpdateAnimatedProps),
+      makeNativeMethod(
+          "createRuntimeExecutor",
+          FabricMountingManagerTestHelper::createRuntimeExecutor),
+      makeNativeMethod(
+          "createRuntimeScheduler",
+          FabricMountingManagerTestHelper::createRuntimeScheduler),
+      makeNativeMethod(
+          "registerViewComponent",
+          FabricMountingManagerTestHelper::registerViewComponent),
+      makeNativeMethod(
+          "commitViews", FabricMountingManagerTestHelper::commitViews),
+      makeNativeMethod(
+          "commitViewsOnSurfaceStart",
+          FabricMountingManagerTestHelper::commitViewsOnSurfaceStart),
+      makeNativeMethod(
+          "stopSurfaceHandler",
+          FabricMountingManagerTestHelper::stopSurfaceHandler),
+      makeNativeMethod(
+          "recordPulledDeletes",
+          FabricMountingManagerTestHelper::recordPulledDeletes),
+      makeNativeMethod(
+          "pulledDeleteTags",
+          FabricMountingManagerTestHelper::pulledDeleteTags),
   });
 }