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

package/ReactAndroid/src/main/java/com/facebook/react/fabric/jni/Binding.cpp

@@ -7,28 +7,31 @@
 
 #include "Binding.h"
 #include "AsyncEventBeat.h"
+#include "AsyncEventBeatV2.h"
 #include "EventEmitterWrapper.h"
 #include "ReactNativeConfigHolder.h"
 #include "StateWrapperImpl.h"
 
-#import <better/set.h>
+#include <cfenv>
+#include <cmath>
+
 #include <fbjni/fbjni.h>
 #include <jsi/JSIDynamic.h>
 #include <jsi/jsi.h>
-#include <react/animations/LayoutAnimationDriver.h>
-#include <react/componentregistry/ComponentDescriptorFactory.h>
-#include <react/components/scrollview/ScrollViewProps.h>
-#include <react/core/EventBeat.h>
-#include <react/core/EventEmitter.h>
-#include <react/core/conversions.h>
-#include <react/debug/SystraceSection.h>
-#include <react/scheduler/Scheduler.h>
-#include <react/scheduler/SchedulerDelegate.h>
-#include <react/scheduler/SchedulerToolbox.h>
-#include <react/uimanager/primitives.h>
+#include <react/renderer/animations/LayoutAnimationDriver.h>
+#include <react/renderer/componentregistry/ComponentDescriptorFactory.h>
+#include <react/renderer/components/scrollview/ScrollViewProps.h>
+#include <react/renderer/core/EventBeat.h>
+#include <react/renderer/core/EventEmitter.h>
+#include <react/renderer/core/conversions.h>
+#include <react/renderer/debug/SystraceSection.h>
+#include <react/renderer/scheduler/Scheduler.h>
+#include <react/renderer/scheduler/SchedulerDelegate.h>
+#include <react/renderer/scheduler/SchedulerToolbox.h>
+#include <react/renderer/uimanager/primitives.h>
 #include <react/utils/ContextContainer.h>
 
-#include <Glog/logging.h>
+#include <glog/logging.h>
 
 using namespace facebook::jni;
 using namespace facebook::jsi;
@@ -43,16 +46,176 @@ struct JMountItem : public JavaClass<JMountItem> {
       "Lcom/facebook/react/fabric/mounting/mountitems/MountItem;";
 };
 
-struct RemoveDeleteMetadata {
-  Tag tag;
-  Tag parentTag;
-  int index;
-  bool shouldRemove;
-  bool shouldDelete;
-};
-
 } // namespace
 
+CppMountItem CppMountItem::CreateMountItem(ShadowView shadowView) {
+  return {CppMountItem::Type::Create, {}, {}, shadowView, -1};
+}
+CppMountItem CppMountItem::DeleteMountItem(ShadowView shadowView) {
+  return {CppMountItem::Type::Delete, {}, shadowView, {}, -1};
+}
+CppMountItem CppMountItem::InsertMountItem(
+    ShadowView parentView,
+    ShadowView shadowView,
+    int index) {
+  return {CppMountItem::Type::Insert, parentView, {}, shadowView, index};
+}
+CppMountItem CppMountItem::RemoveMountItem(
+    ShadowView parentView,
+    ShadowView shadowView,
+    int index) {
+  return {CppMountItem::Type::Remove, parentView, shadowView, {}, index};
+}
+CppMountItem CppMountItem::UpdatePropsMountItem(ShadowView shadowView) {
+  return {CppMountItem::Type::UpdateProps, {}, {}, shadowView, -1};
+}
+CppMountItem CppMountItem::UpdateStateMountItem(ShadowView shadowView) {
+  return {CppMountItem::Type::UpdateState, {}, {}, shadowView, -1};
+}
+CppMountItem CppMountItem::UpdateLayoutMountItem(ShadowView shadowView) {
+  return {CppMountItem::Type::UpdateLayout, {}, {}, shadowView, -1};
+}
+CppMountItem CppMountItem::UpdateEventEmitterMountItem(ShadowView shadowView) {
+  return {CppMountItem::Type::UpdateEventEmitter, {}, {}, shadowView, -1};
+}
+CppMountItem CppMountItem::UpdatePaddingMountItem(ShadowView shadowView) {
+  return {CppMountItem::Type::UpdatePadding, {}, {}, shadowView, -1};
+}
+
+static inline int getIntBufferSizeForType(CppMountItem::Type mountItemType) {
+  if (mountItemType == CppMountItem::Type::Create) {
+    return 2; // tag, isLayoutable
+  } else if (mountItemType == CppMountItem::Type::Insert) {
+    return 3; // tag, parentTag, index
+  } else if (mountItemType == CppMountItem::Type::Remove) {
+    return 3; // tag, parentTag, index
+  } else if (mountItemType == CppMountItem::Type::Delete) {
+    return 1; // tag
+  } else if (mountItemType == CppMountItem::Type::UpdateProps) {
+    return 1; // tag
+  } else if (mountItemType == CppMountItem::Type::UpdateState) {
+    return 1; // tag
+  } else if (mountItemType == CppMountItem::Type::UpdatePadding) {
+    return 5; // tag, top, left, bottom, right
+  } else if (mountItemType == CppMountItem::Type::UpdateLayout) {
+    return 6; // tag, x, y, w, h, DisplayType
+  } else if (mountItemType == CppMountItem::Type::UpdateEventEmitter) {
+    return 1; // tag
+  } else {
+    return -1;
+  }
+}
+
+static inline void updateBufferSizes(
+    CppMountItem::Type mountItemType,
+    int numInstructions,
+    int &batchMountItemIntsSize,
+    int &batchMountItemObjectsSize) {
+  if (numInstructions == 0) {
+    return;
+  }
+
+  batchMountItemIntsSize +=
+      numInstructions == 1 ? 1 : 2; // instructionType[, numInstructions]
+  batchMountItemIntsSize +=
+      numInstructions * getIntBufferSizeForType(mountItemType);
+
+  if (mountItemType == CppMountItem::Type::UpdateProps) {
+    batchMountItemObjectsSize +=
+        numInstructions; // props object * numInstructions
+  } else if (mountItemType == CppMountItem::Type::UpdateState) {
+    batchMountItemObjectsSize +=
+        numInstructions; // state object * numInstructions
+  } else if (mountItemType == CppMountItem::Type::UpdateEventEmitter) {
+    batchMountItemObjectsSize +=
+        numInstructions; // EventEmitter object * numInstructions
+  }
+}
+
+static inline void computeBufferSizes(
+    int &batchMountItemIntsSize,
+    int &batchMountItemObjectsSize,
+    std::vector<CppMountItem> &cppCommonMountItems,
+    std::vector<CppMountItem> &cppDeleteMountItems,
+    std::vector<CppMountItem> &cppUpdatePropsMountItems,
+    std::vector<CppMountItem> &cppUpdateStateMountItems,
+    std::vector<CppMountItem> &cppUpdatePaddingMountItems,
+    std::vector<CppMountItem> &cppUpdateLayoutMountItems,
+    std::vector<CppMountItem> &cppUpdateEventEmitterMountItems) {
+  CppMountItem::Type lastType = CppMountItem::Type::Undefined;
+  int numSameType = 0;
+  for (const auto &mountItem : cppCommonMountItems) {
+    const auto &mountItemType = mountItem.type;
+
+    if (lastType == mountItemType) {
+      numSameType++;
+      if (numSameType == 2) {
+        batchMountItemIntsSize += 1; // numInstructions
+      }
+    } else {
+      numSameType = 1;
+      lastType = mountItemType;
+      batchMountItemIntsSize += 1; // instructionType
+    }
+
+    batchMountItemIntsSize += getIntBufferSizeForType(mountItemType);
+    if (mountItemType == CppMountItem::Type::Create) {
+      batchMountItemObjectsSize +=
+          4; // component name, props, state, event emitter
+    }
+  }
+
+  updateBufferSizes(
+      CppMountItem::Type::UpdateProps,
+      cppUpdatePropsMountItems.size(),
+      batchMountItemIntsSize,
+      batchMountItemObjectsSize);
+  updateBufferSizes(
+      CppMountItem::Type::UpdateState,
+      cppUpdateStateMountItems.size(),
+      batchMountItemIntsSize,
+      batchMountItemObjectsSize);
+  updateBufferSizes(
+      CppMountItem::Type::UpdatePadding,
+      cppUpdatePaddingMountItems.size(),
+      batchMountItemIntsSize,
+      batchMountItemObjectsSize);
+  updateBufferSizes(
+      CppMountItem::Type::UpdateLayout,
+      cppUpdateLayoutMountItems.size(),
+      batchMountItemIntsSize,
+      batchMountItemObjectsSize);
+  updateBufferSizes(
+      CppMountItem::Type::UpdateEventEmitter,
+      cppUpdateEventEmitterMountItems.size(),
+      batchMountItemIntsSize,
+      batchMountItemObjectsSize);
+  updateBufferSizes(
+      CppMountItem::Type::Delete,
+      cppDeleteMountItems.size(),
+      batchMountItemIntsSize,
+      batchMountItemObjectsSize);
+}
+
+static inline void writeIntBufferTypePreamble(
+    int mountItemType,
+    int numItems,
+    _JNIEnv *env,
+    jintArray &intBufferArray,
+    int &intBufferPosition) {
+  jint temp[2];
+  if (numItems == 1) {
+    temp[0] = mountItemType;
+    env->SetIntArrayRegion(intBufferArray, intBufferPosition, 1, temp);
+    intBufferPosition += 1;
+  } else {
+    temp[0] = mountItemType | CppMountItem::Type::Multiple;
+    temp[1] = numItems;
+    env->SetIntArrayRegion(intBufferArray, intBufferPosition, 2, temp);
+    intBufferPosition += 2;
+  }
+}
+
 jni::local_ref<Binding::jhybriddata> Binding::initHybrid(
     jni::alias_ref<jclass>) {
   return makeCxxInstance();
@@ -70,6 +233,34 @@ std::shared_ptr<Scheduler> Binding::getScheduler() {
   return scheduler_;
 }
 
+jni::local_ref<ReadableNativeMap::jhybridobject>
+Binding::getInspectorDataForInstance(
+    jni::alias_ref<EventEmitterWrapper::javaobject> eventEmitterWrapper) {
+  std::shared_ptr<Scheduler> scheduler = getScheduler();
+  if (!scheduler) {
+    LOG(ERROR) << "Binding::startSurface: scheduler disappeared";
+    return ReadableNativeMap::newObjectCxxArgs(folly::dynamic::object());
+  }
+
+  EventEmitterWrapper *cEventEmitter = cthis(eventEmitterWrapper);
+  InspectorData data = scheduler->getInspectorDataForInstance(
+      enableEventEmitterRawPointer_ ? *cEventEmitter->eventEmitterPointer
+                                    : *cEventEmitter->eventEmitter);
+
+  folly::dynamic result = folly::dynamic::object;
+  result["fileName"] = data.fileName;
+  result["lineNumber"] = data.lineNumber;
+  result["columnNumber"] = data.columnNumber;
+  result["selectedIndex"] = data.selectedIndex;
+  result["props"] = data.props;
+  auto hierarchy = folly::dynamic::array();
+  for (auto hierarchyItem : data.hierarchy) {
+    hierarchy.push_back(hierarchyItem);
+  }
+  result["hierarchy"] = hierarchy;
+  return ReadableNativeMap::newObjectCxxArgs(result);
+}
+
 void Binding::startSurface(
     jint surfaceId,
     jni::alias_ref<jstring> moduleName,
@@ -82,15 +273,27 @@ void Binding::startSurface(
     return;
   }
 
-  LayoutContext context;
-  context.pointScaleFactor = pointScaleFactor_;
-  scheduler->startSurface(
-      surfaceId,
-      moduleName->toStdString(),
-      initialProps->consume(),
-      {},
-      context,
+  auto layoutContext = LayoutContext{};
+  layoutContext.pointScaleFactor = pointScaleFactor_;
+
+  auto surfaceHandler = SurfaceHandler{moduleName->toStdString(), surfaceId};
+  surfaceHandler.setContextContainer(scheduler->getContextContainer());
+  surfaceHandler.setProps(initialProps->consume());
+  surfaceHandler.constraintLayout({}, layoutContext);
+
+  scheduler->registerSurface(surfaceHandler);
+
+  surfaceHandler.start();
+
+  surfaceHandler.getMountingCoordinator()->setMountingOverrideDelegate(
       animationDriver_);
+
+  {
+    SystraceSection s2("FabricUIManagerBinding::startSurface::surfaceId::lock");
+    std::unique_lock<better::shared_mutex> lock(surfaceHandlerRegistryMutex_);
+    SystraceSection s3("FabricUIManagerBinding::startSurface::surfaceId");
+    surfaceHandlerRegistry_.emplace(surfaceId, std::move(surfaceHandler));
+  }
 }
 
 void Binding::startSurfaceWithConstraints(
@@ -101,6 +304,8 @@ void Binding::startSurfaceWithConstraints(
     jfloat maxWidth,
     jfloat minHeight,
     jfloat maxHeight,
+    jfloat offsetX,
+    jfloat offsetY,
     jboolean isRTL,
     jboolean doLeftAndRightSwapInRTL) {
   SystraceSection s("FabricUIManagerBinding::startSurfaceWithConstraints");
@@ -123,6 +328,8 @@ void Binding::startSurfaceWithConstraints(
       Size{maxWidth / pointScaleFactor_, maxHeight / pointScaleFactor_};
 
   LayoutContext context;
+  context.viewportOffset =
+      Point{offsetX / pointScaleFactor_, offsetY / pointScaleFactor_};
   context.pointScaleFactor = {pointScaleFactor_};
   context.swapLeftAndRightInRTL = doLeftAndRightSwapInRTL;
   LayoutConstraints constraints = {};
@@ -131,13 +338,26 @@ void Binding::startSurfaceWithConstraints(
   constraints.layoutDirection =
       isRTL ? LayoutDirection::RightToLeft : LayoutDirection::LeftToRight;
 
-  scheduler->startSurface(
-      surfaceId,
-      moduleName->toStdString(),
-      initialProps->consume(),
-      constraints,
-      context,
+  auto surfaceHandler = SurfaceHandler{moduleName->toStdString(), surfaceId};
+  surfaceHandler.setContextContainer(scheduler_->getContextContainer());
+  surfaceHandler.setProps(initialProps->consume());
+  surfaceHandler.constraintLayout(constraints, context);
+
+  scheduler->registerSurface(surfaceHandler);
+
+  surfaceHandler.start();
+
+  surfaceHandler.getMountingCoordinator()->setMountingOverrideDelegate(
       animationDriver_);
+
+  {
+    SystraceSection s2(
+        "FabricUIManagerBinding::startSurfaceWithConstraints::surfaceId::lock");
+    std::unique_lock<better::shared_mutex> lock(surfaceHandlerRegistryMutex_);
+    SystraceSection s3(
+        "FabricUIManagerBinding::startSurfaceWithConstraints::surfaceId");
+    surfaceHandlerRegistry_.emplace(surfaceId, std::move(surfaceHandler));
+  }
 }
 
 void Binding::renderTemplateToSurface(jint surfaceId, jstring uiTemplate) {
@@ -169,7 +389,47 @@ void Binding::stopSurface(jint surfaceId) {
     return;
   }
 
-  scheduler->stopSurface(surfaceId);
+  {
+    std::unique_lock<better::shared_mutex> lock(surfaceHandlerRegistryMutex_);
+
+    auto iterator = surfaceHandlerRegistry_.find(surfaceId);
+
+    if (iterator == surfaceHandlerRegistry_.end()) {
+      LOG(ERROR) << "Binding::stopSurface: Surface with given id is not found";
+      return;
+    }
+
+    auto surfaceHandler = std::move(iterator->second);
+    surfaceHandlerRegistry_.erase(iterator);
+    surfaceHandler.stop();
+    scheduler->unregisterSurface(surfaceHandler);
+  }
+}
+
+void Binding::registerSurface(SurfaceHandlerBinding *surfaceHandlerBinding) {
+  auto scheduler = getScheduler();
+  scheduler->registerSurface(surfaceHandlerBinding->getSurfaceHandler());
+}
+
+void Binding::unregisterSurface(SurfaceHandlerBinding *surfaceHandlerBinding) {
+  auto scheduler = getScheduler();
+  scheduler->unregisterSurface(surfaceHandlerBinding->getSurfaceHandler());
+}
+
+static inline float scale(Float value, Float pointScaleFactor) {
+  std::feclearexcept(FE_ALL_EXCEPT);
+  float result = value * pointScaleFactor;
+  if (std::fetestexcept(FE_OVERFLOW)) {
+    LOG(ERROR) << "Binding::scale - FE_OVERFLOW - value: " << value
+               << " pointScaleFactor: " << pointScaleFactor
+               << " result: " << result;
+  }
+  if (std::fetestexcept(FE_UNDERFLOW)) {
+    LOG(ERROR) << "Binding::scale - FE_UNDERFLOW - value: " << value
+               << " pointScaleFactor: " << pointScaleFactor
+               << " result: " << result;
+  }
+  return result;
 }
 
 void Binding::setConstraints(
@@ -178,6 +438,8 @@ void Binding::setConstraints(
     jfloat maxWidth,
     jfloat minHeight,
     jfloat maxHeight,
+    jfloat offsetX,
+    jfloat offsetY,
     jboolean isRTL,
     jboolean doLeftAndRightSwapInRTL) {
   SystraceSection s("FabricUIManagerBinding::setConstraints");
@@ -194,6 +456,8 @@ void Binding::setConstraints(
       Size{maxWidth / pointScaleFactor_, maxHeight / pointScaleFactor_};
 
   LayoutContext context;
+  context.viewportOffset =
+      Point{offsetX / pointScaleFactor_, offsetY / pointScaleFactor_};
   context.pointScaleFactor = {pointScaleFactor_};
   context.swapLeftAndRightInRTL = doLeftAndRightSwapInRTL;
   LayoutConstraints constraints = {};
@@ -202,16 +466,40 @@ void Binding::setConstraints(
   constraints.layoutDirection =
       isRTL ? LayoutDirection::RightToLeft : LayoutDirection::LeftToRight;
 
-  scheduler->constraintSurfaceLayout(surfaceId, constraints, context);
+  {
+    std::shared_lock<better::shared_mutex> lock(surfaceHandlerRegistryMutex_);
+
+    auto iterator = surfaceHandlerRegistry_.find(surfaceId);
+
+    if (iterator == surfaceHandlerRegistry_.end()) {
+      LOG(ERROR)
+          << "Binding::setConstraints: Surface with given id is not found";
+      return;
+    }
+
+    auto &surfaceHandler = iterator->second;
+    surfaceHandler.constraintLayout(constraints, context);
+  }
+}
+
+bool isMapBufferSerializationEnabled() {
+  static const auto reactFeatureFlagsJavaDescriptor =
+      jni::findClassStatic(Binding::ReactFeatureFlagsJavaDescriptor);
+  static const auto isMapBufferSerializationEnabledMethod =
+      reactFeatureFlagsJavaDescriptor->getStaticMethod<jboolean()>(
+          "isMapBufferSerializationEnabled");
+  bool value =
+      isMapBufferSerializationEnabledMethod(reactFeatureFlagsJavaDescriptor);
+  return value;
 }
 
 void Binding::installFabricUIManager(
-    jlong jsContextNativePointer,
     jni::alias_ref<JRuntimeExecutor::javaobject> runtimeExecutorHolder,
+    jni::alias_ref<JRuntimeScheduler::javaobject> runtimeSchedulerHolder,
     jni::alias_ref<jobject> javaUIManager,
     EventBeatManager *eventBeatManager,
     jni::alias_ref<JavaMessageQueueThread::javaobject> jsMessageQueueThread,
-    ComponentFactoryDelegate *componentsRegistry,
+    ComponentFactory *componentsRegistry,
     jni::alias_ref<jobject> reactNativeConfig) {
   SystraceSection s("FabricUIManagerBinding::installFabricUIManager");
 
@@ -221,6 +509,12 @@ void Binding::installFabricUIManager(
   enableFabricLogs_ =
       config->getBool("react_fabric:enabled_android_fabric_logs");
 
+  disableRevisionCheckForPreallocation_ =
+      config->getBool("react_fabric:disable_revision_check_for_preallocation");
+
+  enableEventEmitterRawPointer_ =
+      config->getBool("react_fabric:enable_event_emitter_wrapper_raw_pointer");
+
   if (enableFabricLogs_) {
     LOG(WARNING) << "Binding::installFabricUIManager() was called (address: "
                  << this << ").";
@@ -240,56 +534,70 @@ void Binding::installFabricUIManager(
 
   auto sharedJSMessageQueueThread =
       std::make_shared<JMessageQueueThread>(jsMessageQueueThread);
-
-  bool useRuntimeExecutor =
-      config->getBool("react_fabric:use_shared_runtime_executor_android");
-
-  RuntimeExecutor runtimeExecutor;
-  if (useRuntimeExecutor) {
-    runtimeExecutor = runtimeExecutorHolder->cthis()->get();
-  } else {
-    Runtime *runtime = (Runtime *)jsContextNativePointer;
-    runtimeExecutor =
-        [runtime, sharedJSMessageQueueThread](
-            std::function<void(facebook::jsi::Runtime & runtime)> &&callback) {
-          sharedJSMessageQueueThread->runOnQueue(
-              [runtime, callback = std::move(callback)]() {
-                callback(*runtime);
-              });
-        };
+  auto runtimeExecutor = runtimeExecutorHolder->cthis()->get();
+
+  if (runtimeSchedulerHolder) {
+    auto runtimeScheduler = runtimeSchedulerHolder->cthis()->get().lock();
+    if (runtimeScheduler) {
+      runtimeScheduler->setEnableYielding(config->getBool(
+          "react_native_new_architecture:runtimescheduler_enable_yielding_android"));
+      runtimeExecutor =
+          [runtimeScheduler](
+              std::function<void(jsi::Runtime & runtime)> &&callback) {
+            runtimeScheduler->scheduleWork(std::move(callback));
+          };
+    }
   }
 
+  auto enableV2AsynchronousEventBeat =
+      config->getBool("react_fabric:enable_asynchronous_event_beat_v2_android");
+
   // TODO: T31905686 Create synchronous Event Beat
   jni::global_ref<jobject> localJavaUIManager = javaUIManager_;
   EventBeat::Factory synchronousBeatFactory =
-      [eventBeatManager, runtimeExecutor, localJavaUIManager](
-          EventBeat::SharedOwnerBox const &ownerBox) {
-        return std::make_unique<AsyncEventBeat>(
-            ownerBox, eventBeatManager, runtimeExecutor, localJavaUIManager);
-      };
+      [eventBeatManager,
+       runtimeExecutor,
+       localJavaUIManager,
+       enableV2AsynchronousEventBeat](EventBeat::SharedOwnerBox const &ownerBox)
+      -> std::unique_ptr<EventBeat> {
+    if (enableV2AsynchronousEventBeat) {
+      return std::make_unique<AsyncEventBeatV2>(
+          ownerBox, eventBeatManager, runtimeExecutor, localJavaUIManager);
+    } else {
+      return std::make_unique<AsyncEventBeat>(
+          ownerBox, eventBeatManager, runtimeExecutor, localJavaUIManager);
+    }
+  };
 
   EventBeat::Factory asynchronousBeatFactory =
-      [eventBeatManager, runtimeExecutor, localJavaUIManager](
-          EventBeat::SharedOwnerBox const &ownerBox) {
-        return std::make_unique<AsyncEventBeat>(
-            ownerBox, eventBeatManager, runtimeExecutor, localJavaUIManager);
-      };
+      [eventBeatManager,
+       runtimeExecutor,
+       localJavaUIManager,
+       enableV2AsynchronousEventBeat](EventBeat::SharedOwnerBox const &ownerBox)
+      -> std::unique_ptr<EventBeat> {
+    if (enableV2AsynchronousEventBeat) {
+      return std::make_unique<AsyncEventBeatV2>(
+          ownerBox, eventBeatManager, runtimeExecutor, localJavaUIManager);
+    } else {
+      return std::make_unique<AsyncEventBeat>(
+          ownerBox, eventBeatManager, runtimeExecutor, localJavaUIManager);
+    }
+  };
 
   contextContainer->insert("ReactNativeConfig", config);
   contextContainer->insert("FabricUIManager", javaUIManager_);
 
   // Keep reference to config object and cache some feature flags here
   reactNativeConfig_ = config;
-  shouldCollateRemovesAndDeletes_ = reactNativeConfig_->getBool(
-      "react_fabric:enable_removedelete_collation_android");
-  collapseDeleteCreateMountingInstructions_ = reactNativeConfig_->getBool(
-      "react_fabric:enabled_collapse_delete_create_mounting_instructions");
+
+  contextContainer->insert(
+      "MapBufferSerializationEnabled", isMapBufferSerializationEnabled());
 
   disablePreallocateViews_ = reactNativeConfig_->getBool(
       "react_fabric:disabled_view_preallocation_android");
 
-  bool enableLayoutAnimations = reactNativeConfig_->getBool(
-      "react_fabric:enabled_layout_animations_android");
+  enableEarlyEventEmitterUpdate_ = reactNativeConfig_->getBool(
+      "react_fabric:enable_early_event_emitter_update");
 
   auto toolbox = SchedulerToolbox{};
   toolbox.contextContainer = contextContainer;
@@ -298,9 +606,14 @@ void Binding::installFabricUIManager(
   toolbox.synchronousEventBeatFactory = synchronousBeatFactory;
   toolbox.asynchronousEventBeatFactory = asynchronousBeatFactory;
 
-  if (enableLayoutAnimations) {
-    animationDriver_ = std::make_shared<LayoutAnimationDriver>(this);
+  if (reactNativeConfig_->getBool(
+          "react_fabric:enable_background_executor_android")) {
+    backgroundExecutor_ = std::make_unique<JBackgroundExecutor>();
+    toolbox.backgroundExecutor = backgroundExecutor_->get();
   }
+
+  animationDriver_ = std::make_shared<LayoutAnimationDriver>(
+      runtimeExecutor, contextContainer, this);
   scheduler_ = std::make_shared<Scheduler>(
       toolbox, (animationDriver_ ? animationDriver_.get() : nullptr), this);
 }
@@ -349,256 +662,12 @@ local_ref<JString> getPlatformComponentName(const ShadowView &shadowView) {
   return componentName;
 }
 
-local_ref<JMountItem::javaobject> createUpdateEventEmitterMountItem(
-    const jni::global_ref<jobject> &javaUIManager,
-    const ShadowViewMutation &mutation) {
-  if (!mutation.newChildShadowView.eventEmitter) {
-    return nullptr;
-  }
-  SharedEventEmitter eventEmitter = mutation.newChildShadowView.eventEmitter;
-
-  // Do not hold a reference to javaEventEmitter from the C++ side.
-  auto javaEventEmitter = EventEmitterWrapper::newObjectJavaArgs();
-  EventEmitterWrapper *cEventEmitter = cthis(javaEventEmitter);
-  cEventEmitter->eventEmitter = eventEmitter;
-
-  static auto updateEventEmitterInstruction =
-      jni::findClassStatic(Binding::UIManagerJavaDescriptor)
-          ->getMethod<alias_ref<JMountItem>(jint, jobject)>(
-              "updateEventEmitterMountItem");
-
-  return updateEventEmitterInstruction(
-      javaUIManager, mutation.newChildShadowView.tag, javaEventEmitter.get());
-}
-
-local_ref<JMountItem::javaobject> createUpdatePropsMountItem(
-    const jni::global_ref<jobject> &javaUIManager,
-    const ShadowViewMutation &mutation) {
-  auto shadowView = mutation.newChildShadowView;
-  auto newViewProps =
-      *std::dynamic_pointer_cast<const ViewProps>(shadowView.props);
-
-  // TODO: move props from map to a typed object.
-  auto newProps = shadowView.props->rawProps;
-
-  local_ref<ReadableMap::javaobject> readableMap =
-      castReadableMap(ReadableNativeMap::newObjectCxxArgs(newProps));
-  static auto updatePropsInstruction =
-      jni::findClassStatic(Binding::UIManagerJavaDescriptor)
-          ->getMethod<alias_ref<JMountItem>(jint, ReadableMap::javaobject)>(
-              "updatePropsMountItem");
-
-  return updatePropsInstruction(
-      javaUIManager, mutation.newChildShadowView.tag, readableMap.get());
-}
-
-local_ref<JMountItem::javaobject> createUpdateLayoutMountItem(
-    const jni::global_ref<jobject> &javaUIManager,
-    const ShadowViewMutation &mutation) {
-  auto oldChildShadowView = mutation.oldChildShadowView;
-  auto newChildShadowView = mutation.newChildShadowView;
-
-  if (newChildShadowView.layoutMetrics != EmptyLayoutMetrics &&
-      oldChildShadowView.layoutMetrics != newChildShadowView.layoutMetrics) {
-    static auto updateLayoutInstruction =
-        jni::findClassStatic(Binding::UIManagerJavaDescriptor)
-            ->getMethod<alias_ref<JMountItem>(
-                jint, jint, jint, jint, jint, jint)>("updateLayoutMountItem");
-    auto layoutMetrics = newChildShadowView.layoutMetrics;
-    auto pointScaleFactor = layoutMetrics.pointScaleFactor;
-    auto frame = layoutMetrics.frame;
-
-    int x = round(frame.origin.x * pointScaleFactor);
-    int y = round(frame.origin.y * pointScaleFactor);
-    int w = round(frame.size.width * pointScaleFactor);
-    int h = round(frame.size.height * pointScaleFactor);
-    auto layoutDirection =
-        toInt(newChildShadowView.layoutMetrics.layoutDirection);
-    return updateLayoutInstruction(
-        javaUIManager, newChildShadowView.tag, x, y, w, h, layoutDirection);
-  }
-
-  return nullptr;
-}
-
-local_ref<JMountItem::javaobject> createUpdatePaddingMountItem(
-    const jni::global_ref<jobject> &javaUIManager,
-    const ShadowViewMutation &mutation) {
-  auto oldChildShadowView = mutation.oldChildShadowView;
-  auto newChildShadowView = mutation.newChildShadowView;
-
-  if (oldChildShadowView.layoutMetrics.contentInsets ==
-      newChildShadowView.layoutMetrics.contentInsets) {
-    return nullptr;
-  }
-
-  static auto updateLayoutInstruction =
-      jni::findClassStatic(Binding::UIManagerJavaDescriptor)
-          ->getMethod<alias_ref<JMountItem>(jint, jint, jint, jint, jint)>(
-              "updatePaddingMountItem");
-
-  auto layoutMetrics = newChildShadowView.layoutMetrics;
-  auto pointScaleFactor = layoutMetrics.pointScaleFactor;
-  auto contentInsets = layoutMetrics.contentInsets;
-
-  int left = round(contentInsets.left * pointScaleFactor);
-  int top = round(contentInsets.top * pointScaleFactor);
-  int right = round(contentInsets.right * pointScaleFactor);
-  int bottom = round(contentInsets.bottom * pointScaleFactor);
-
-  return updateLayoutInstruction(
-      javaUIManager, newChildShadowView.tag, left, top, right, bottom);
-}
-
-local_ref<JMountItem::javaobject> createInsertMountItem(
-    const jni::global_ref<jobject> &javaUIManager,
-    const ShadowViewMutation &mutation) {
-  static auto insertInstruction =
-      jni::findClassStatic(Binding::UIManagerJavaDescriptor)
-          ->getMethod<alias_ref<JMountItem>(jint, jint, jint)>(
-              "insertMountItem");
-
-  return insertInstruction(
-      javaUIManager,
-      mutation.newChildShadowView.tag,
-      mutation.parentShadowView.tag,
-      mutation.index);
-}
-
-local_ref<JMountItem::javaobject> createUpdateStateMountItem(
-    const jni::global_ref<jobject> &javaUIManager,
-    const ShadowViewMutation &mutation) {
-  static auto updateStateInstruction =
-      jni::findClassStatic(Binding::UIManagerJavaDescriptor)
-          ->getMethod<alias_ref<JMountItem>(jint, jobject)>(
-              "updateStateMountItem");
-
-  auto state = mutation.newChildShadowView.state;
-
-  // Do not hold onto Java object from C
-  // We DO want to hold onto C object from Java, since we don't know the
-  // lifetime of the Java object
-  local_ref<StateWrapperImpl::JavaPart> javaStateWrapper = nullptr;
-  if (state != nullptr) {
-    javaStateWrapper = StateWrapperImpl::newObjectJavaArgs();
-    StateWrapperImpl *cStateWrapper = cthis(javaStateWrapper);
-    cStateWrapper->state_ = state;
-  }
-
-  return updateStateInstruction(
-      javaUIManager,
-      mutation.newChildShadowView.tag,
-      (javaStateWrapper != nullptr ? javaStateWrapper.get() : nullptr));
-}
-
-local_ref<JMountItem::javaobject> createRemoveMountItem(
-    const jni::global_ref<jobject> &javaUIManager,
-    const ShadowViewMutation &mutation) {
-  static auto removeInstruction =
-      jni::findClassStatic(Binding::UIManagerJavaDescriptor)
-          ->getMethod<alias_ref<JMountItem>(jint, jint, jint)>(
-              "removeMountItem");
-
-  return removeInstruction(
-      javaUIManager,
-      mutation.oldChildShadowView.tag,
-      mutation.parentShadowView.tag,
-      mutation.index);
-}
-
-local_ref<JMountItem::javaobject> createDeleteMountItem(
-    const jni::global_ref<jobject> &javaUIManager,
-    const ShadowViewMutation &mutation) {
-  static auto deleteInstruction =
-      jni::findClassStatic(Binding::UIManagerJavaDescriptor)
-          ->getMethod<alias_ref<JMountItem>(jint)>("deleteMountItem");
-
-  return deleteInstruction(javaUIManager, mutation.oldChildShadowView.tag);
-}
-
-local_ref<JMountItem::javaobject> createRemoveAndDeleteMultiMountItem(
-    const jni::global_ref<jobject> &javaUIManager,
-    const std::vector<RemoveDeleteMetadata> &metadata) {
-  auto env = Environment::current();
-  auto removeAndDeleteArray = env->NewIntArray(metadata.size() * 4);
-  int position = 0;
-  jint temp[4];
-  for (const auto &x : metadata) {
-    temp[0] = x.tag;
-    temp[1] = x.parentTag;
-    temp[2] = x.index;
-    temp[3] = (x.shouldRemove ? 1 : 0) | (x.shouldDelete ? 2 : 0);
-    env->SetIntArrayRegion(removeAndDeleteArray, position, 4, temp);
-    position += 4;
-  }
-
-  static auto removeDeleteMultiInstruction =
-      jni::findClassStatic(Binding::UIManagerJavaDescriptor)
-          ->getMethod<alias_ref<JMountItem>(jintArray)>(
-              "removeDeleteMultiMountItem");
-
-  auto ret = removeDeleteMultiInstruction(javaUIManager, removeAndDeleteArray);
-
-  // It is not strictly necessary to manually delete the ref here, in this
-  // particular case. If JNI memory is being allocated in a loop, it's easy to
-  // overload the localref table and crash; this is not possible in this case
-  // since the JNI would automatically clear this ref when it goes out of scope,
-  // anyway. However, this is being left here as a reminder of good hygiene and
-  // to be careful with JNI-allocated memory in general.
-  env->DeleteLocalRef(removeAndDeleteArray);
-
-  return ret;
-}
-
-// TODO T48019320: because we pass initial props and state to the Create (and
-// preallocate) mount instruction, we technically don't need to pass the first
-// Update to any components. Dedupe?
-local_ref<JMountItem::javaobject> createCreateMountItem(
-    const jni::global_ref<jobject> &javaUIManager,
-    const ShadowViewMutation &mutation,
-    const Tag surfaceId) {
-  static auto createJavaInstruction =
-      jni::findClassStatic(Binding::UIManagerJavaDescriptor)
-          ->getMethod<alias_ref<JMountItem>(
-              jstring, ReadableMap::javaobject, jobject, jint, jint, jboolean)>(
-              "createMountItem");
-
-  auto newChildShadowView = mutation.newChildShadowView;
-
-  local_ref<JString> componentName =
-      getPlatformComponentName(newChildShadowView);
-
-  jboolean isLayoutable =
-      newChildShadowView.layoutMetrics != EmptyLayoutMetrics;
-
-  local_ref<ReadableMap::javaobject> props = castReadableMap(
-      ReadableNativeMap::newObjectCxxArgs(newChildShadowView.props->rawProps));
-
-  // Do not hold onto Java object from C
-  // We DO want to hold onto C object from Java, since we don't know the
-  // lifetime of the Java object
-  local_ref<StateWrapperImpl::JavaPart> javaStateWrapper = nullptr;
-  if (newChildShadowView.state != nullptr) {
-    javaStateWrapper = StateWrapperImpl::newObjectJavaArgs();
-    StateWrapperImpl *cStateWrapper = cthis(javaStateWrapper);
-    cStateWrapper->state_ = newChildShadowView.state;
-  }
-
-  return createJavaInstruction(
-      javaUIManager,
-      componentName.get(),
-      props.get(),
-      (javaStateWrapper != nullptr ? javaStateWrapper.get() : nullptr),
-      surfaceId,
-      newChildShadowView.tag,
-      isLayoutable);
-}
-
 void Binding::schedulerDidFinishTransaction(
     MountingCoordinator::Shared const &mountingCoordinator) {
   std::lock_guard<std::recursive_mutex> lock(commitMutex_);
 
-  SystraceSection s("FabricUIManagerBinding::schedulerDidFinishTransaction");
+  SystraceSection s(
+      "FabricUIManagerBinding::schedulerDidFinishTransactionIntBuffer");
   auto finishTransactionStartTime = telemetryTimePointNow();
 
   jni::global_ref<jobject> localJavaUIManager = getJavaUIManager();
@@ -614,222 +683,124 @@ void Binding::schedulerDidFinishTransaction(
     return;
   }
 
+  auto env = Environment::current();
+
   auto telemetry = mountingTransaction->getTelemetry();
   auto surfaceId = mountingTransaction->getSurfaceId();
   auto &mutations = mountingTransaction->getMutations();
 
-  facebook::better::set<Tag> createAndDeleteTagsToProcess;
-  // When collapseDeleteCreateMountingInstructions_ is enabled, the
-  // createAndDeleteTagsToProcess set will contain all the tags belonging to
-  // CREATE and DELETE mutation instructions that needs to be processed. If a
-  // CREATE or DELETE mutation instruction does not belong in the set, it means
-  // that the we received a pair of mutation instructions: DELETE - CREATE and
-  // it is not necessary to create or delete on the screen.
-  if (collapseDeleteCreateMountingInstructions_) {
-    for (const auto &mutation : mutations) {
-      if (mutation.type == ShadowViewMutation::Delete) {
-        // TAG on 'Delete' mutation instructions are part of the
-        // oldChildShadowView
-        createAndDeleteTagsToProcess.insert(mutation.oldChildShadowView.tag);
-      } else if (mutation.type == ShadowViewMutation::Create) {
-        // TAG on 'Create' mutation instructions are part of the
-        // newChildShadowView
-        Tag tag = mutation.newChildShadowView.tag;
-        if (createAndDeleteTagsToProcess.find(tag) ==
-            createAndDeleteTagsToProcess.end()) {
-          createAndDeleteTagsToProcess.insert(tag);
-        } else {
-          createAndDeleteTagsToProcess.erase(tag);
-        }
-      }
-    }
-  }
-  int64_t commitNumber = telemetry.getCommitNumber();
-
-  std::vector<local_ref<jobject>> queue;
-  // Upper bound estimation of mount items to be delivered to Java side.
-  int size = mutations.size() * 3 + 42;
-
-  local_ref<JArrayClass<JMountItem::javaobject>> mountItemsArray =
-      JArrayClass<JMountItem::javaobject>::newArray(size);
-
-  auto mountItems = *(mountItemsArray);
-  std::unordered_set<Tag> deletedViewTags;
+  auto revisionNumber = telemetry.getRevisionNumber();
 
-  // Find the set of tags that are removed and deleted in one block
-  std::vector<RemoveDeleteMetadata> toRemove;
+  std::vector<CppMountItem> cppCommonMountItems;
+  std::vector<CppMountItem> cppDeleteMountItems;
+  std::vector<CppMountItem> cppUpdatePropsMountItems;
+  std::vector<CppMountItem> cppUpdateStateMountItems;
+  std::vector<CppMountItem> cppUpdatePaddingMountItems;
+  std::vector<CppMountItem> cppUpdateLayoutMountItems;
+  std::vector<CppMountItem> cppUpdateEventEmitterMountItems;
 
-  int position = 0;
   for (const auto &mutation : mutations) {
-    auto oldChildShadowView = mutation.oldChildShadowView;
-    auto newChildShadowView = mutation.newChildShadowView;
-    auto mutationType = mutation.type;
-
-    if (collapseDeleteCreateMountingInstructions_ &&
-        (mutationType == ShadowViewMutation::Create ||
-         mutationType == ShadowViewMutation::Delete) &&
-        createAndDeleteTagsToProcess.size() > 0) {
-      // The TAG on 'Delete' mutation instructions are part of the
-      // oldChildShadowView. On the other side, the TAG on 'Create' mutation
-      // instructions are part of the newChildShadowView
-      Tag tag = mutationType == ShadowViewMutation::Create
-          ? mutation.newChildShadowView.tag
-          : mutation.oldChildShadowView.tag;
-      if (createAndDeleteTagsToProcess.find(tag) ==
-          createAndDeleteTagsToProcess.end()) {
-        continue;
-      }
-    }
+    const auto &parentShadowView = mutation.parentShadowView;
+    const auto &oldChildShadowView = mutation.oldChildShadowView;
+    const auto &newChildShadowView = mutation.newChildShadowView;
+    auto &mutationType = mutation.type;
+    auto &index = mutation.index;
 
-    bool isVirtual = newChildShadowView.layoutMetrics == EmptyLayoutMetrics &&
-        oldChildShadowView.layoutMetrics == EmptyLayoutMetrics;
-
-    // Handle accumulated removals/deletions
-    if (shouldCollateRemovesAndDeletes_ &&
-        mutation.type != ShadowViewMutation::Remove &&
-        mutation.type != ShadowViewMutation::Delete) {
-      if (toRemove.size() > 0) {
-        mountItems[position++] =
-            createRemoveAndDeleteMultiMountItem(localJavaUIManager, toRemove);
-        toRemove.clear();
-      }
-    }
+    bool isVirtual = mutation.mutatedViewIsVirtual();
 
-    switch (mutation.type) {
+    switch (mutationType) {
       case ShadowViewMutation::Create: {
         if (disablePreallocateViews_ ||
-            mutation.newChildShadowView.props->revision > 1 ||
-            deletedViewTags.find(mutation.newChildShadowView.tag) !=
-                deletedViewTags.end()) {
-          mountItems[position++] =
-              createCreateMountItem(localJavaUIManager, mutation, surfaceId);
+            newChildShadowView.props->revision > 1) {
+          cppCommonMountItems.push_back(
+              CppMountItem::CreateMountItem(newChildShadowView));
         }
         break;
       }
       case ShadowViewMutation::Remove: {
         if (!isVirtual) {
-          if (shouldCollateRemovesAndDeletes_) {
-            toRemove.push_back(
-                RemoveDeleteMetadata{mutation.oldChildShadowView.tag,
-                                     mutation.parentShadowView.tag,
-                                     mutation.index,
-                                     true,
-                                     false});
-          } else {
-            mountItems[position++] =
-                createRemoveMountItem(localJavaUIManager, mutation);
-          }
+          cppCommonMountItems.push_back(CppMountItem::RemoveMountItem(
+              parentShadowView, oldChildShadowView, index));
         }
         break;
       }
       case ShadowViewMutation::Delete: {
-        if (shouldCollateRemovesAndDeletes_) {
-          // It is impossible to delete without removing node first
-          const auto &it = std::find_if(
-              std::begin(toRemove),
-              std::end(toRemove),
-              [&mutation](const auto &x) {
-                return x.tag == mutation.oldChildShadowView.tag;
-              });
-
-          if (it != std::end(toRemove)) {
-            it->shouldDelete = true;
-          } else {
-            toRemove.push_back(RemoveDeleteMetadata{
-                mutation.oldChildShadowView.tag, -1, -1, false, true});
-          }
-        } else {
-          mountItems[position++] =
-              createDeleteMountItem(localJavaUIManager, mutation);
-        }
-
-        deletedViewTags.insert(mutation.oldChildShadowView.tag);
+        cppDeleteMountItems.push_back(
+            CppMountItem::DeleteMountItem(oldChildShadowView));
         break;
       }
       case ShadowViewMutation::Update: {
         if (!isVirtual) {
-          if (mutation.oldChildShadowView.props !=
-              mutation.newChildShadowView.props) {
-            mountItems[position++] =
-                createUpdatePropsMountItem(localJavaUIManager, mutation);
+          if (oldChildShadowView.props != newChildShadowView.props) {
+            cppUpdatePropsMountItems.push_back(
+                CppMountItem::UpdatePropsMountItem(newChildShadowView));
           }
-          if (mutation.oldChildShadowView.state !=
-              mutation.newChildShadowView.state) {
-            mountItems[position++] =
-                createUpdateStateMountItem(localJavaUIManager, mutation);
+          if (oldChildShadowView.state != newChildShadowView.state) {
+            cppUpdateStateMountItems.push_back(
+                CppMountItem::UpdateStateMountItem(newChildShadowView));
           }
 
           // Padding: padding mountItems must be executed before layout props
           // are updated in the view. This is necessary to ensure that events
           // (resulting from layout changes) are dispatched with the correct
           // padding information.
-          auto updatePaddingMountItem =
-              createUpdatePaddingMountItem(localJavaUIManager, mutation);
-          if (updatePaddingMountItem) {
-            mountItems[position++] = updatePaddingMountItem;
+          if (oldChildShadowView.layoutMetrics.contentInsets !=
+              newChildShadowView.layoutMetrics.contentInsets) {
+            cppUpdatePaddingMountItems.push_back(
+                CppMountItem::UpdatePaddingMountItem(newChildShadowView));
           }
 
-          auto updateLayoutMountItem =
-              createUpdateLayoutMountItem(localJavaUIManager, mutation);
-          if (updateLayoutMountItem) {
-            mountItems[position++] = updateLayoutMountItem;
+          if (oldChildShadowView.layoutMetrics !=
+              newChildShadowView.layoutMetrics) {
+            cppUpdateLayoutMountItems.push_back(
+                CppMountItem::UpdateLayoutMountItem(
+                    mutation.newChildShadowView));
           }
         }
 
-        if (mutation.oldChildShadowView.eventEmitter !=
-            mutation.newChildShadowView.eventEmitter) {
-          auto updateEventEmitterMountItem =
-              createUpdateEventEmitterMountItem(localJavaUIManager, mutation);
-          if (updateEventEmitterMountItem) {
-            mountItems[position++] = updateEventEmitterMountItem;
-          }
+        if (oldChildShadowView.eventEmitter !=
+            newChildShadowView.eventEmitter) {
+          cppUpdateEventEmitterMountItems.push_back(
+              CppMountItem::UpdateEventEmitterMountItem(
+                  mutation.newChildShadowView));
         }
         break;
       }
       case ShadowViewMutation::Insert: {
         if (!isVirtual) {
           // Insert item
-          mountItems[position++] =
-              createInsertMountItem(localJavaUIManager, mutation);
+          cppCommonMountItems.push_back(CppMountItem::InsertMountItem(
+              parentShadowView, newChildShadowView, index));
 
           if (disablePreallocateViews_ ||
-              mutation.newChildShadowView.props->revision > 1 ||
-              deletedViewTags.find(mutation.newChildShadowView.tag) !=
-                  deletedViewTags.end()) {
-            mountItems[position++] =
-                createUpdatePropsMountItem(localJavaUIManager, mutation);
+              newChildShadowView.props->revision > 1) {
+            cppUpdatePropsMountItems.push_back(
+                CppMountItem::UpdatePropsMountItem(newChildShadowView));
           }
 
           // State
-          if (mutation.newChildShadowView.state) {
-            mountItems[position++] =
-                createUpdateStateMountItem(localJavaUIManager, mutation);
+          if (newChildShadowView.state) {
+            cppUpdateStateMountItems.push_back(
+                CppMountItem::UpdateStateMountItem(newChildShadowView));
           }
 
           // Padding: padding mountItems must be executed before layout props
           // are updated in the view. This is necessary to ensure that events
           // (resulting from layout changes) are dispatched with the correct
           // padding information.
-          auto updatePaddingMountItem =
-              createUpdatePaddingMountItem(localJavaUIManager, mutation);
-          if (updatePaddingMountItem) {
-            mountItems[position++] = updatePaddingMountItem;
-          }
+          cppUpdatePaddingMountItems.push_back(
+              CppMountItem::UpdatePaddingMountItem(
+                  mutation.newChildShadowView));
 
           // Layout
-          auto updateLayoutMountItem =
-              createUpdateLayoutMountItem(localJavaUIManager, mutation);
-          if (updateLayoutMountItem) {
-            mountItems[position++] = updateLayoutMountItem;
-          }
+          cppUpdateLayoutMountItems.push_back(
+              CppMountItem::UpdateLayoutMountItem(mutation.newChildShadowView));
         }
 
         // EventEmitter
-        auto updateEventEmitterMountItem =
-            createUpdateEventEmitterMountItem(localJavaUIManager, mutation);
-        if (updateEventEmitterMountItem) {
-          mountItems[position++] = updateEventEmitterMountItem;
-        }
+        cppUpdateEventEmitterMountItems.push_back(
+            CppMountItem::UpdateEventEmitterMountItem(
+                mutation.newChildShadowView));
 
         break;
       }
@@ -839,27 +810,26 @@ void Binding::schedulerDidFinishTransaction(
     }
   }
 
-  // Handle remaining removals and deletions
-  if (shouldCollateRemovesAndDeletes_ && toRemove.size() > 0) {
-    mountItems[position++] =
-        createRemoveAndDeleteMultiMountItem(localJavaUIManager, toRemove);
-    toRemove.clear();
-  }
-
-  static auto createMountItemsBatchContainer =
+  // We now have all the information we need, including ordering of mount items,
+  // to know exactly how much space must be allocated
+  int batchMountItemIntsSize = 0;
+  int batchMountItemObjectsSize = 0;
+  computeBufferSizes(
+      batchMountItemIntsSize,
+      batchMountItemObjectsSize,
+      cppCommonMountItems,
+      cppDeleteMountItems,
+      cppUpdatePropsMountItems,
+      cppUpdateStateMountItems,
+      cppUpdatePaddingMountItems,
+      cppUpdateLayoutMountItems,
+      cppUpdateEventEmitterMountItems);
+
+  static auto createMountItemsIntBufferBatchContainer =
       jni::findClassStatic(Binding::UIManagerJavaDescriptor)
           ->getMethod<alias_ref<JMountItem>(
-              jint, jtypeArray<JMountItem::javaobject>, jint, jint)>(
-              "createBatchMountItem");
-
-  // If there are no items, we pass a nullptr instead of passing the object
-  // through the JNI
-  auto batch = createMountItemsBatchContainer(
-      localJavaUIManager,
-      surfaceId,
-      position == 0 ? nullptr : mountItemsArray.get(),
-      position,
-      commitNumber);
+              jint, jintArray, jtypeArray<jobject>, jint)>(
+              "createIntBufferBatchMountItem");
 
   static auto scheduleMountItem =
       jni::findClassStatic(Binding::UIManagerJavaDescriptor)
@@ -874,12 +844,285 @@ void Binding::schedulerDidFinishTransaction(
               jlong,
               jlong)>("scheduleMountItem");
 
+  if (batchMountItemIntsSize == 0) {
+    auto finishTransactionEndTime = telemetryTimePointNow();
+
+    scheduleMountItem(
+        localJavaUIManager,
+        nullptr,
+        telemetry.getRevisionNumber(),
+        telemetryTimePointToMilliseconds(telemetry.getCommitStartTime()),
+        telemetryTimePointToMilliseconds(telemetry.getDiffStartTime()),
+        telemetryTimePointToMilliseconds(telemetry.getDiffEndTime()),
+        telemetryTimePointToMilliseconds(telemetry.getLayoutStartTime()),
+        telemetryTimePointToMilliseconds(telemetry.getLayoutEndTime()),
+        telemetryTimePointToMilliseconds(finishTransactionStartTime),
+        telemetryTimePointToMilliseconds(finishTransactionEndTime));
+    return;
+  }
+
+  // Allocate the intBuffer and object array, now that we know exact sizes
+  // necessary
+  // TODO: don't allocate at all if size is zero
+  jintArray intBufferArray = env->NewIntArray(batchMountItemIntsSize);
+  local_ref<JArrayClass<jobject>> objBufferArray =
+      JArrayClass<jobject>::newArray(batchMountItemObjectsSize);
+
+  // Fill in arrays
+  int intBufferPosition = 0;
+  int objBufferPosition = 0;
+  int prevMountItemType = -1;
+  jint temp[7];
+  for (int i = 0; i < cppCommonMountItems.size(); i++) {
+    const auto &mountItem = cppCommonMountItems[i];
+    const auto &mountItemType = mountItem.type;
+
+    // Get type here, and count forward how many items of this type are in a
+    // row. Write preamble to any common type here.
+    if (prevMountItemType != mountItemType) {
+      int numSameItemTypes = 1;
+      for (int j = i + 1; j < cppCommonMountItems.size() &&
+           cppCommonMountItems[j].type == mountItemType;
+           j++) {
+        numSameItemTypes++;
+      }
+
+      writeIntBufferTypePreamble(
+          mountItemType,
+          numSameItemTypes,
+          env,
+          intBufferArray,
+          intBufferPosition);
+    }
+    prevMountItemType = mountItemType;
+
+    // TODO: multi-create, multi-insert, etc
+    if (mountItemType == CppMountItem::Type::Create) {
+      local_ref<JString> componentName =
+          getPlatformComponentName(mountItem.newChildShadowView);
+
+      int isLayoutable =
+          mountItem.newChildShadowView.layoutMetrics != EmptyLayoutMetrics ? 1
+                                                                           : 0;
+
+      local_ref<ReadableMap::javaobject> props =
+          castReadableMap(ReadableNativeMap::newObjectCxxArgs(
+              mountItem.newChildShadowView.props->rawProps));
+
+      // Do not hold onto Java object from C
+      // We DO want to hold onto C object from Java, since we don't know the
+      // lifetime of the Java object
+      local_ref<StateWrapperImpl::JavaPart> javaStateWrapper = nullptr;
+      if (mountItem.newChildShadowView.state != nullptr) {
+        javaStateWrapper = StateWrapperImpl::newObjectJavaArgs();
+        StateWrapperImpl *cStateWrapper = cthis(javaStateWrapper);
+        cStateWrapper->state_ = mountItem.newChildShadowView.state;
+      }
+
+      // Do not hold a reference to javaEventEmitter from the C++ side.
+      SharedEventEmitter eventEmitter =
+          mountItem.newChildShadowView.eventEmitter;
+      auto javaEventEmitter = EventEmitterWrapper::newObjectJavaArgs();
+      EventEmitterWrapper *cEventEmitter = cthis(javaEventEmitter);
+      if (enableEventEmitterRawPointer_) {
+        cEventEmitter->eventEmitterPointer = eventEmitter.get();
+      } else {
+        cEventEmitter->eventEmitter = eventEmitter;
+      }
+      temp[0] = mountItem.newChildShadowView.tag;
+      temp[1] = isLayoutable;
+      env->SetIntArrayRegion(intBufferArray, intBufferPosition, 2, temp);
+      intBufferPosition += 2;
+
+      (*objBufferArray)[objBufferPosition++] = componentName.get();
+      (*objBufferArray)[objBufferPosition++] = props.get();
+      (*objBufferArray)[objBufferPosition++] =
+          javaStateWrapper != nullptr ? javaStateWrapper.get() : nullptr;
+      (*objBufferArray)[objBufferPosition++] = javaEventEmitter.get();
+    } else if (mountItemType == CppMountItem::Type::Insert) {
+      temp[0] = mountItem.newChildShadowView.tag;
+      temp[1] = mountItem.parentShadowView.tag;
+      temp[2] = mountItem.index;
+      env->SetIntArrayRegion(intBufferArray, intBufferPosition, 3, temp);
+      intBufferPosition += 3;
+    } else if (mountItemType == CppMountItem::Remove) {
+      temp[0] = mountItem.oldChildShadowView.tag;
+      temp[1] = mountItem.parentShadowView.tag;
+      temp[2] = mountItem.index;
+      env->SetIntArrayRegion(intBufferArray, intBufferPosition, 3, temp);
+      intBufferPosition += 3;
+    } else {
+      LOG(ERROR) << "Unexpected CppMountItem type";
+    }
+  }
+  if (cppUpdatePropsMountItems.size() > 0) {
+    writeIntBufferTypePreamble(
+        CppMountItem::Type::UpdateProps,
+        cppUpdatePropsMountItems.size(),
+        env,
+        intBufferArray,
+        intBufferPosition);
+
+    for (const auto &mountItem : cppUpdatePropsMountItems) {
+      temp[0] = mountItem.newChildShadowView.tag;
+      env->SetIntArrayRegion(intBufferArray, intBufferPosition, 1, temp);
+      intBufferPosition += 1;
+
+      auto newProps = mountItem.newChildShadowView.props->rawProps;
+      local_ref<ReadableMap::javaobject> newPropsReadableMap =
+          castReadableMap(ReadableNativeMap::newObjectCxxArgs(newProps));
+      (*objBufferArray)[objBufferPosition++] = newPropsReadableMap.get();
+    }
+  }
+  if (cppUpdateStateMountItems.size() > 0) {
+    writeIntBufferTypePreamble(
+        CppMountItem::Type::UpdateState,
+        cppUpdateStateMountItems.size(),
+        env,
+        intBufferArray,
+        intBufferPosition);
+
+    for (const auto &mountItem : cppUpdateStateMountItems) {
+      temp[0] = mountItem.newChildShadowView.tag;
+      env->SetIntArrayRegion(intBufferArray, intBufferPosition, 1, temp);
+      intBufferPosition += 1;
+
+      auto state = mountItem.newChildShadowView.state;
+      // Do not hold onto Java object from C
+      // We DO want to hold onto C object from Java, since we don't know the
+      // lifetime of the Java object
+      local_ref<StateWrapperImpl::JavaPart> javaStateWrapper = nullptr;
+      if (state != nullptr) {
+        javaStateWrapper = StateWrapperImpl::newObjectJavaArgs();
+        StateWrapperImpl *cStateWrapper = cthis(javaStateWrapper);
+        cStateWrapper->state_ = state;
+      }
+
+      (*objBufferArray)[objBufferPosition++] =
+          (javaStateWrapper != nullptr ? javaStateWrapper.get() : nullptr);
+    }
+  }
+  if (cppUpdatePaddingMountItems.size() > 0) {
+    writeIntBufferTypePreamble(
+        CppMountItem::Type::UpdatePadding,
+        cppUpdatePaddingMountItems.size(),
+        env,
+        intBufferArray,
+        intBufferPosition);
+
+    for (const auto &mountItem : cppUpdatePaddingMountItems) {
+      auto layoutMetrics = mountItem.newChildShadowView.layoutMetrics;
+      auto pointScaleFactor = layoutMetrics.pointScaleFactor;
+      auto contentInsets = layoutMetrics.contentInsets;
+
+      int left = floor(scale(contentInsets.left, pointScaleFactor));
+      int top = floor(scale(contentInsets.top, pointScaleFactor));
+      int right = floor(scale(contentInsets.right, pointScaleFactor));
+      int bottom = floor(scale(contentInsets.bottom, pointScaleFactor));
+
+      temp[0] = mountItem.newChildShadowView.tag;
+      temp[1] = left;
+      temp[2] = top;
+      temp[3] = right;
+      temp[4] = bottom;
+      env->SetIntArrayRegion(intBufferArray, intBufferPosition, 5, temp);
+      intBufferPosition += 5;
+    }
+  }
+  if (cppUpdateLayoutMountItems.size() > 0) {
+    writeIntBufferTypePreamble(
+        CppMountItem::Type::UpdateLayout,
+        cppUpdateLayoutMountItems.size(),
+        env,
+        intBufferArray,
+        intBufferPosition);
+
+    for (const auto &mountItem : cppUpdateLayoutMountItems) {
+      auto layoutMetrics = mountItem.newChildShadowView.layoutMetrics;
+      auto pointScaleFactor = layoutMetrics.pointScaleFactor;
+      auto frame = layoutMetrics.frame;
+
+      int x = round(scale(frame.origin.x, pointScaleFactor));
+      int y = round(scale(frame.origin.y, pointScaleFactor));
+      int w = round(scale(frame.size.width, pointScaleFactor));
+      int h = round(scale(frame.size.height, pointScaleFactor));
+      int displayType =
+          toInt(mountItem.newChildShadowView.layoutMetrics.displayType);
+
+      temp[0] = mountItem.newChildShadowView.tag;
+      temp[1] = x;
+      temp[2] = y;
+      temp[3] = w;
+      temp[4] = h;
+      temp[5] = displayType;
+      env->SetIntArrayRegion(intBufferArray, intBufferPosition, 6, temp);
+      intBufferPosition += 6;
+    }
+  }
+  if (cppUpdateEventEmitterMountItems.size() > 0) {
+    writeIntBufferTypePreamble(
+        CppMountItem::Type::UpdateEventEmitter,
+        cppUpdateEventEmitterMountItems.size(),
+        env,
+        intBufferArray,
+        intBufferPosition);
+
+    for (const auto &mountItem : cppUpdateEventEmitterMountItems) {
+      temp[0] = mountItem.newChildShadowView.tag;
+      env->SetIntArrayRegion(intBufferArray, intBufferPosition, 1, temp);
+      intBufferPosition += 1;
+
+      SharedEventEmitter eventEmitter =
+          mountItem.newChildShadowView.eventEmitter;
+
+      // Do not hold a reference to javaEventEmitter from the C++ side.
+      auto javaEventEmitter = EventEmitterWrapper::newObjectJavaArgs();
+      EventEmitterWrapper *cEventEmitter = cthis(javaEventEmitter);
+      if (enableEventEmitterRawPointer_) {
+        cEventEmitter->eventEmitterPointer = eventEmitter.get();
+      } else {
+        cEventEmitter->eventEmitter = eventEmitter;
+      }
+
+      (*objBufferArray)[objBufferPosition++] = javaEventEmitter.get();
+    }
+  }
+
+  // Write deletes last - so that all prop updates, etc, for the tag in the same
+  // batch don't fail. Without additional machinery, moving deletes here
+  // requires that the differ never produces "DELETE...CREATE" in that order for
+  // the same tag. It's nice to be able to batch all similar operations together
+  // for space efficiency.
+  if (cppDeleteMountItems.size() > 0) {
+    writeIntBufferTypePreamble(
+        CppMountItem::Type::Delete,
+        cppDeleteMountItems.size(),
+        env,
+        intBufferArray,
+        intBufferPosition);
+
+    for (const auto &mountItem : cppDeleteMountItems) {
+      temp[0] = mountItem.oldChildShadowView.tag;
+      env->SetIntArrayRegion(intBufferArray, intBufferPosition, 1, temp);
+      intBufferPosition += 1;
+    }
+  }
+
+  // If there are no items, we pass a nullptr instead of passing the object
+  // through the JNI
+  auto batch = createMountItemsIntBufferBatchContainer(
+      localJavaUIManager,
+      surfaceId,
+      batchMountItemIntsSize == 0 ? nullptr : intBufferArray,
+      batchMountItemObjectsSize == 0 ? nullptr : objBufferArray.get(),
+      revisionNumber);
+
   auto finishTransactionEndTime = telemetryTimePointNow();
 
   scheduleMountItem(
       localJavaUIManager,
       batch.get(),
-      telemetry.getCommitNumber(),
+      telemetry.getRevisionNumber(),
       telemetryTimePointToMilliseconds(telemetry.getCommitStartTime()),
       telemetryTimePointToMilliseconds(telemetry.getDiffStartTime()),
       telemetryTimePointToMilliseconds(telemetry.getDiffEndTime()),
@@ -887,6 +1130,8 @@ void Binding::schedulerDidFinishTransaction(
       telemetryTimePointToMilliseconds(telemetry.getLayoutEndTime()),
       telemetryTimePointToMilliseconds(finishTransactionStartTime),
       telemetryTimePointToMilliseconds(finishTransactionEndTime));
+
+  env->DeleteLocalRef(intBufferArray);
 }
 
 void Binding::setPixelDensity(float pointScaleFactor) {
@@ -924,13 +1169,9 @@ void Binding::driveCxxAnimations() {
   scheduler_->animationTick();
 }
 
-void Binding::schedulerDidRequestPreliminaryViewAllocation(
+void Binding::preallocateShadowView(
     const SurfaceId surfaceId,
     const ShadowView &shadowView) {
-  if (disablePreallocateViews_) {
-    return;
-  }
-
   jni::global_ref<jobject> localJavaUIManager = getJavaUIManager();
   if (!localJavaUIManager) {
     LOG(ERROR)
@@ -940,15 +1181,16 @@ void Binding::schedulerDidRequestPreliminaryViewAllocation(
 
   bool isLayoutableShadowNode = shadowView.layoutMetrics != EmptyLayoutMetrics;
 
-  if (disableVirtualNodePreallocation_ && !isLayoutableShadowNode) {
-    return;
-  }
-
   static auto preallocateView =
       jni::findClassStatic(Binding::UIManagerJavaDescriptor)
           ->getMethod<void(
-              jint, jint, jstring, ReadableMap::javaobject, jobject, jboolean)>(
-              "preallocateView");
+              jint,
+              jint,
+              jstring,
+              ReadableMap::javaobject,
+              jobject,
+              jobject,
+              jboolean)>("preallocateView");
 
   // Do not hold onto Java object from C
   // We DO want to hold onto C object from Java, since we don't know the
@@ -960,6 +1202,21 @@ void Binding::schedulerDidRequestPreliminaryViewAllocation(
     cStateWrapper->state_ = shadowView.state;
   }
 
+  // Do not hold a reference to javaEventEmitter from the C++ side.
+  local_ref<EventEmitterWrapper::JavaPart> javaEventEmitter = nullptr;
+  if (enableEarlyEventEmitterUpdate_) {
+    SharedEventEmitter eventEmitter = shadowView.eventEmitter;
+    if (eventEmitter != nullptr) {
+      javaEventEmitter = EventEmitterWrapper::newObjectJavaArgs();
+      EventEmitterWrapper *cEventEmitter = cthis(javaEventEmitter);
+      if (enableEventEmitterRawPointer_) {
+        cEventEmitter->eventEmitterPointer = eventEmitter.get();
+      } else {
+        cEventEmitter->eventEmitter = eventEmitter;
+      }
+    }
+  }
+
   local_ref<ReadableMap::javaobject> props = castReadableMap(
       ReadableNativeMap::newObjectCxxArgs(shadowView.props->rawProps));
   auto component = getPlatformComponentName(shadowView);
@@ -971,9 +1228,55 @@ void Binding::schedulerDidRequestPreliminaryViewAllocation(
       component.get(),
       props.get(),
       (javaStateWrapper != nullptr ? javaStateWrapper.get() : nullptr),
+      (javaEventEmitter != nullptr ? javaEventEmitter.get() : nullptr),
       isLayoutableShadowNode);
 }
 
+void Binding::schedulerDidRequestPreliminaryViewAllocation(
+    const SurfaceId surfaceId,
+    const ShadowNode &shadowNode) {
+  if (disablePreallocateViews_) {
+    return;
+  }
+
+  auto shadowView = ShadowView(shadowNode);
+
+  if (!shadowView.traits.check(ShadowNodeTraits::Trait::FormsView)) {
+    return;
+  }
+
+  preallocateShadowView(surfaceId, shadowView);
+}
+
+void Binding::schedulerDidCloneShadowNode(
+    SurfaceId surfaceId,
+    const ShadowNode &oldShadowNode,
+    const ShadowNode &newShadowNode) {
+  // This is only necessary if view preallocation was skipped during
+  // createShadowNode
+
+  // We may need to PreAllocate a ShadowNode at this point if this is the
+  // earliest point it is possible to do so:
+  // 1. The revision is exactly 1
+  // 2. At revision 0 (the old node), View Preallocation would have been skipped
+
+  if (!disableRevisionCheckForPreallocation_) {
+    if (newShadowNode.getProps()->revision != 1) {
+      return;
+    }
+    if (oldShadowNode.getProps()->revision != 0) {
+      return;
+    }
+  }
+
+  // If the new node is concrete and the old wasn't, we can preallocate
+  if (!oldShadowNode.getTraits().check(ShadowNodeTraits::Trait::FormsView) &&
+      newShadowNode.getTraits().check(ShadowNodeTraits::Trait::FormsView)) {
+    auto shadowView = ShadowView(newShadowNode);
+    preallocateShadowView(surfaceId, shadowView);
+  }
+}
+
 void Binding::schedulerDidDispatchCommand(
     const ShadowView &shadowView,
     std::string const &commandName,
@@ -987,7 +1290,7 @@ void Binding::schedulerDidDispatchCommand(
 
   static auto dispatchCommand =
       jni::findClassStatic(Binding::UIManagerJavaDescriptor)
-          ->getMethod<void(jint, jstring, ReadableArray::javaobject)>(
+          ->getMethod<void(jint, jint, jstring, ReadableArray::javaobject)>(
               "dispatchCommand");
 
   local_ref<JString> command = make_jstring(commandName);
@@ -996,62 +1299,92 @@ void Binding::schedulerDidDispatchCommand(
       castReadableArray(ReadableNativeArray::newObjectCxxArgs(args));
 
   dispatchCommand(
-      localJavaUIManager, shadowView.tag, command.get(), argsArray.get());
+      localJavaUIManager,
+      shadowView.surfaceId,
+      shadowView.tag,
+      command.get(),
+      argsArray.get());
 }
 
-void Binding::schedulerDidSetJSResponder(
-    SurfaceId surfaceId,
+void Binding::schedulerDidSendAccessibilityEvent(
     const ShadowView &shadowView,
-    const ShadowView &initialShadowView,
-    bool blockNativeResponder) {
+    std::string const &eventType) {
   jni::global_ref<jobject> localJavaUIManager = getJavaUIManager();
   if (!localJavaUIManager) {
-    LOG(ERROR) << "Binding::schedulerSetJSResponder: JavaUIManager disappeared";
+    LOG(ERROR)
+        << "Binding::schedulerDidDispatchCommand: JavaUIManager disappeared";
     return;
   }
 
-  static auto setJSResponder =
+  local_ref<JString> eventTypeStr = make_jstring(eventType);
+
+  static auto sendAccessibilityEventFromJS =
       jni::findClassStatic(Binding::UIManagerJavaDescriptor)
-          ->getMethod<void(jint, jint, jboolean)>("setJSResponder");
+          ->getMethod<void(jint, jint, jstring)>(
+              "sendAccessibilityEventFromJS");
 
-  setJSResponder(
+  sendAccessibilityEventFromJS(
       localJavaUIManager,
+      shadowView.surfaceId,
       shadowView.tag,
-      initialShadowView.tag,
-      (jboolean)blockNativeResponder);
+      eventTypeStr.get());
 }
 
-void Binding::schedulerDidClearJSResponder() {
+void Binding::schedulerDidSetIsJSResponder(
+    ShadowView const &shadowView,
+    bool isJSResponder,
+    bool blockNativeResponder) {
   jni::global_ref<jobject> localJavaUIManager = getJavaUIManager();
   if (!localJavaUIManager) {
-    LOG(ERROR)
-        << "Binding::schedulerClearJSResponder: JavaUIManager disappeared";
+    LOG(ERROR) << "Binding::schedulerSetJSResponder: JavaUIManager disappeared";
     return;
   }
 
+  static auto setJSResponder =
+      jni::findClassStatic(Binding::UIManagerJavaDescriptor)
+          ->getMethod<void(jint, jint, jint, jboolean)>("setJSResponder");
+
   static auto clearJSResponder =
       jni::findClassStatic(Binding::UIManagerJavaDescriptor)
           ->getMethod<void()>("clearJSResponder");
 
-  clearJSResponder(localJavaUIManager);
+  if (isJSResponder) {
+    setJSResponder(
+        localJavaUIManager,
+        shadowView.surfaceId,
+        shadowView.tag,
+        // The closest non-flattened ancestor of the same value if the node is
+        // not flattened. For now, we don't support the case when the node can
+        // be flattened because the only component that uses this feature -
+        // ScrollView - cannot be flattened.
+        shadowView.tag,
+        (jboolean)blockNativeResponder);
+  } else {
+    clearJSResponder(localJavaUIManager);
+  }
 }
 
 void Binding::registerNatives() {
-  registerHybrid(
-      {makeNativeMethod("initHybrid", Binding::initHybrid),
-       makeNativeMethod(
-           "installFabricUIManager", Binding::installFabricUIManager),
-       makeNativeMethod("startSurface", Binding::startSurface),
-       makeNativeMethod(
-           "startSurfaceWithConstraints", Binding::startSurfaceWithConstraints),
-       makeNativeMethod(
-           "renderTemplateToSurface", Binding::renderTemplateToSurface),
-       makeNativeMethod("stopSurface", Binding::stopSurface),
-       makeNativeMethod("setConstraints", Binding::setConstraints),
-       makeNativeMethod("setPixelDensity", Binding::setPixelDensity),
-       makeNativeMethod("driveCxxAnimations", Binding::driveCxxAnimations),
-       makeNativeMethod(
-           "uninstallFabricUIManager", Binding::uninstallFabricUIManager)});
+  registerHybrid({
+      makeNativeMethod("initHybrid", Binding::initHybrid),
+      makeNativeMethod(
+          "installFabricUIManager", Binding::installFabricUIManager),
+      makeNativeMethod("startSurface", Binding::startSurface),
+      makeNativeMethod(
+          "getInspectorDataForInstance", Binding::getInspectorDataForInstance),
+      makeNativeMethod(
+          "startSurfaceWithConstraints", Binding::startSurfaceWithConstraints),
+      makeNativeMethod(
+          "renderTemplateToSurface", Binding::renderTemplateToSurface),
+      makeNativeMethod("stopSurface", Binding::stopSurface),
+      makeNativeMethod("setConstraints", Binding::setConstraints),
+      makeNativeMethod("setPixelDensity", Binding::setPixelDensity),
+      makeNativeMethod("driveCxxAnimations", Binding::driveCxxAnimations),
+      makeNativeMethod(
+          "uninstallFabricUIManager", Binding::uninstallFabricUIManager),
+      makeNativeMethod("registerSurface", Binding::registerSurface),
+      makeNativeMethod("unregisterSurface", Binding::unregisterSurface),
+  });
 }
 
 } // namespace react