react-native 0.69.0-rc.6 → 0.70.0-rc.0

package/ReactAndroid/src/main/java/com/facebook/react/fabric/mounting/MountItemDispatcher.java

@@ -126,6 +126,8 @@ public class MountItemDispatcher {
       mInDispatch = false;
     }
 
+    // We call didDispatchMountItems regardless of whether we actually dispatched anything, since
+    // NativeAnimatedModule relies on this for executing any animations that may have been scheduled
     mItemDispatchListener.didDispatchMountItems();
 
     // Decide if we want to try reentering
@@ -204,8 +206,7 @@ public class MountItemDispatcher {
     if (viewCommandMountItemsToDispatch != null) {
       Systrace.beginSection(
           Systrace.TRACE_TAG_REACT_JAVA_BRIDGE,
-          "FabricUIManager::mountViews viewCommandMountItems to execute: "
-              + viewCommandMountItemsToDispatch.size());
+          "FabricUIManager::mountViews viewCommandMountItems");
       for (DispatchCommandMountItem command : viewCommandMountItemsToDispatch) {
         if (ENABLE_FABRIC_LOGS) {
           printMountItem(command, "dispatchMountItems: Executing viewCommandMountItem");
@@ -248,9 +249,7 @@ public class MountItemDispatcher {
 
     if (preMountItemsToDispatch != null) {
       Systrace.beginSection(
-          Systrace.TRACE_TAG_REACT_JAVA_BRIDGE,
-          "FabricUIManager::mountViews preMountItems to execute: "
-              + preMountItemsToDispatch.size());
+          Systrace.TRACE_TAG_REACT_JAVA_BRIDGE, "FabricUIManager::mountViews preMountItems");
 
       for (PreAllocateViewMountItem preMountItem : preMountItemsToDispatch) {
         executeOrEnqueue(preMountItem);
@@ -262,7 +261,7 @@ public class MountItemDispatcher {
     if (mountItemsToDispatch != null) {
       Systrace.beginSection(
           Systrace.TRACE_TAG_REACT_JAVA_BRIDGE,
-          "FabricUIManager::mountViews mountItems to execute: " + mountItemsToDispatch.size());
+          "FabricUIManager::mountViews mountItems to execute");
 
       long batchedExecutionStartTime = SystemClock.uptimeMillis();
 
@@ -356,13 +355,16 @@ public class MountItemDispatcher {
   @Nullable
   private static <E extends MountItem> List<E> drainConcurrentItemQueue(
       ConcurrentLinkedQueue<E> queue) {
+    if (queue.isEmpty()) {
+      return null;
+    }
     List<E> result = new ArrayList<>();
-    while (!queue.isEmpty()) {
+    do {
       E item = queue.poll();
       if (item != null) {
         result.add(item);
       }
-    }
+    } while (!queue.isEmpty());
     if (result.size() == 0) {
       return null;
     }

package/ReactAndroid/src/main/java/com/facebook/react/fabric/mounting/MountingManager.java

@@ -26,6 +26,7 @@ import com.facebook.react.bridge.UiThreadUtil;
 import com.facebook.react.common.mapbuffer.MapBuffer;
 import com.facebook.react.fabric.FabricUIManager;
 import com.facebook.react.fabric.events.EventEmitterWrapper;
+import com.facebook.react.fabric.mounting.SurfaceMountingManager.ViewEvent;
 import com.facebook.react.fabric.mounting.mountitems.MountItem;
 import com.facebook.react.touch.JSResponderHandler;
 import com.facebook.react.uimanager.RootViewManager;
@@ -422,4 +423,14 @@ public class MountingManager {
   public void initializeViewManager(String componentName) {
     mViewManagerRegistry.get(componentName);
   }
+
+  public void enqueuePendingEvent(int reactTag, ViewEvent viewEvent) {
+    @Nullable SurfaceMountingManager smm = getSurfaceManagerForView(reactTag);
+    if (smm == null) {
+      // Cannot queue event without valid surface mountng manager. Do nothing here.
+      return;
+    }
+
+    smm.enqueuePendingEvent(reactTag, viewEvent);
+  }
 }

package/ReactAndroid/src/main/java/com/facebook/react/fabric/mounting/SurfaceMountingManager.java

@@ -19,18 +19,22 @@ import androidx.annotation.UiThread;
 import com.facebook.common.logging.FLog;
 import com.facebook.infer.annotation.Assertions;
 import com.facebook.infer.annotation.ThreadConfined;
+import com.facebook.react.bridge.ReactContext;
 import com.facebook.react.bridge.ReactSoftExceptionLogger;
 import com.facebook.react.bridge.ReadableArray;
 import com.facebook.react.bridge.ReadableMap;
 import com.facebook.react.bridge.RetryableMountingLayerException;
 import com.facebook.react.bridge.SoftAssertions;
 import com.facebook.react.bridge.UiThreadUtil;
+import com.facebook.react.bridge.WritableMap;
 import com.facebook.react.common.build.ReactBuildConfig;
 import com.facebook.react.common.mapbuffer.ReadableMapBuffer;
 import com.facebook.react.config.ReactFeatureFlags;
+import com.facebook.react.fabric.GuardedFrameCallback;
 import com.facebook.react.fabric.events.EventEmitterWrapper;
 import com.facebook.react.fabric.mounting.MountingManager.MountItemExecutor;
 import com.facebook.react.fabric.mounting.mountitems.MountItem;
+import com.facebook.react.modules.core.ReactChoreographer;
 import com.facebook.react.touch.JSResponderHandler;
 import com.facebook.react.uimanager.IllegalViewOperationException;
 import com.facebook.react.uimanager.ReactOverflowViewWithInset;
@@ -43,10 +47,14 @@ import com.facebook.react.uimanager.ThemedReactContext;
 import com.facebook.react.uimanager.ViewGroupManager;
 import com.facebook.react.uimanager.ViewManager;
 import com.facebook.react.uimanager.ViewManagerRegistry;
+import com.facebook.react.uimanager.events.EventCategoryDef;
 import com.facebook.react.views.view.ReactMapBufferViewManager;
 import com.facebook.react.views.view.ReactViewManagerWrapper;
 import java.util.HashSet;
+import java.util.LinkedList;
+import java.util.Queue;
 import java.util.Set;
+import java.util.Stack;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.ConcurrentLinkedQueue;
 import javax.annotation.Nullable;
@@ -70,6 +78,18 @@ public class SurfaceMountingManager {
   private RootViewManager mRootViewManager;
   private MountItemExecutor mMountItemExecutor;
 
+  // Stack of deferred-removal tags for Views that can be
+  // removed asynchronously. Guaranteed to be disconnected
+  // from the viewport and these tags will not be reused in the future.
+  @ThreadConfined(UI)
+  private final Stack<Integer> mReactTagsToRemove = new Stack<>();
+
+  @ThreadConfined(UI)
+  private final Set<Integer> mErroneouslyReaddedReactTags = new HashSet<>();
+
+  @ThreadConfined(UI)
+  private RemoveDeleteTreeUIFrameCallback mRemoveDeleteTreeUIFrameCallback;
+
   // This is null *until* StopSurface is called.
   private Set<Integer> mTagSetForStoppedSurface;
 
@@ -300,6 +320,10 @@ public class SurfaceMountingManager {
             mRootViewManager = null;
             mMountItemExecutor = null;
             mOnViewAttachItems.clear();
+
+            if (ReactFeatureFlags.enableViewRecycling) {
+              mViewManagerRegistry.onSurfaceStopped(mSurfaceId);
+            }
           }
         };
 
@@ -357,7 +381,29 @@ public class SurfaceMountingManager {
                   + "]: View already has a parent: ["
                   + actualParentId
                   + "] "
-                  + viewParent.getClass().getSimpleName()));
+                  + " Parent: "
+                  + viewParent.getClass().getSimpleName()
+                  + " View: "
+                  + view.getClass().getSimpleName()));
+
+      // We've hit an error case, and `addView` will crash below
+      // if we don't take evasive action (it is an error to add a View
+      // to the hierarchy if it already has a parent).
+      // We don't know /why/ this happens yet, but it does happen
+      // very infrequently in production.
+      // Thus, we do three things here:
+      // (1) We logged a SoftException above, so if there's a crash later
+      // on, we might have some hints about what caused it.
+      // (2) We remove the View from its parent.
+      // (3) In case the View was removed from the hierarchy with the
+      // RemoveDeleteTree instruction, and is now being readded - which
+      // should be impossible - we mark this as a "readded" View and
+      // thus prevent the RemoveDeleteTree worker from deleting this
+      // View in the future.
+      if (viewParent instanceof ViewGroup) {
+        ((ViewGroup) viewParent).removeView(view);
+      }
+      mErroneouslyReaddedReactTags.add(tag);
     }
 
     try {
@@ -400,6 +446,17 @@ public class SurfaceMountingManager {
       return;
     }
 
+    // This is "impossible". See comments above.
+    if (mErroneouslyReaddedReactTags.contains(tag)) {
+      ReactSoftExceptionLogger.logSoftException(
+          TAG,
+          new IllegalViewOperationException(
+              "removeViewAt tried to remove a React View that was actually reused. This indicates a bug in the Differ (specifically instruction ordering). ["
+                  + tag
+                  + "]"));
+      return;
+    }
+
     UiThreadUtil.assertOnUiThread();
     ViewState parentViewState = getNullableViewState(parentTag);
 
@@ -553,6 +610,189 @@ public class SurfaceMountingManager {
     }
   }
 
+  @UiThread
+  public void removeDeleteTreeAt(final int tag, final int parentTag, int index) {
+    if (isStopped()) {
+      return;
+    }
+
+    UiThreadUtil.assertOnUiThread();
+    ViewState parentViewState = getNullableViewState(parentTag);
+
+    // TODO: throw exception here?
+    if (parentViewState == null) {
+      ReactSoftExceptionLogger.logSoftException(
+          MountingManager.TAG,
+          new IllegalStateException(
+              "Unable to find viewState for tag: [" + parentTag + "] for removeDeleteTreeAt"));
+      return;
+    }
+
+    if (!(parentViewState.mView instanceof ViewGroup)) {
+      String message =
+          "Unable to remove+delete a view from a view that is not a ViewGroup. ParentTag: "
+              + parentTag
+              + " - Tag: "
+              + tag
+              + " - Index: "
+              + index;
+      FLog.e(TAG, message);
+      throw new IllegalStateException(message);
+    }
+
+    final ViewGroup parentView = (ViewGroup) parentViewState.mView;
+
+    if (parentView == null) {
+      throw new IllegalStateException("Unable to find view for tag [" + parentTag + "]");
+    }
+
+    if (SHOW_CHANGED_VIEW_HIERARCHIES) {
+      // Display children before deleting any
+      FLog.e(
+          TAG,
+          "removeDeleteTreeAt: [" + tag + "] -> [" + parentTag + "] idx: " + index + " BEFORE");
+      logViewHierarchy(parentView, false);
+    }
+
+    ViewGroupManager<ViewGroup> viewGroupManager = getViewGroupManager(parentViewState);
+
+    // Verify that the view we're about to remove has the same tag we expect
+    View view = viewGroupManager.getChildAt(parentView, index);
+    int actualTag = (view != null ? view.getId() : -1);
+    if (actualTag != tag) {
+      int tagActualIndex = -1;
+      int parentChildrenCount = parentView.getChildCount();
+      for (int i = 0; i < parentChildrenCount; i++) {
+        if (parentView.getChildAt(i).getId() == tag) {
+          tagActualIndex = i;
+          break;
+        }
+      }
+
+      // TODO T74425739: previously, we did not do this check and `removeViewAt` would be executed
+      // below, sometimes crashing there. *However*, interestingly enough, `removeViewAt` would not
+      // complain if you removed views from an already-empty parent. This seems necessary currently
+      // for certain ViewManagers that remove their own children - like BottomSheet?
+      // This workaround seems not-great, but for now, we just return here for
+      // backwards-compatibility. Essentially, if a view has already been removed from the
+      // hierarchy, we treat it as a noop.
+      if (tagActualIndex == -1) {
+        FLog.e(
+            TAG,
+            "removeDeleteTreeAt: ["
+                + tag
+                + "] -> ["
+                + parentTag
+                + "] @"
+                + index
+                + ": view already removed from parent! Children in parent: "
+                + parentChildrenCount);
+        return;
+      }
+
+      // Here we are guaranteed that the view is still in the View hierarchy, just
+      // at a different index. In debug mode we'll crash here; in production, we'll remove
+      // the child from the parent and move on.
+      // This is an issue that is safely recoverable 95% of the time. If this allows corruption
+      // of the view hierarchy and causes bugs or a crash after this point, there will be logs
+      // indicating that this happened.
+      // This is likely *only* necessary because of Fabric's LayoutAnimations implementation.
+      // If we can fix the bug there, or remove the need for LayoutAnimation index adjustment
+      // entirely, we can just throw this exception without regression user experience.
+      logViewHierarchy(parentView, true);
+      ReactSoftExceptionLogger.logSoftException(
+          TAG,
+          new IllegalStateException(
+              "Tried to remove+delete view ["
+                  + tag
+                  + "] of parent ["
+                  + parentTag
+                  + "] at index "
+                  + index
+                  + ", but got view tag "
+                  + actualTag
+                  + " - actual index of view: "
+                  + tagActualIndex));
+      index = tagActualIndex;
+    }
+
+    try {
+      viewGroupManager.removeViewAt(parentView, index);
+    } catch (RuntimeException e) {
+      // Note: `getChildCount` may not always be accurate!
+      // We don't currently have a good explanation other than, in situations where you
+      // would empirically expect to see childCount > 0, the childCount is reported as 0.
+      // This is likely due to a ViewManager overriding getChildCount or some other methods
+      // in a way that is strictly incorrect, but potentially only visible here.
+      // The failure mode is actually that in `removeViewAt`, a NullPointerException is
+      // thrown when we try to perform an operation on a View that doesn't exist, and
+      // is therefore null.
+      // We try to add some extra diagnostics here, but we always try to remove the View
+      // from the hierarchy first because detecting by looking at childCount will not work.
+      //
+      // Note that the lesson here is that `getChildCount` is not /required/ to adhere to
+      // any invariants. If you add 9 children to a parent, the `getChildCount` of the parent
+      // may not be equal to 9. This apparently causes no issues with Android and is common
+      // enough that we shouldn't try to change this invariant, without a lot of thought.
+      int childCount = viewGroupManager.getChildCount(parentView);
+
+      logViewHierarchy(parentView, true);
+
+      throw new IllegalStateException(
+          "Cannot remove child at index "
+              + index
+              + " from parent ViewGroup ["
+              + parentView.getId()
+              + "], only "
+              + childCount
+              + " children in parent. Warning: childCount may be incorrect!",
+          e);
+    }
+
+    // Display children after deleting any
+    if (SHOW_CHANGED_VIEW_HIERARCHIES) {
+      final int finalIndex = index;
+      UiThreadUtil.runOnUiThread(
+          new Runnable() {
+            @Override
+            public void run() {
+              FLog.e(
+                  TAG,
+                  "removeViewAt: ["
+                      + tag
+                      + "] -> ["
+                      + parentTag
+                      + "] idx: "
+                      + finalIndex
+                      + " AFTER");
+              logViewHierarchy(parentView, false);
+            }
+          });
+    }
+
+    // The View has been removed from the View hierarchy; now it
+    // and all of its children, if any, need to be deleted, recursively.
+    // We want to maintain the legacy ordering: delete (and call onViewStateDeleted)
+    // for leaf nodes, and then parents, recursively.
+    // Schedule the Runnable first, to detect if we need to schedule a Runnable at all.
+    // Since this current function and the Runnable both run on the UI thread, there is
+    // no race condition here.
+    runDeferredTagRemovalAndDeletion();
+    mReactTagsToRemove.push(tag);
+  }
+
+  @UiThread
+  private void runDeferredTagRemovalAndDeletion() {
+    if (mReactTagsToRemove.empty()) {
+      if (mRemoveDeleteTreeUIFrameCallback == null) {
+        mRemoveDeleteTreeUIFrameCallback = new RemoveDeleteTreeUIFrameCallback(mThemedReactContext);
+      }
+      ReactChoreographer.getInstance()
+          .postFrameCallback(
+              ReactChoreographer.CallbackType.IDLE_EVENT, mRemoveDeleteTreeUIFrameCallback);
+    }
+  }
+
   @UiThread
   public void createView(
       @NonNull String componentName,
@@ -849,6 +1089,7 @@ public class SurfaceMountingManager {
     }
   }
 
+  /** We update the event emitter from the main thread when the view is mounted. */
   @UiThread
   public void updateEventEmitter(int reactTag, @NonNull EventEmitterWrapper eventEmitter) {
     UiThreadUtil.assertOnUiThread();
@@ -870,6 +1111,20 @@ public class SurfaceMountingManager {
     if (previousEventEmitterWrapper != eventEmitter && previousEventEmitterWrapper != null) {
       previousEventEmitterWrapper.destroy();
     }
+
+    if (viewState.mPendingEventQueue != null) {
+      // Invoke pending event queued to the view state
+      for (ViewEvent viewEvent : viewState.mPendingEventQueue) {
+        if (viewEvent.canCoalesceEvent()) {
+          eventEmitter.invokeUnique(
+              viewEvent.getEventName(), viewEvent.getParams(), viewEvent.getCustomCoalesceKey());
+        } else {
+          eventEmitter.invoke(
+              viewEvent.getEventName(), viewEvent.getParams(), viewEvent.getEventCategory());
+        }
+      }
+      viewState.mPendingEventQueue = null;
+    }
   }
 
   @UiThread
@@ -1017,7 +1272,8 @@ public class SurfaceMountingManager {
   private @NonNull ViewState getViewState(int tag) {
     ViewState viewState = mTagToViewState.get(tag);
     if (viewState == null) {
-      throw new RetryableMountingLayerException("Unable to find viewState for tag " + tag);
+      throw new RetryableMountingLayerException(
+          "Unable to find viewState for tag " + tag + ". Surface stopped: " + isStopped());
     }
     if (ReactFeatureFlags.enableDelayedViewStateDeletion) {
       mScheduledForDeletionViewStateTags.remove(tag);
@@ -1064,6 +1320,31 @@ public class SurfaceMountingManager {
     }
   }
 
+  @UiThread
+  public void enqueuePendingEvent(int reactTag, ViewEvent viewEvent) {
+    UiThreadUtil.assertOnUiThread();
+
+    // When the surface stopped we will reset the view state map. We are not going to enqueue
+    // pending events as they are not expected to be dispatched anyways.
+    if (mTagToViewState == null) {
+      return;
+    }
+
+    ViewState viewState = mTagToViewState.get(reactTag);
+    if (viewState == null) {
+      // Cannot queue event without view state. Do nothing here.
+      return;
+    }
+    Assertions.assertCondition(
+        viewState.mEventEmitter == null,
+        "Only queue pending events when event emitter is null for the given view state");
+
+    if (viewState.mPendingEventQueue == null) {
+      viewState.mPendingEventQueue = new LinkedList<>();
+    }
+    viewState.mPendingEventQueue.add(viewEvent);
+  }
+
   /**
    * This class holds view state for react tags. Objects of this class are stored into the {@link
    * #mTagToViewState}, and they should be updated in the same thread.
@@ -1077,6 +1358,7 @@ public class SurfaceMountingManager {
     @Nullable public ReadableMap mCurrentLocalData = null;
     @Nullable public StateWrapper mStateWrapper = null;
     @Nullable public EventEmitterWrapper mEventEmitter = null;
+    @Nullable public Queue<ViewEvent> mPendingEventQueue = null;
 
     private ViewState(
         int reactTag, @Nullable View view, @Nullable ReactViewManagerWrapper viewManager) {
@@ -1111,4 +1393,169 @@ public class SurfaceMountingManager {
           + isLayoutOnly;
     }
   }
+
+  public static class ViewEvent {
+    private final String mEventName;
+    private final boolean mCanCoalesceEvent;
+    private final int mCustomCoalesceKey;
+    private final @EventCategoryDef int mEventCategory;
+    private @Nullable WritableMap mParams;
+
+    public ViewEvent(
+        String eventName,
+        @Nullable WritableMap params,
+        @EventCategoryDef int eventCategory,
+        boolean canCoalesceEvent,
+        int customCoalesceKey) {
+      mEventName = eventName;
+      mParams = params;
+      mEventCategory = eventCategory;
+      mCanCoalesceEvent = canCoalesceEvent;
+      mCustomCoalesceKey = customCoalesceKey;
+    }
+
+    public String getEventName() {
+      return mEventName;
+    }
+
+    public boolean canCoalesceEvent() {
+      return mCanCoalesceEvent;
+    }
+
+    public int getCustomCoalesceKey() {
+      return mCustomCoalesceKey;
+    }
+
+    public @EventCategoryDef int getEventCategory() {
+      return mEventCategory;
+    }
+
+    public @Nullable WritableMap getParams() {
+      return mParams;
+    }
+  }
+
+  private class RemoveDeleteTreeUIFrameCallback extends GuardedFrameCallback {
+    private static final long FRAME_TIME_MS = 16;
+    private static final long MAX_TIME_IN_FRAME = 9;
+
+    private RemoveDeleteTreeUIFrameCallback(@NonNull ReactContext reactContext) {
+      super(reactContext);
+    }
+
+    /**
+     * Detect if we still have processing time left in this frame. Technically, it should be fine
+     * for this to take up to 15ms since it executes after all other important UI work.
+     */
+    private boolean haveExceededNonBatchedFrameTime(long frameTimeNanos) {
+      long timeLeftInFrame = FRAME_TIME_MS - ((System.nanoTime() - frameTimeNanos) / 1000000);
+      return timeLeftInFrame < MAX_TIME_IN_FRAME;
+    }
+
+    @Override
+    @UiThread
+    @ThreadConfined(UI)
+    public void doFrameGuarded(long frameTimeNanos) {
+      int deletedViews = 0;
+      Stack<Integer> localChildren = new Stack<>();
+      try {
+        while (!mReactTagsToRemove.empty()) {
+          int reactTag = mReactTagsToRemove.pop();
+          deletedViews++;
+
+          // This is "impossible". See comments above.
+          if (mErroneouslyReaddedReactTags.contains(reactTag)) {
+            ReactSoftExceptionLogger.logSoftException(
+                TAG,
+                new IllegalViewOperationException(
+                    "RemoveDeleteTree recursively tried to remove a React View that was actually reused. This indicates a bug in the Differ. ["
+                        + reactTag
+                        + "]"));
+            continue;
+          }
+
+          localChildren.clear();
+
+          ViewState thisViewState = getNullableViewState(reactTag);
+          if (thisViewState != null) {
+            View thisView = thisViewState.mView;
+            int numChildren = 0;
+
+            // Children are managed by React Native if both of the following are true:
+            // 1) There are 1 or more children of this View, which must be a ViewGroup
+            // 2) Those children are managed by RN (this is not the case for certain native
+            // components, like embedded Litho hierarchies)
+            boolean childrenAreManaged = false;
+
+            if (thisView instanceof ViewGroup) {
+              View nextChild = null;
+              // For reasons documented elsewhere in this class, getChildCount is not
+              // necessarily reliable, and so we rely instead on requesting children directly.
+              while ((nextChild = ((ViewGroup) thisView).getChildAt(numChildren)) != null) {
+                int childId = nextChild.getId();
+                childrenAreManaged = childrenAreManaged || getNullableViewState(childId) != null;
+                localChildren.push(nextChild.getId());
+                numChildren++;
+              }
+              // Removing all at once is more efficient than removing one-by-one
+              // If the children are not managed by RN, we simply drop the entire
+              // subtree instead of recursing further.
+              if (childrenAreManaged) {
+                try {
+                  // This can happen if the removeAllViews method is overriden to throw,
+                  // which it is explicitly in some cases (for example embedded Litho views,
+                  // but there could be other cases). In those cases, we want to fail silently
+                  // and then assume the subtree is /not/ managed by React Native.
+                  // In this case short-lived memory-leaks could occur if we aren't clearing
+                  // out the ViewState map properly; but the risk should be small.
+                  // In debug mode, the SoftException will cause a crash. In production it
+                  // will not. This should give good visibility into whether or not this is
+                  // a problem without causing user-facing errors.
+                  ((ViewGroup) thisView).removeAllViews();
+                } catch (RuntimeException e) {
+                  childrenAreManaged = false;
+                  ReactSoftExceptionLogger.logSoftException(TAG, e);
+                }
+              }
+            }
+            if (childrenAreManaged) {
+              // Push tags onto the stack so we process all children
+              mReactTagsToRemove.addAll(localChildren);
+            }
+
+            // Immediately remove tag and notify listeners.
+            // Note that this causes RemoveDeleteTree to call onViewStateDeleted
+            // in a top-down matter (parents first) vs a bottom-up matter (leaf nodes first).
+            // Hopefully this doesn't matter but you should ensure that any custom
+            // onViewStateDeleted logic is resilient to both semantics.
+            // In the initial version of RemoveDeleteTree we attempted to maintain
+            // the bottom-up event listener behavior but this causes additional
+            // memory pressure as well as complexity.
+            mTagToViewState.remove(reactTag);
+            onViewStateDeleted(thisViewState);
+
+            // Circuit breaker: after processing every N tags, check that we haven't
+            // exceeded the max allowed time. Since we don't know what other work needs
+            // to happen on the UI thread during this frame, and since this works tends to be
+            // low-priority, we only give this function a fraction of a frame to run.
+            if (deletedViews % 20 == 0 && haveExceededNonBatchedFrameTime(frameTimeNanos)) {
+              break;
+            }
+          }
+        }
+      } finally {
+        if (!mReactTagsToRemove.empty()) {
+          ReactChoreographer.getInstance()
+              .postFrameCallback(ReactChoreographer.CallbackType.IDLE_EVENT, this);
+        } else {
+          // If there are no more tags to process, then clear the "reused"
+          // tag set. Since the RemoveDeleteTree runner executes /after/ all
+          // other mounting instructions have been executed, all in-band Remove
+          // instructions have already had a chance to execute here.
+          mErroneouslyReaddedReactTags.clear();
+          mReactTagsToRemove.clear();
+        }
+      }
+    }
+  }
 }

package/ReactAndroid/src/main/java/com/facebook/react/fabric/mounting/mountitems/DispatchStringCommandMountItem.java

@@ -16,7 +16,7 @@ public class DispatchStringCommandMountItem extends DispatchCommandMountItem {
 
   private final int mSurfaceId;
   private final int mReactTag;
-  @NonNull private final String mCommandId;
+  private final @NonNull String mCommandId;
   private final @Nullable ReadableArray mCommandArgs;
 
   public DispatchStringCommandMountItem(