react-native 0.0.0-e6fc20ee6 → 0.0.0-e9440508e-20211011-2008

package/ReactAndroid/src/main/java/com/facebook/react/fabric/FabricUIManager.java

@@ -22,10 +22,11 @@ import static com.facebook.react.uimanager.common.UIManagerType.FABRIC;
 
 import android.annotation.SuppressLint;
 import android.content.Context;
+import android.graphics.Point;
 import android.os.SystemClock;
 import android.view.View;
+import android.view.accessibility.AccessibilityEvent;
 import androidx.annotation.AnyThread;
-import androidx.annotation.GuardedBy;
 import androidx.annotation.NonNull;
 import androidx.annotation.Nullable;
 import androidx.annotation.UiThread;
@@ -33,77 +34,77 @@ import com.facebook.common.logging.FLog;
 import com.facebook.debug.holder.PrinterHolder;
 import com.facebook.debug.tags.ReactDebugOverlayTags;
 import com.facebook.infer.annotation.ThreadConfined;
-import com.facebook.proguard.annotations.DoNotStrip;
+import com.facebook.proguard.annotations.DoNotStripAny;
+import com.facebook.react.bridge.ColorPropConverter;
 import com.facebook.react.bridge.LifecycleEventListener;
+import com.facebook.react.bridge.NativeArray;
 import com.facebook.react.bridge.NativeMap;
 import com.facebook.react.bridge.ReactApplicationContext;
 import com.facebook.react.bridge.ReactContext;
 import com.facebook.react.bridge.ReactMarker;
 import com.facebook.react.bridge.ReactMarkerConstants;
-import com.facebook.react.bridge.ReactNoCrashSoftException;
-import com.facebook.react.bridge.ReactSoftException;
+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.UIManager;
 import com.facebook.react.bridge.UIManagerListener;
 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.events.EventBeatManager;
+import com.facebook.react.fabric.events.EventCategoryDef;
 import com.facebook.react.fabric.events.EventEmitterWrapper;
 import com.facebook.react.fabric.events.FabricEventEmitter;
+import com.facebook.react.fabric.mounting.MountItemDispatcher;
 import com.facebook.react.fabric.mounting.MountingManager;
-import com.facebook.react.fabric.mounting.mountitems.BatchMountItem;
-import com.facebook.react.fabric.mounting.mountitems.CreateMountItem;
-import com.facebook.react.fabric.mounting.mountitems.DeleteMountItem;
-import com.facebook.react.fabric.mounting.mountitems.DispatchCommandMountItem;
+import com.facebook.react.fabric.mounting.SurfaceMountingManager;
 import com.facebook.react.fabric.mounting.mountitems.DispatchIntCommandMountItem;
 import com.facebook.react.fabric.mounting.mountitems.DispatchStringCommandMountItem;
-import com.facebook.react.fabric.mounting.mountitems.InsertMountItem;
+import com.facebook.react.fabric.mounting.mountitems.IntBufferBatchMountItem;
 import com.facebook.react.fabric.mounting.mountitems.MountItem;
 import com.facebook.react.fabric.mounting.mountitems.PreAllocateViewMountItem;
-import com.facebook.react.fabric.mounting.mountitems.RemoveDeleteMultiMountItem;
-import com.facebook.react.fabric.mounting.mountitems.RemoveMountItem;
 import com.facebook.react.fabric.mounting.mountitems.SendAccessibilityEvent;
-import com.facebook.react.fabric.mounting.mountitems.UpdateEventEmitterMountItem;
-import com.facebook.react.fabric.mounting.mountitems.UpdateLayoutMountItem;
-import com.facebook.react.fabric.mounting.mountitems.UpdatePaddingMountItem;
-import com.facebook.react.fabric.mounting.mountitems.UpdatePropsMountItem;
-import com.facebook.react.fabric.mounting.mountitems.UpdateStateMountItem;
 import com.facebook.react.modules.core.ReactChoreographer;
 import com.facebook.react.modules.i18nmanager.I18nUtil;
+import com.facebook.react.uimanager.IllegalViewOperationException;
+import com.facebook.react.uimanager.PixelUtil;
 import com.facebook.react.uimanager.ReactRoot;
 import com.facebook.react.uimanager.ReactRootViewTagGenerator;
+import com.facebook.react.uimanager.RootViewUtil;
 import com.facebook.react.uimanager.StateWrapper;
 import com.facebook.react.uimanager.ThemedReactContext;
 import com.facebook.react.uimanager.UIManagerHelper;
 import com.facebook.react.uimanager.ViewManagerPropertyUpdater;
 import com.facebook.react.uimanager.ViewManagerRegistry;
 import com.facebook.react.uimanager.events.EventDispatcher;
-import com.facebook.systrace.Systrace;
-import java.util.ArrayDeque;
-import java.util.ArrayList;
+import com.facebook.react.uimanager.events.EventDispatcherImpl;
+import com.facebook.react.uimanager.events.LockFreeEventDispatcherImpl;
+import com.facebook.react.views.text.TextLayoutManager;
+import com.facebook.react.views.text.TextLayoutManagerMapBuffer;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
-import java.util.concurrent.ConcurrentHashMap;
+import java.util.Queue;
 import java.util.concurrent.CopyOnWriteArrayList;
 
+/**
+ * We instruct ProGuard not to strip out any fields or methods, because many of these methods are
+ * only called through the JNI from Cxx so it appears that most of this class is "unused".
+ */
 @SuppressLint("MissingNativeLoadLibrary")
+@DoNotStripAny
 public class FabricUIManager implements UIManager, LifecycleEventListener {
+  public static final String TAG = FabricUIManager.class.getSimpleName();
 
-  public static final String TAG = "FabricUIManager";
   // The IS_DEVELOPMENT_ENVIRONMENT variable is used to log extra data when running fabric in a
   // development environment. DO NOT ENABLE THIS ON PRODUCTION OR YOU WILL BE FIRED!
-  public static final boolean IS_DEVELOPMENT_ENVIRONMENT = false;
+  public static final boolean IS_DEVELOPMENT_ENVIRONMENT = false && ReactBuildConfig.DEBUG;
   public static final boolean ENABLE_FABRIC_LOGS =
       ReactFeatureFlags.enableFabricLogs
           || PrinterHolder.getPrinter()
               .shouldDisplayLogMessage(ReactDebugOverlayTags.FABRIC_UI_MANAGER);
-  private static final int FRAME_TIME_MS = 16;
-  private static final int MAX_TIME_IN_FRAME_FOR_NON_BATCHED_OPERATIONS_MS = 8;
-  private static final int PRE_MOUNT_ITEMS_INITIAL_SIZE_ARRAY = 250;
 
   static {
     FabricSoLoader.staticInit();
@@ -113,55 +114,28 @@ public class FabricUIManager implements UIManager, LifecycleEventListener {
   @NonNull private final ReactApplicationContext mReactApplicationContext;
   @NonNull private final MountingManager mMountingManager;
   @NonNull private final EventDispatcher mEventDispatcher;
-
-  @NonNull
-  private final ConcurrentHashMap<Integer, ThemedReactContext> mReactContextForRootTag =
-      new ConcurrentHashMap<>();
+  @NonNull private final MountItemDispatcher mMountItemDispatcher;
 
   @NonNull private final EventBeatManager mEventBeatManager;
-  @NonNull private final Object mViewCommandMountItemsLock = new Object();
-  @NonNull private final Object mMountItemsLock = new Object();
-  @NonNull private final Object mPreMountItemsLock = new Object();
-
-  private boolean mInDispatch = false;
-  private int mReDispatchCounter = 0;
-
-  @GuardedBy("mViewCommandMountItemsLock")
-  @NonNull
-  private List<DispatchCommandMountItem> mViewCommandMountItems = new ArrayList<>();
 
   @NonNull
   private final CopyOnWriteArrayList<UIManagerListener> mListeners = new CopyOnWriteArrayList<>();
 
-  @GuardedBy("mMountItemsLock")
-  @NonNull
-  private List<MountItem> mMountItems = new ArrayList<>();
-
-  @GuardedBy("mPreMountItemsLock")
-  @NonNull
-  private ArrayDeque<PreAllocateViewMountItem> mPreMountItems =
-      new ArrayDeque<>(PRE_MOUNT_ITEMS_INITIAL_SIZE_ARRAY);
-
   @ThreadConfined(UI)
   @NonNull
   private final DispatchUIFrameCallback mDispatchUIFrameCallback;
 
-  @ThreadConfined(UI)
-  private int mLastExecutedMountItemSurfaceId = -1;
-
-  @ThreadConfined(UI)
-  private boolean mLastExecutedMountItemSurfaceIdActive = false;
-
   /**
    * This is used to keep track of whether or not the FabricUIManager has been destroyed. Once the
    * Catalyst instance is being destroyed, we should cease all operation here.
    */
   private volatile boolean mDestroyed = false;
 
+  // TODO T83943316: Delete this variable once StaticViewConfigs are enabled by default
+  private volatile boolean mShouldDeallocateEventDispatcher = false;
+
   private boolean mDriveCxxAnimations = false;
 
-  private long mRunStartTime = 0l;
-  private long mBatchedExecutionTime = 0l;
   private long mDispatchViewUpdatesTime = 0l;
   private long mCommitStartTime = 0l;
   private long mLayoutTime = 0l;
@@ -174,6 +148,19 @@ public class FabricUIManager implements UIManager, LifecycleEventListener {
   // from C++ to exceed 9,999 and it should be obvious what's going on when analyzing performance.
   private int mCurrentSynchronousCommitNumber = 10000;
 
+  private MountingManager.MountItemExecutor mMountItemExecutor =
+      new MountingManager.MountItemExecutor() {
+        @Override
+        public void executeItems(Queue<MountItem> items) {
+          // This executor can be technically accessed before the dispatcher is created,
+          // but if that happens, something is terribly wrong
+          mMountItemDispatcher.dispatchMountItems(items);
+        }
+      };
+
+  // TODO T83943316: Deprecate and delete this constructor once StaticViewConfigs are enabled by
+  // default
+  @Deprecated
   public FabricUIManager(
       ReactApplicationContext reactContext,
       ViewManagerRegistry viewManagerRegistry,
@@ -181,8 +168,29 @@ public class FabricUIManager implements UIManager, LifecycleEventListener {
       EventBeatManager eventBeatManager) {
     mDispatchUIFrameCallback = new DispatchUIFrameCallback(reactContext);
     mReactApplicationContext = reactContext;
-    mMountingManager = new MountingManager(viewManagerRegistry);
+    mMountingManager = new MountingManager(viewManagerRegistry, mMountItemExecutor);
+    mMountItemDispatcher =
+        new MountItemDispatcher(mMountingManager, new MountItemDispatchListener());
     mEventDispatcher = eventDispatcher;
+    mShouldDeallocateEventDispatcher = false;
+    mEventBeatManager = eventBeatManager;
+    mReactApplicationContext.addLifecycleEventListener(this);
+  }
+
+  public FabricUIManager(
+      ReactApplicationContext reactContext,
+      ViewManagerRegistry viewManagerRegistry,
+      EventBeatManager eventBeatManager) {
+    mDispatchUIFrameCallback = new DispatchUIFrameCallback(reactContext);
+    mReactApplicationContext = reactContext;
+    mMountingManager = new MountingManager(viewManagerRegistry, mMountItemExecutor);
+    mMountItemDispatcher =
+        new MountItemDispatcher(mMountingManager, new MountItemDispatchListener());
+    mEventDispatcher =
+        ReactFeatureFlags.enableLockFreeEventDispatcher
+            ? new LockFreeEventDispatcherImpl(reactContext)
+            : new EventDispatcherImpl(reactContext);
+    mShouldDeallocateEventDispatcher = true;
     mEventBeatManager = eventBeatManager;
     mReactApplicationContext.addLifecycleEventListener(this);
   }
@@ -191,18 +199,22 @@ public class FabricUIManager implements UIManager, LifecycleEventListener {
   @Override
   @UiThread
   @ThreadConfined(UI)
+  @Deprecated
   public <T extends View> int addRootView(
       final T rootView, final WritableMap initialProps, final @Nullable String initialUITemplate) {
+    ReactSoftExceptionLogger.logSoftException(
+        TAG,
+        new IllegalViewOperationException(
+            "Do not call addRootView in Fabric; it is unsupported. Call startSurface instead."));
+
     final int rootTag = ReactRootViewTagGenerator.getNextRootViewTag();
     ReactRoot reactRootView = (ReactRoot) rootView;
 
-    // TODO T31905686: Combine with startSurface below
     ThemedReactContext reactContext =
         new ThemedReactContext(
-            mReactApplicationContext, rootView.getContext(), reactRootView.getSurfaceID());
-    mMountingManager.addRootView(rootTag, rootView);
+            mReactApplicationContext, rootView.getContext(), reactRootView.getSurfaceID(), rootTag);
+    mMountingManager.startSurface(rootTag, rootView, reactContext);
     String moduleName = reactRootView.getJSModuleName();
-    mReactContextForRootTag.put(rootTag, reactContext);
     if (ENABLE_FABRIC_LOGS) {
       FLog.d(TAG, "Starting surface for module: %s and reactTag: %d", moduleName, rootTag);
     }
@@ -213,6 +225,36 @@ public class FabricUIManager implements UIManager, LifecycleEventListener {
     return rootTag;
   }
 
+  /**
+   * This API returns metadata associated to the React Component that rendered the Android View
+   * received as a parameter.
+   *
+   * @param surfaceId {@link int} that represents the surfaceId for the View received as a
+   *     parameter. In practice surfaceId can be retrieved calling the {@link View#getId()} method
+   *     on the {@link ReactRoot} that holds the View received as a second parameter.
+   * @param view {@link View} view that will be used to retrieve the React view hierarchy metadata.
+   * @return a {@link ReadableMap} that contains metadata associated to the React Component that
+   *     rendered the Android View received as a parameter. For more details about the keys stored
+   *     in the {@link ReadableMap} refer to the "getInspectorDataForInstance" method from
+   *     com/facebook/react/fabric/jni/Binding.cpp file.
+   */
+  @UiThread
+  @ThreadConfined(UI)
+  public ReadableMap getInspectorDataForInstance(final int surfaceId, final View view) {
+    UiThreadUtil.assertOnUiThread();
+    int reactTag = view.getId();
+
+    EventEmitterWrapper eventEmitter = mMountingManager.getEventEmitter(surfaceId, reactTag);
+    return mBinding.getInspectorDataForInstance(eventEmitter);
+  }
+
+  @Override
+  public void preInitializeViewManagers(List<String> viewManagerNames) {
+    for (String viewManagerName : viewManagerNames) {
+      mMountingManager.initializeViewManager(viewManagerName);
+    }
+  }
+
   @Override
   @AnyThread
   @ThreadConfined(ANY)
@@ -225,12 +267,19 @@ public class FabricUIManager implements UIManager, LifecycleEventListener {
     final int rootTag = ReactRootViewTagGenerator.getNextRootViewTag();
     Context context = rootView.getContext();
     ThemedReactContext reactContext =
-        new ThemedReactContext(mReactApplicationContext, context, moduleName);
+        new ThemedReactContext(mReactApplicationContext, context, moduleName, rootTag);
     if (ENABLE_FABRIC_LOGS) {
       FLog.d(TAG, "Starting surface for module: %s and reactTag: %d", moduleName, rootTag);
     }
-    mMountingManager.addRootView(rootTag, rootView);
-    mReactContextForRootTag.put(rootTag, reactContext);
+    mMountingManager.startSurface(rootTag, rootView, reactContext);
+
+    // If startSurface is executed in the UIThread then, it uses the ViewportOffset from the View,
+    // Otherwise Fabric relies on calling {@link Binding#setConstraints} method to update the
+    // ViewportOffset during measurement or onLayout.
+    @SuppressLint("WrongThread")
+    Point viewportOffset =
+        UiThreadUtil.isOnUiThread() ? RootViewUtil.getViewportOffset(rootView) : new Point(0, 0);
+
     mBinding.startSurfaceWithConstraints(
         rootTag,
         moduleName,
@@ -239,13 +288,64 @@ public class FabricUIManager implements UIManager, LifecycleEventListener {
         getMaxSize(widthMeasureSpec),
         getMinSize(heightMeasureSpec),
         getMaxSize(heightMeasureSpec),
+        viewportOffset.x,
+        viewportOffset.y,
         I18nUtil.getInstance().isRTL(context),
         I18nUtil.getInstance().doLeftAndRightSwapInRTL(context));
     return rootTag;
   }
 
+  public void startSurface(final SurfaceHandler surfaceHandler, final @Nullable View rootView) {
+    final int rootTag = ReactRootViewTagGenerator.getNextRootViewTag();
+
+    if (rootView == null) {
+      mMountingManager.startSurface(rootTag);
+    } else {
+      Context context = rootView.getContext();
+      ThemedReactContext reactContext =
+          new ThemedReactContext(
+              mReactApplicationContext, context, surfaceHandler.getModuleName(), rootTag);
+      mMountingManager.startSurface(rootTag, rootView, reactContext);
+    }
+
+    surfaceHandler.setSurfaceId(rootTag);
+    if (surfaceHandler instanceof SurfaceHandlerBinding) {
+      mBinding.registerSurface((SurfaceHandlerBinding) surfaceHandler);
+    }
+    surfaceHandler.setMountable(rootView != null);
+    surfaceHandler.start();
+  }
+
+  public void attachRootView(final SurfaceHandler surfaceHandler, final View rootView) {
+    ThemedReactContext reactContext =
+        new ThemedReactContext(
+            mReactApplicationContext,
+            rootView.getContext(),
+            surfaceHandler.getModuleName(),
+            surfaceHandler.getSurfaceId());
+    mMountingManager.attachRootView(surfaceHandler.getSurfaceId(), rootView, reactContext);
+
+    surfaceHandler.setMountable(true);
+  }
+
+  public void stopSurface(final SurfaceHandler surfaceHandler) {
+    if (!surfaceHandler.isRunning()) {
+      ReactSoftExceptionLogger.logSoftException(
+          FabricUIManager.TAG,
+          new IllegalStateException("Trying to stop surface that hasn't started yet"));
+      return;
+    }
+
+    mMountingManager.stopSurface(surfaceHandler.getSurfaceId());
+
+    surfaceHandler.stop();
+
+    if (surfaceHandler instanceof SurfaceHandlerBinding) {
+      mBinding.unregisterSurface((SurfaceHandlerBinding) surfaceHandler);
+    }
+  }
+
   /** Method called when an event has been dispatched on the C++ side. */
-  @DoNotStrip
   @SuppressWarnings("unused")
   public void onRequestEventBeat() {
     mEventDispatcher.dispatchAllEvents();
@@ -254,9 +354,14 @@ public class FabricUIManager implements UIManager, LifecycleEventListener {
   @AnyThread
   @ThreadConfined(ANY)
   @Override
-  public void stopSurface(int surfaceID) {
+  public void stopSurface(final int surfaceID) {
+    // Mark surfaceId as dead, stop executing mounting instructions
+    mMountingManager.stopSurface(surfaceID);
+
+    // Communicate stopSurface to Cxx - causes an empty ShadowTree to be committed,
+    // but all mounting instructions will be ignored because stopSurface was called
+    // on the MountingManager
     mBinding.stopSurface(surfaceID);
-    mReactContextForRootTag.remove(surfaceID);
   }
 
   @Override
@@ -273,7 +378,7 @@ public class FabricUIManager implements UIManager, LifecycleEventListener {
     FLog.i(TAG, "FabricUIManager.onCatalystInstanceDestroy");
 
     if (mDestroyed) {
-      ReactSoftException.logSoftException(
+      ReactSoftExceptionLogger.logSoftException(
           FabricUIManager.TAG, new IllegalStateException("Cannot double-destroy FabricUIManager"));
       return;
     }
@@ -299,157 +404,44 @@ public class FabricUIManager implements UIManager, LifecycleEventListener {
     // memory immediately.
     mDispatchUIFrameCallback.stop();
 
-    // Stop all attached surfaces
-    if (ReactFeatureFlags.enableFabricStopAllSurfacesOnTeardown) {
-      FLog.e(TAG, "stop all attached surfaces");
-      for (int surfaceId : mReactContextForRootTag.keySet()) {
-        FLog.e(TAG, "stop attached surface: " + surfaceId);
-        stopSurface(surfaceId);
-      }
-    }
-
     mBinding.unregister();
     mBinding = null;
 
     ViewManagerPropertyUpdater.clear();
-  }
 
-  @DoNotStrip
-  @SuppressWarnings("unused")
-  @AnyThread
-  @ThreadConfined(ANY)
-  private void preallocateView(
-      int rootTag,
-      int reactTag,
-      final String componentName,
-      @Nullable ReadableMap props,
-      @Nullable Object stateWrapper,
-      boolean isLayoutable) {
-    ThemedReactContext context = mReactContextForRootTag.get(rootTag);
-
-    String component = getFabricComponentName(componentName);
-    synchronized (mPreMountItemsLock) {
-      mPreMountItems.add(
-          new PreAllocateViewMountItem(
-              context,
-              rootTag,
-              reactTag,
-              component,
-              props,
-              (StateWrapper) stateWrapper,
-              isLayoutable));
-    }
-  }
-
-  @DoNotStrip
-  @SuppressWarnings("unused")
-  @AnyThread
-  @ThreadConfined(ANY)
-  private MountItem createMountItem(
-      String componentName,
-      @Nullable ReadableMap props,
-      @Nullable Object stateWrapper,
-      int reactRootTag,
-      int reactTag,
-      boolean isLayoutable) {
-    String component = getFabricComponentName(componentName);
-    ThemedReactContext reactContext = mReactContextForRootTag.get(reactRootTag);
-    if (reactContext == null) {
-      throw new IllegalArgumentException("Unable to find ReactContext for root: " + reactRootTag);
+    // When using ReactFeatureFlags.enableExperimentalStaticViewConfigs enabled, FabriUIManager is
+    // responsible for initializing and deallocating EventDispatcher.
+    // TODO T83943316: Remove this IF once StaticViewConfigs are enabled by default
+    if (mShouldDeallocateEventDispatcher) {
+      mEventDispatcher.onCatalystInstanceDestroyed();
     }
-    return new CreateMountItem(
-        reactContext,
-        reactRootTag,
-        reactTag,
-        component,
-        props,
-        (StateWrapper) stateWrapper,
-        isLayoutable);
   }
 
-  @DoNotStrip
   @SuppressWarnings("unused")
-  @AnyThread
-  @ThreadConfined(ANY)
-  private MountItem removeMountItem(int reactTag, int parentReactTag, int index) {
-    return new RemoveMountItem(reactTag, parentReactTag, index);
+  private NativeArray measureLines(
+      ReadableMap attributedString, ReadableMap paragraphAttributes, float width, float height) {
+    return (NativeArray)
+        TextLayoutManager.measureLines(
+            mReactApplicationContext,
+            attributedString,
+            paragraphAttributes,
+            PixelUtil.toPixelFromDIP(width));
   }
 
-  @DoNotStrip
   @SuppressWarnings("unused")
-  @AnyThread
-  @ThreadConfined(ANY)
-  private MountItem insertMountItem(int reactTag, int parentReactTag, int index) {
-    return new InsertMountItem(reactTag, parentReactTag, index);
+  private NativeArray measureLinesMapBuffer(
+      ReadableMapBuffer attributedString,
+      ReadableMapBuffer paragraphAttributes,
+      float width,
+      float height) {
+    return (NativeArray)
+        TextLayoutManagerMapBuffer.measureLines(
+            mReactApplicationContext,
+            attributedString,
+            paragraphAttributes,
+            PixelUtil.toPixelFromDIP(width));
   }
 
-  @DoNotStrip
-  @SuppressWarnings("unused")
-  @AnyThread
-  @ThreadConfined(ANY)
-  private MountItem deleteMountItem(int reactTag) {
-    return new DeleteMountItem(reactTag);
-  }
-
-  @DoNotStrip
-  @SuppressWarnings("unused")
-  @AnyThread
-  @ThreadConfined(ANY)
-  private MountItem removeDeleteMultiMountItem(int[] metadata) {
-    return new RemoveDeleteMultiMountItem(metadata);
-  }
-
-  @DoNotStrip
-  @SuppressWarnings("unused")
-  @AnyThread
-  @ThreadConfined(ANY)
-  private MountItem updateLayoutMountItem(
-      int reactTag, int x, int y, int width, int height, int layoutDirection) {
-    return new UpdateLayoutMountItem(reactTag, x, y, width, height, layoutDirection);
-  }
-
-  @DoNotStrip
-  @SuppressWarnings("unused")
-  @AnyThread
-  @ThreadConfined(ANY)
-  private MountItem updatePaddingMountItem(int reactTag, int left, int top, int right, int bottom) {
-    return new UpdatePaddingMountItem(reactTag, left, top, right, bottom);
-  }
-
-  @DoNotStrip
-  @SuppressWarnings("unused")
-  @AnyThread
-  @ThreadConfined(ANY)
-  private MountItem updatePropsMountItem(int reactTag, ReadableMap map) {
-    return new UpdatePropsMountItem(reactTag, map);
-  }
-
-  @DoNotStrip
-  @SuppressWarnings("unused")
-  @AnyThread
-  @ThreadConfined(ANY)
-  private MountItem updateStateMountItem(int reactTag, @Nullable Object stateWrapper) {
-    return new UpdateStateMountItem(reactTag, (StateWrapper) stateWrapper);
-  }
-
-  @DoNotStrip
-  @SuppressWarnings("unused")
-  @AnyThread
-  @ThreadConfined(ANY)
-  private MountItem updateEventEmitterMountItem(int reactTag, Object eventEmitter) {
-    return new UpdateEventEmitterMountItem(reactTag, (EventEmitterWrapper) eventEmitter);
-  }
-
-  @DoNotStrip
-  @SuppressWarnings("unused")
-  @AnyThread
-  @ThreadConfined(ANY)
-  private MountItem createBatchMountItem(
-      int rootTag, MountItem[] items, int size, int commitNumber) {
-    return new BatchMountItem(rootTag, items, size, commitNumber);
-  }
-
-  @DoNotStrip
   @SuppressWarnings("unused")
   private long measure(
       int rootTag,
@@ -474,10 +466,17 @@ public class FabricUIManager implements UIManager, LifecycleEventListener {
         null);
   }
 
-  @DoNotStrip
+  @SuppressWarnings("unused")
+  public int getColor(int surfaceId, ReadableMap platformColor) {
+    ThemedReactContext context =
+        mMountingManager.getSurfaceManagerEnforced(surfaceId, "getColor").getContext();
+    Integer color = ColorPropConverter.getColor(platformColor, context);
+    return color != null ? color : 0;
+  }
+
   @SuppressWarnings("unused")
   private long measure(
-      int rootTag,
+      int surfaceId,
       String componentName,
       ReadableMap localData,
       ReadableMap props,
@@ -487,8 +486,19 @@ public class FabricUIManager implements UIManager, LifecycleEventListener {
       float minHeight,
       float maxHeight,
       @Nullable float[] attachmentsPositions) {
-    ReactContext context =
-        rootTag < 0 ? mReactApplicationContext : mReactContextForRootTag.get(rootTag);
+
+    ReactContext context;
+    if (surfaceId > 0) {
+      SurfaceMountingManager surfaceMountingManager =
+          mMountingManager.getSurfaceManagerEnforced(surfaceId, "measure");
+      if (surfaceMountingManager.isStopped()) {
+        return 0;
+      }
+      context = surfaceMountingManager.getContext();
+    } else {
+      context = mReactApplicationContext;
+    }
+
     return mMountingManager.measure(
         context,
         componentName,
@@ -502,23 +512,53 @@ public class FabricUIManager implements UIManager, LifecycleEventListener {
         attachmentsPositions);
   }
 
+  @SuppressWarnings("unused")
+  private long measureMapBuffer(
+      int surfaceId,
+      String componentName,
+      ReadableMapBuffer attributedString,
+      ReadableMapBuffer paragraphAttributes,
+      float minWidth,
+      float maxWidth,
+      float minHeight,
+      float maxHeight,
+      @Nullable float[] attachmentsPositions) {
+
+    ReactContext context;
+    if (surfaceId > 0) {
+      SurfaceMountingManager surfaceMountingManager =
+          mMountingManager.getSurfaceManagerEnforced(surfaceId, "measure");
+      if (surfaceMountingManager.isStopped()) {
+        return 0;
+      }
+      context = surfaceMountingManager.getContext();
+    } else {
+      context = mReactApplicationContext;
+    }
+
+    // TODO: replace ReadableNativeMap -> ReadableMapBuffer
+    return mMountingManager.measureTextMapBuffer(
+        context,
+        componentName,
+        attributedString,
+        paragraphAttributes,
+        getYogaSize(minWidth, maxWidth),
+        getYogaMeasureMode(minWidth, maxWidth),
+        getYogaSize(minHeight, maxHeight),
+        getYogaMeasureMode(minHeight, maxHeight),
+        attachmentsPositions);
+  }
+
   /**
-   * @param surfaceID {@link int} surface ID
+   * @param surfaceId {@link int} surface ID
    * @param defaultTextInputPadding {@link float[]} output parameter will contain the default theme
    *     padding used by RN Android TextInput.
    * @return if theme data is available in the output parameters.
    */
-  @DoNotStrip
-  public boolean getThemeData(int surfaceID, float[] defaultTextInputPadding) {
-    ThemedReactContext themedReactContext = mReactContextForRootTag.get(surfaceID);
-    if (themedReactContext == null) {
-      // TODO T68526882: Review if this should cause a crash instead.
-      ReactSoftException.logSoftException(
-          TAG,
-          new ReactNoCrashSoftException(
-              "Unable to find ThemedReactContext associated to surfaceID: " + surfaceID));
-      return false;
-    }
+  public boolean getThemeData(int surfaceId, float[] defaultTextInputPadding) {
+    SurfaceMountingManager surfaceMountingManager =
+        mMountingManager.getSurfaceManagerEnforced(surfaceId, "getThemeData");
+    ThemedReactContext themedReactContext = surfaceMountingManager.getContext();
     float[] defaultTextInputPaddingForTheme =
         UIManagerHelper.getDefaultTextInputPadding(themedReactContext);
     defaultTextInputPadding[0] = defaultTextInputPaddingForTheme[PADDING_START_INDEX];
@@ -528,61 +568,142 @@ public class FabricUIManager implements UIManager, LifecycleEventListener {
     return true;
   }
 
+  public void addUIManagerEventListener(UIManagerListener listener) {
+    mListeners.add(listener);
+  }
+
+  public void removeUIManagerEventListener(UIManagerListener listener) {
+    mListeners.remove(listener);
+  }
+
   @Override
   @UiThread
   @ThreadConfined(UI)
-  public void synchronouslyUpdateViewOnUIThread(int reactTag, @NonNull ReadableMap props) {
+  public void synchronouslyUpdateViewOnUIThread(
+      final int reactTag, @NonNull final ReadableMap props) {
     UiThreadUtil.assertOnUiThread();
 
     int commitNumber = mCurrentSynchronousCommitNumber++;
 
-    // We are on the UI thread so this is safe to call. We try to flush any existing
-    // mount instructions that are queued.
-    tryDispatchMountItems();
+    // We are on the UI thread so it would otherwise be safe to call `tryDispatchMountItems` here to
+    // flush previously-queued mountitems, *BUT* we don't know where we are on the callstack.
+    // Why isn't it safe, and why do we have additional safeguards here?
+    //
+    // A tangible example where it would cause a crash, and did in the past:
+    // 1. There are queued "delete" mutations
+    // 2. We're called by this stack trace:
+    //    FabricUIManager.synchronouslyUpdateViewOnUIThread(FabricUIManager.java:574)
+    //    PropsAnimatedNode.updateView(PropsAnimatedNode.java:114)
+    //    NativeAnimatedNodesManager.updateNodes(NativeAnimatedNodesManager.java:655)
+    //    NativeAnimatedNodesManager.handleEvent(NativeAnimatedNodesManager.java:521)
+    //    NativeAnimatedNodesManager.onEventDispatch(NativeAnimatedNodesManager.java:483)
+    //    EventDispatcherImpl.dispatchEvent(EventDispatcherImpl.java:116)
+    //    ReactScrollViewHelper.emitScrollEvent(ReactScrollViewHelper.java:85)
+    //    ReactScrollViewHelper.emitScrollEvent(ReactScrollViewHelper.java:46)
+    //    ReactScrollView.onScrollChanged(ReactScrollView.java:285)
+    //    ReactScrollView.onOverScrolled(ReactScrollView.java:808)
+    //    android.view.View.overScrollBy(View.java:26052)
+    //    android.widget.ScrollView.overScrollBy(ScrollView.java:2040)
+    //    android.widget.ScrollView.computeScroll(ScrollView.java:1481)
+    //    android.view.View.updateDisplayListIfDirty(View.java:20466)
+    // 3. A view is deleted while its parent is being drawn, causing a crash.
+
+    MountItem synchronousMountItem =
+        new MountItem() {
+          @Override
+          public void execute(@NonNull MountingManager mountingManager) {
+            try {
+              mountingManager.updateProps(reactTag, props);
+            } catch (Exception ex) {
+              // TODO T42943890: Fix animations in Fabric and remove this try/catch?
+              // There might always be race conditions between surface teardown and
+              // animations/other operations, so it may not be feasible to remove this.
+              // Practically 100% of reported errors from this point are because the
+              // surface has stopped by this point, but the MountItem was queued before
+              // the surface was stopped. It's likely not feasible to prevent all such races.
+            }
+          }
 
-    try {
-      ReactMarker.logFabricMarker(
-          ReactMarkerConstants.FABRIC_UPDATE_UI_MAIN_THREAD_START, null, commitNumber);
-      if (ENABLE_FABRIC_LOGS) {
-        FLog.d(
-            TAG,
-            "SynchronouslyUpdateViewOnUIThread for tag %d: %s",
-            reactTag,
-            (IS_DEVELOPMENT_ENVIRONMENT ? props.toHashMap().toString() : "<hidden>"));
-      }
+          @Override
+          public int getSurfaceId() {
+            return View.NO_ID;
+          }
+
+          @Override
+          public String toString() {
+            String propsString =
+                IS_DEVELOPMENT_ENVIRONMENT
+                    ? (props != null ? props.toHashMap().toString() : "<null>")
+                    : "<hidden>";
+            return String.format("SYNC UPDATE PROPS [%d]: %s", reactTag, propsString);
+          }
+        };
+
+    // If the reactTag exists, we assume that it might at the end of the next
+    // batch of MountItems. Otherwise, we try to execute immediately.
+    if (!mMountingManager.getViewExists(reactTag)) {
+      mMountItemDispatcher.addMountItem(synchronousMountItem);
+      return;
+    }
 
-      updatePropsMountItem(reactTag, props).execute(mMountingManager);
-    } catch (Exception ex) {
-      // TODO T42943890: Fix animations in Fabric and remove this try/catch
-      ReactSoftException.logSoftException(
+    ReactMarker.logFabricMarker(
+        ReactMarkerConstants.FABRIC_UPDATE_UI_MAIN_THREAD_START, null, commitNumber);
+
+    if (ENABLE_FABRIC_LOGS) {
+      FLog.d(
           TAG,
-          new ReactNoCrashSoftException(
-              "Caught exception in synchronouslyUpdateViewOnUIThread", ex));
-    } finally {
-      ReactMarker.logFabricMarker(
-          ReactMarkerConstants.FABRIC_UPDATE_UI_MAIN_THREAD_END, null, commitNumber);
+          "SynchronouslyUpdateViewOnUIThread for tag %d: %s",
+          reactTag,
+          (IS_DEVELOPMENT_ENVIRONMENT ? props.toHashMap().toString() : "<hidden>"));
     }
+
+    synchronousMountItem.execute(mMountingManager);
+
+    ReactMarker.logFabricMarker(
+        ReactMarkerConstants.FABRIC_UPDATE_UI_MAIN_THREAD_END, null, commitNumber);
   }
 
-  public void addUIManagerEventListener(UIManagerListener listener) {
-    mListeners.add(listener);
+  @SuppressWarnings("unused")
+  @AnyThread
+  @ThreadConfined(ANY)
+  private void preallocateView(
+      int rootTag,
+      int reactTag,
+      final String componentName,
+      @Nullable ReadableMap props,
+      @Nullable Object stateWrapper,
+      @Nullable Object eventEmitterWrapper,
+      boolean isLayoutable) {
+
+    mMountItemDispatcher.addPreAllocateMountItem(
+        new PreAllocateViewMountItem(
+            rootTag,
+            reactTag,
+            getFabricComponentName(componentName),
+            props,
+            (StateWrapper) stateWrapper,
+            (EventEmitterWrapper) eventEmitterWrapper,
+            isLayoutable));
   }
 
-  public void removeUIManagerEventListener(UIManagerListener listener) {
-    mListeners.remove(listener);
+  @SuppressWarnings("unused")
+  @AnyThread
+  @ThreadConfined(ANY)
+  private MountItem createIntBufferBatchMountItem(
+      int rootTag, int[] intBuffer, Object[] objBuffer, int commitNumber) {
+    return new IntBufferBatchMountItem(rootTag, intBuffer, objBuffer, commitNumber);
   }
 
   /**
    * This method enqueues UI operations directly to the UI thread. This might change in the future
-   * to enforce execution order using {@link ReactChoreographer#CallbackType}. This method should
+   * to enforce execution order using {@link ReactChoreographer.CallbackType}. This method should
    * only be called as the result of a new tree being committed.
    */
-  @DoNotStrip
   @SuppressWarnings("unused")
   @AnyThread
   @ThreadConfined(ANY)
   private void scheduleMountItem(
-      @NonNull final MountItem mountItem,
+      @Nullable final MountItem mountItem,
       int commitNumber,
       long commitStartTime,
       long diffStartTime,
@@ -594,8 +715,10 @@ public class FabricUIManager implements UIManager, LifecycleEventListener {
     // When Binding.cpp calls scheduleMountItems during a commit phase, it always calls with
     // a BatchMountItem. No other sites call into this with a BatchMountItem, and Binding.cpp only
     // calls scheduleMountItems with a BatchMountItem.
-    boolean isBatchMountItem = mountItem instanceof BatchMountItem;
-    boolean shouldSchedule = !(isBatchMountItem && ((BatchMountItem) mountItem).getSize() == 0);
+    boolean isBatchMountItem = mountItem instanceof IntBufferBatchMountItem;
+    boolean shouldSchedule =
+        (isBatchMountItem && ((IntBufferBatchMountItem) mountItem).shouldSchedule())
+            || (!isBatchMountItem && mountItem != null);
 
     // In case of sync rendering, this could be called on the UI thread. Otherwise,
     // it should ~always be called on the JS thread.
@@ -612,13 +735,10 @@ public class FabricUIManager implements UIManager, LifecycleEventListener {
     }
 
     if (shouldSchedule) {
-      synchronized (mMountItemsLock) {
-        mMountItems.add(mountItem);
-      }
-
+      mMountItemDispatcher.addMountItem(mountItem);
       if (UiThreadUtil.isOnUiThread()) {
         // We only read these flags on the UI thread.
-        tryDispatchMountItems();
+        mMountItemDispatcher.tryDispatchMountItems();
       }
     }
 
@@ -648,314 +768,6 @@ public class FabricUIManager implements UIManager, LifecycleEventListener {
     }
   }
 
-  @UiThread
-  @ThreadConfined(UI)
-  private void tryDispatchMountItems() {
-    // If we're already dispatching, don't reenter.
-    // Reentrance can potentially happen a lot on Android in Fabric because
-    // `updateState` from the
-    // mounting layer causes mount items to be dispatched synchronously. We want to 1) make sure
-    // we don't reenter in those cases, but 2) still execute those queued instructions
-    // synchronously.
-    // This is a pretty blunt tool, but we might not have better options since we really don't want
-    // to execute anything out-of-order.
-    if (mInDispatch) {
-      return;
-    }
-
-    final boolean didDispatchItems;
-    try {
-      didDispatchItems = dispatchMountItems();
-    } catch (Throwable e) {
-      mReDispatchCounter = 0;
-      mLastExecutedMountItemSurfaceId = -1;
-      throw e;
-    } finally {
-      // Clean up after running dispatchMountItems - even if an exception was thrown
-      mInDispatch = false;
-    }
-
-    for (UIManagerListener listener : mListeners) {
-      listener.didDispatchMountItems(this);
-    }
-
-    // Decide if we want to try reentering
-    if (mReDispatchCounter < 10 && didDispatchItems) {
-      // Executing twice in a row is normal. Only log after that point.
-      if (mReDispatchCounter > 2) {
-        ReactSoftException.logSoftException(
-            TAG,
-            new ReactNoCrashSoftException(
-                "Re-dispatched "
-                    + mReDispatchCounter
-                    + " times. This indicates setState (?) is likely being called too many times during mounting."));
-      }
-
-      mReDispatchCounter++;
-      tryDispatchMountItems();
-    }
-    mReDispatchCounter = 0;
-    mLastExecutedMountItemSurfaceId = -1;
-  }
-
-  @UiThread
-  @ThreadConfined(UI)
-  private List<DispatchCommandMountItem> getAndResetViewCommandMountItems() {
-    if (!ReactFeatureFlags.allowEarlyViewCommandExecution) {
-      return null;
-    }
-
-    synchronized (mViewCommandMountItemsLock) {
-      List<DispatchCommandMountItem> result = mViewCommandMountItems;
-      if (result.isEmpty()) {
-        return null;
-      }
-      mViewCommandMountItems = new ArrayList<>();
-      return result;
-    }
-  }
-
-  @UiThread
-  @ThreadConfined(UI)
-  private List<MountItem> getAndResetMountItems() {
-    synchronized (mMountItemsLock) {
-      List<MountItem> result = mMountItems;
-      if (result.isEmpty()) {
-        return null;
-      }
-      mMountItems = new ArrayList<>();
-      return result;
-    }
-  }
-
-  private ArrayDeque<PreAllocateViewMountItem> getAndResetPreMountItems() {
-    synchronized (mPreMountItemsLock) {
-      ArrayDeque<PreAllocateViewMountItem> result = mPreMountItems;
-      if (result.isEmpty()) {
-        return null;
-      }
-      mPreMountItems = new ArrayDeque<>(PRE_MOUNT_ITEMS_INITIAL_SIZE_ARRAY);
-      return result;
-    }
-  }
-
-  /**
-   * Check if a surfaceId is active and ready for MountItems to be executed against it. It is safe
-   * and cheap to call this repeatedly because we expect many operations to be batched with the same
-   * surfaceId in a row and we memoize the parameters and results.
-   *
-   * @param surfaceId
-   * @param context
-   * @return
-   */
-  @UiThread
-  @ThreadConfined(UI)
-  private boolean surfaceActiveForExecution(int surfaceId, String context) {
-    if (mLastExecutedMountItemSurfaceId != surfaceId) {
-      mLastExecutedMountItemSurfaceId = surfaceId;
-      mLastExecutedMountItemSurfaceIdActive = mReactContextForRootTag.get(surfaceId) != null;
-
-      // If there are many MountItems with the same SurfaceId, we only
-      // log a warning for the first one that is skipped.
-      if (!mLastExecutedMountItemSurfaceIdActive) {
-        ReactSoftException.logSoftException(
-            TAG,
-            new ReactNoCrashSoftException(
-                "dispatchMountItems: skipping "
-                    + context
-                    + ", because surface not available: "
-                    + surfaceId));
-      }
-    }
-
-    return mLastExecutedMountItemSurfaceIdActive;
-  }
-
-  @UiThread
-  @ThreadConfined(UI)
-  /** Nothing should call this directly except for `tryDispatchMountItems`. */
-  private boolean dispatchMountItems() {
-    if (mReDispatchCounter == 0) {
-      mBatchedExecutionTime = 0;
-    }
-
-    mRunStartTime = SystemClock.uptimeMillis();
-
-    List<DispatchCommandMountItem> viewCommandMountItemsToDispatch =
-        getAndResetViewCommandMountItems();
-    List<MountItem> mountItemsToDispatch = getAndResetMountItems();
-
-    if (mountItemsToDispatch == null && viewCommandMountItemsToDispatch == null) {
-      return false;
-    }
-
-    // As an optimization, execute all ViewCommands first
-    // This should be:
-    // 1) Performant: ViewCommands are often a replacement for SetNativeProps, which we've always
-    // wanted to be as "synchronous" as possible.
-    // 2) Safer: ViewCommands are inherently disconnected from the tree commit/diff/mount process.
-    // JS imperatively queues these commands.
-    //    If JS has queued a command, it's reasonable to assume that the more time passes, the more
-    // likely it is that the view disappears.
-    //    Thus, by executing ViewCommands early, we should actually avoid a category of
-    // errors/glitches.
-    if (viewCommandMountItemsToDispatch != null) {
-      Systrace.beginSection(
-          Systrace.TRACE_TAG_REACT_JAVA_BRIDGE,
-          "FabricUIManager::mountViews viewCommandMountItems to execute: "
-              + viewCommandMountItemsToDispatch.size());
-      for (DispatchCommandMountItem command : viewCommandMountItemsToDispatch) {
-        if (ENABLE_FABRIC_LOGS) {
-          FLog.d(TAG, "dispatchMountItems: Executing viewCommandMountItem: " + command.toString());
-        }
-        try {
-          command.execute(mMountingManager);
-        } catch (RetryableMountingLayerException e) {
-          // If the exception is marked as Retryable, we retry the viewcommand exactly once, after
-          // the current batch of mount items has finished executing.
-          if (command.getRetries() == 0) {
-            command.incrementRetries();
-            dispatchCommandMountItem(command);
-          } else {
-            // It's very common for commands to be executed on views that no longer exist - for
-            // example, a blur event on TextInput being fired because of a navigation event away
-            // from the current screen. If the exception is marked as Retryable, we log a soft
-            // exception but never crash in debug.
-            // It's not clear that logging this is even useful, because these events are very
-            // common, mundane, and there's not much we can do about them currently.
-            ReactSoftException.logSoftException(
-                TAG,
-                new ReactNoCrashSoftException(
-                    "Caught exception executing ViewCommand: " + command.toString(), e));
-          }
-        } catch (Throwable e) {
-          // Non-Retryable exceptions are logged as soft exceptions in prod, but crash in Debug.
-          ReactSoftException.logSoftException(
-              TAG,
-              new RuntimeException(
-                  "Caught exception executing ViewCommand: " + command.toString(), e));
-        }
-      }
-
-      Systrace.endSection(Systrace.TRACE_TAG_REACT_JAVA_BRIDGE);
-    }
-
-    // If there are MountItems to dispatch, we make sure all the "pre mount items" are executed
-    // first
-    ArrayDeque<PreAllocateViewMountItem> mPreMountItemsToDispatch = getAndResetPreMountItems();
-
-    if (mPreMountItemsToDispatch != null) {
-      Systrace.beginSection(
-          Systrace.TRACE_TAG_REACT_JAVA_BRIDGE,
-          "FabricUIManager::mountViews preMountItems to execute: "
-              + mPreMountItemsToDispatch.size());
-
-      while (!mPreMountItemsToDispatch.isEmpty()) {
-        PreAllocateViewMountItem mountItem = mPreMountItemsToDispatch.pollFirst();
-        if (surfaceActiveForExecution(
-            mountItem.getRootTag(), "dispatchMountItems PreAllocateViewMountItem")) {
-          mountItem.execute(mMountingManager);
-        }
-      }
-
-      Systrace.endSection(Systrace.TRACE_TAG_REACT_JAVA_BRIDGE);
-    }
-
-    if (mountItemsToDispatch != null) {
-      Systrace.beginSection(
-          Systrace.TRACE_TAG_REACT_JAVA_BRIDGE,
-          "FabricUIManager::mountViews mountItems to execute: " + mountItemsToDispatch.size());
-
-      long batchedExecutionStartTime = SystemClock.uptimeMillis();
-
-      for (MountItem mountItem : mountItemsToDispatch) {
-        if (ENABLE_FABRIC_LOGS) {
-          // If a MountItem description is split across multiple lines, it's because it's a compound
-          // MountItem. Log each line separately.
-          String[] mountItemLines = mountItem.toString().split("\n");
-          for (String m : mountItemLines) {
-            FLog.d(TAG, "dispatchMountItems: Executing mountItem: " + m);
-          }
-        }
-
-        // Make sure surface associated with this MountItem has been started, and not stopped.
-        // TODO T68118357: clean up this logic and simplify this method overall
-        if (mountItem instanceof BatchMountItem) {
-          BatchMountItem batchMountItem = (BatchMountItem) mountItem;
-          if (!surfaceActiveForExecution(
-              batchMountItem.getRootTag(), "dispatchMountItems BatchMountItem")) {
-            continue;
-          }
-        }
-
-        // TODO: if early ViewCommand dispatch ships 100% as a feature, this can be removed.
-        // This try/catch catches Retryable errors that can only be thrown by ViewCommands, which
-        // won't be executed here in Early Dispatch mode.
-        try {
-          mountItem.execute(mMountingManager);
-        } catch (RetryableMountingLayerException e) {
-          // It's very common for commands to be executed on views that no longer exist - for
-          // example, a blur event on TextInput being fired because of a navigation event away
-          // from the current screen. If the exception is marked as Retryable, we log a soft
-          // exception but never crash in debug.
-          // It's not clear that logging this is even useful, because these events are very
-          // common, mundane, and there's not much we can do about them currently.
-          if (mountItem instanceof DispatchCommandMountItem) {
-            ReactSoftException.logSoftException(
-                TAG,
-                new ReactNoCrashSoftException(
-                    "Caught exception executing retryable mounting layer instruction: "
-                        + mountItem.toString(),
-                    e));
-          } else {
-            throw e;
-          }
-        }
-      }
-      mBatchedExecutionTime += SystemClock.uptimeMillis() - batchedExecutionStartTime;
-    }
-    Systrace.endSection(Systrace.TRACE_TAG_REACT_JAVA_BRIDGE);
-
-    return true;
-  }
-
-  @UiThread
-  @ThreadConfined(UI)
-  private void dispatchPreMountItems(long frameTimeNanos) {
-    Systrace.beginSection(Systrace.TRACE_TAG_REACT_JAVA_BRIDGE, "FabricUIManager::premountViews");
-
-    // dispatchPreMountItems cannot be reentrant, but we want to prevent dispatchMountItems from
-    // reentering during dispatchPreMountItems
-    mInDispatch = true;
-
-    try {
-      while (true) {
-        long timeLeftInFrame = FRAME_TIME_MS - ((System.nanoTime() - frameTimeNanos) / 1000000);
-        if (timeLeftInFrame < MAX_TIME_IN_FRAME_FOR_NON_BATCHED_OPERATIONS_MS) {
-          break;
-        }
-
-        PreAllocateViewMountItem preMountItemToDispatch;
-        synchronized (mPreMountItemsLock) {
-          if (mPreMountItems.isEmpty()) {
-            break;
-          }
-          preMountItemToDispatch = mPreMountItems.pollFirst();
-        }
-
-        if (surfaceActiveForExecution(
-            preMountItemToDispatch.getRootTag(), "dispatchPreMountItems")) {
-          preMountItemToDispatch.execute(mMountingManager);
-        }
-      }
-    } finally {
-      mInDispatch = false;
-      mLastExecutedMountItemSurfaceId = -1;
-    }
-
-    Systrace.endSection(Systrace.TRACE_TAG_REACT_JAVA_BRIDGE);
-  }
-
   public void setBinding(Binding binding) {
     mBinding = binding;
   }
@@ -967,13 +779,28 @@ public class FabricUIManager implements UIManager, LifecycleEventListener {
   @UiThread
   @ThreadConfined(UI)
   public void updateRootLayoutSpecs(
-      final int rootTag, final int widthMeasureSpec, final int heightMeasureSpec) {
+      final int surfaceId,
+      final int widthMeasureSpec,
+      final int heightMeasureSpec,
+      final int offsetX,
+      final int offsetY) {
 
     if (ENABLE_FABRIC_LOGS) {
-      FLog.d(TAG, "Updating Root Layout Specs");
+      FLog.d(TAG, "Updating Root Layout Specs for [%d]", surfaceId);
+    }
+
+    SurfaceMountingManager surfaceMountingManager = mMountingManager.getSurfaceManager(surfaceId);
+
+    // TODO T83615646: make this a hard-crash in the future.
+    if (surfaceMountingManager == null) {
+      ReactSoftExceptionLogger.logSoftException(
+          TAG,
+          new IllegalViewOperationException(
+              "Cannot updateRootLayoutSpecs on surfaceId that does not exist: " + surfaceId));
+      return;
     }
 
-    ThemedReactContext reactContext = mReactContextForRootTag.get(rootTag);
+    ThemedReactContext reactContext = surfaceMountingManager.getContext();
     boolean isRTL = false;
     boolean doLeftAndRightSwapInRTL = false;
     if (reactContext != null) {
@@ -982,25 +809,98 @@ public class FabricUIManager implements UIManager, LifecycleEventListener {
     }
 
     mBinding.setConstraints(
-        rootTag,
+        surfaceId,
         getMinSize(widthMeasureSpec),
         getMaxSize(widthMeasureSpec),
         getMinSize(heightMeasureSpec),
         getMaxSize(heightMeasureSpec),
+        offsetX,
+        offsetY,
         isRTL,
         doLeftAndRightSwapInRTL);
   }
 
+  @Override
+  public View resolveView(int reactTag) {
+    UiThreadUtil.assertOnUiThread();
+
+    SurfaceMountingManager surfaceManager = mMountingManager.getSurfaceManagerForView(reactTag);
+    return surfaceManager == null ? null : surfaceManager.getView(reactTag);
+  }
+
   @Override
   public void receiveEvent(int reactTag, String eventName, @Nullable WritableMap params) {
-    EventEmitterWrapper eventEmitter = mMountingManager.getEventEmitter(reactTag);
+    receiveEvent(View.NO_ID, reactTag, eventName, params);
+  }
+
+  @Override
+  public void receiveEvent(
+      int surfaceId, int reactTag, String eventName, @Nullable WritableMap params) {
+    receiveEvent(surfaceId, reactTag, eventName, false, 0, params);
+  }
+
+  public void receiveEvent(
+      int surfaceId,
+      int reactTag,
+      String eventName,
+      boolean canCoalesceEvent,
+      int customCoalesceKey,
+      @Nullable WritableMap params) {
+    receiveEvent(
+        surfaceId,
+        reactTag,
+        eventName,
+        canCoalesceEvent,
+        customCoalesceKey,
+        params,
+        EventCategoryDef.UNSPECIFIED);
+  }
+
+  /**
+   * receiveEvent API that emits an event to C++. If `canCoalesceEvent` is true, that signals that
+   * C++ may coalesce the event optionally. Otherwise, coalescing can happen in Java before
+   * emitting.
+   *
+   * <p>`customCoalesceKey` is currently unused.
+   *
+   * @param surfaceId
+   * @param reactTag
+   * @param eventName
+   * @param canCoalesceEvent
+   * @param customCoalesceKey
+   * @param params
+   * @param eventCategory
+   */
+  public void receiveEvent(
+      int surfaceId,
+      int reactTag,
+      String eventName,
+      boolean canCoalesceEvent,
+      int customCoalesceKey,
+      @Nullable WritableMap params,
+      @EventCategoryDef int eventCategory) {
+    if (ReactBuildConfig.DEBUG && surfaceId == View.NO_ID) {
+      FLog.d(TAG, "Emitted event without surfaceId: [%d] %s", reactTag, eventName);
+    }
+
+    if (mDestroyed) {
+      FLog.e(TAG, "Attempted to receiveEvent after destruction");
+      return;
+    }
+
+    EventEmitterWrapper eventEmitter = mMountingManager.getEventEmitter(surfaceId, reactTag);
+
     if (eventEmitter == null) {
       // This can happen if the view has disappeared from the screen (because of async events)
       FLog.d(TAG, "Unable to invoke event: " + eventName + " for reactTag: " + reactTag);
       return;
     }
 
-    eventEmitter.invoke(eventName, params);
+    if (canCoalesceEvent) {
+      eventEmitter.invokeUnique(eventName, params, customCoalesceKey);
+    } else {
+      eventEmitter.invoke(eventName, params, eventCategory);
+    }
   }
 
   @Override
@@ -1025,44 +925,73 @@ public class FabricUIManager implements UIManager, LifecycleEventListener {
   @Override
   public void onHostDestroy() {}
 
-  @Deprecated
   @Override
+  @Deprecated
   @AnyThread
   @ThreadConfined(ANY)
   public void dispatchCommand(
       final int reactTag, final int commandId, @Nullable final ReadableArray commandArgs) {
-    dispatchCommandMountItem(new DispatchIntCommandMountItem(reactTag, commandId, commandArgs));
+    throw new UnsupportedOperationException(
+        "dispatchCommand called without surfaceId - Fabric dispatchCommand must be called through Fabric JSI API");
   }
 
   @Override
+  @Deprecated
   @AnyThread
   @ThreadConfined(ANY)
   public void dispatchCommand(
       final int reactTag, final String commandId, @Nullable final ReadableArray commandArgs) {
-    dispatchCommandMountItem(new DispatchStringCommandMountItem(reactTag, commandId, commandArgs));
+    throw new UnsupportedOperationException(
+        "dispatchCommand called without surfaceId - Fabric dispatchCommand must be called through Fabric JSI API");
   }
 
+  @Deprecated
   @AnyThread
   @ThreadConfined(ANY)
-  private void dispatchCommandMountItem(DispatchCommandMountItem command) {
-    if (ReactFeatureFlags.allowEarlyViewCommandExecution) {
-      synchronized (mViewCommandMountItemsLock) {
-        mViewCommandMountItems.add(command);
-      }
-    } else {
-      synchronized (mMountItemsLock) {
-        mMountItems.add(command);
-      }
-    }
+  public void dispatchCommand(
+      final int surfaceId,
+      final int reactTag,
+      final int commandId,
+      @Nullable final ReadableArray commandArgs) {
+    mMountItemDispatcher.dispatchCommandMountItem(
+        new DispatchIntCommandMountItem(surfaceId, reactTag, commandId, commandArgs));
+  }
+
+  @AnyThread
+  @ThreadConfined(ANY)
+  public void dispatchCommand(
+      final int surfaceId,
+      final int reactTag,
+      final String commandId,
+      @Nullable final ReadableArray commandArgs) {
+    mMountItemDispatcher.dispatchCommandMountItem(
+        new DispatchStringCommandMountItem(surfaceId, reactTag, commandId, commandArgs));
   }
 
   @Override
   @AnyThread
   @ThreadConfined(ANY)
   public void sendAccessibilityEvent(int reactTag, int eventType) {
-    synchronized (mMountItemsLock) {
-      mMountItems.add(new SendAccessibilityEvent(reactTag, eventType));
+    // Can be called from native, not just JS - we need to migrate the native callsites
+    // before removing this entirely.
+    mMountItemDispatcher.addMountItem(new SendAccessibilityEvent(View.NO_ID, reactTag, eventType));
+  }
+
+  @AnyThread
+  @ThreadConfined(ANY)
+  public void sendAccessibilityEventFromJS(int surfaceId, int reactTag, String eventTypeJS) {
+    int eventType;
+    if ("focus".equals(eventTypeJS)) {
+      eventType = AccessibilityEvent.TYPE_VIEW_FOCUSED;
+    } else if ("windowStateChange".equals(eventTypeJS)) {
+      eventType = AccessibilityEvent.TYPE_WINDOW_STATE_CHANGED;
+    } else if ("click".equals(eventTypeJS)) {
+      eventType = AccessibilityEvent.TYPE_VIEW_CLICKED;
+    } else {
+      throw new IllegalArgumentException(
+          "sendAccessibilityEventFromJS: invalid eventType " + eventTypeJS);
     }
+    mMountItemDispatcher.addMountItem(new SendAccessibilityEvent(surfaceId, reactTag, eventType));
   }
 
   /**
@@ -1072,35 +1001,60 @@ public class FabricUIManager implements UIManager, LifecycleEventListener {
    * @param initialReactTag React tag of the JS view that initiated the touch operation
    * @param blockNativeResponder If native responder should be blocked or not
    */
-  @DoNotStrip
   public void setJSResponder(
-      final int reactTag, final int initialReactTag, final boolean blockNativeResponder) {
-    synchronized (mMountItemsLock) {
-      mMountItems.add(
-          new MountItem() {
-            @Override
-            public void execute(MountingManager mountingManager) {
-              mountingManager.setJSResponder(reactTag, initialReactTag, blockNativeResponder);
+      final int surfaceId,
+      final int reactTag,
+      final int initialReactTag,
+      final boolean blockNativeResponder) {
+    mMountItemDispatcher.addMountItem(
+        new MountItem() {
+          @Override
+          public void execute(MountingManager mountingManager) {
+            SurfaceMountingManager surfaceMountingManager =
+                mountingManager.getSurfaceManager(surfaceId);
+            if (surfaceMountingManager != null) {
+              surfaceMountingManager.setJSResponder(
+                  reactTag, initialReactTag, blockNativeResponder);
+            } else {
+              FLog.e(
+                  TAG, "setJSResponder skipped, surface no longer available [" + surfaceId + "]");
             }
-          });
-    }
+          }
+
+          @Override
+          public int getSurfaceId() {
+            return surfaceId;
+          }
+
+          @Override
+          public String toString() {
+            return String.format("SET_JS_RESPONDER [%d] [surface:%d]", reactTag, surfaceId);
+          }
+        });
   }
 
   /**
-   * Clears the JS Responder specified by {@link #setJSResponder(int, int, boolean)}. After this
-   * method is called, all the touch events are going to be handled by JS.
+   * Clears the JS Responder specified by {@link #setJSResponder}. After this method is called, all
+   * the touch events are going to be handled by JS.
    */
-  @DoNotStrip
   public void clearJSResponder() {
-    synchronized (mMountItemsLock) {
-      mMountItems.add(
-          new MountItem() {
-            @Override
-            public void execute(MountingManager mountingManager) {
-              mountingManager.clearJSResponder();
-            }
-          });
-    }
+    mMountItemDispatcher.addMountItem(
+        new MountItem() {
+          @Override
+          public void execute(MountingManager mountingManager) {
+            mountingManager.clearJSResponder();
+          }
+
+          @Override
+          public int getSurfaceId() {
+            return View.NO_ID;
+          }
+
+          @Override
+          public String toString() {
+            return "CLEAR_JS_RESPONDER";
+          }
+        });
   }
 
   @Override
@@ -1108,15 +1062,26 @@ public class FabricUIManager implements UIManager, LifecycleEventListener {
     // TODO T31905686: Remove this method and add support for multi-threading performance counters
   }
 
+  @Override
+  @Deprecated
+  @Nullable
+  public String resolveCustomDirectEventName(@Nullable String eventName) {
+    if (eventName == null) {
+      return null;
+    }
+    if (eventName.startsWith("top")) {
+      return "on" + eventName.substring(3);
+    }
+    return eventName;
+  }
+
   // Called from Binding.cpp
-  @DoNotStrip
   @AnyThread
   public void onAnimationStarted() {
     mDriveCxxAnimations = true;
   }
 
   // Called from Binding.cpp
-  @DoNotStrip
   @AnyThread
   public void onAllAnimationsComplete() {
     mDriveCxxAnimations = false;
@@ -1128,13 +1093,22 @@ public class FabricUIManager implements UIManager, LifecycleEventListener {
     performanceCounters.put("CommitStartTime", mCommitStartTime);
     performanceCounters.put("LayoutTime", mLayoutTime);
     performanceCounters.put("DispatchViewUpdatesTime", mDispatchViewUpdatesTime);
-    performanceCounters.put("RunStartTime", mRunStartTime);
-    performanceCounters.put("BatchedExecutionTime", mBatchedExecutionTime);
+    performanceCounters.put("RunStartTime", mMountItemDispatcher.getRunStartTime());
+    performanceCounters.put("BatchedExecutionTime", mMountItemDispatcher.getBatchedExecutionTime());
     performanceCounters.put("FinishFabricTransactionTime", mFinishTransactionTime);
     performanceCounters.put("FinishFabricTransactionCPPTime", mFinishTransactionCPPTime);
     return performanceCounters;
   }
 
+  private class MountItemDispatchListener implements MountItemDispatcher.ItemDispatchListener {
+    @Override
+    public void didDispatchMountItems() {
+      for (UIManagerListener listener : mListeners) {
+        listener.didDispatchMountItems(FabricUIManager.this);
+      }
+    }
+  }
+
   private class DispatchUIFrameCallback extends GuardedFrameCallback {
 
     private volatile boolean mIsMountingEnabled = true;
@@ -1166,9 +1140,8 @@ public class FabricUIManager implements UIManager, LifecycleEventListener {
       }
 
       try {
-        dispatchPreMountItems(frameTimeNanos);
-
-        tryDispatchMountItems();
+        mMountItemDispatcher.dispatchPreMountItems(frameTimeNanos);
+        mMountItemDispatcher.tryDispatchMountItems();
       } catch (Exception ex) {
         FLog.e(TAG, "Exception thrown when executing UIFrameGuarded", ex);
         stop();