From 9a25e8fd83ee1180b54ef4ab653437575c05ece9 Mon Sep 17 00:00:00 2001
From: Oskar Pawica <pawicao@gmail.com>
Date: Mon, 17 Aug 2026 10:58:32 +0200
Subject: [PATCH 1/2] Implement final-state-first mount delivery for native
 layout animations

Layout code stores an already prepared, owned AnimationRequest while it
intercepts a mounting transaction. A layout-owned pending-start store
(PendingNativeLayoutStarts) submits it to the shared service only after
the platform mount boundary reports the intended Fabric mount. The Apple
boundary uses the synchronous RCTSurfacePresenterObserver signal, which
fires after the mount instructions and before paint (D018).

Before submission the store validates that the surface still runs, the
handle is not cancelled or duplicated, and the mounted view still shows
the expected final layout and final props. Surface teardown rejects
queued records once and blocks later work until a new surface instance
starts. Objective 07 will call the same enqueueNativeLayoutStart entry
from production interception; a dev-only bench screen and common tests
pass controlled prepared requests through it today.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 .../FinalStateFirstBenchExample.tsx           |  97 ++++
 .../src/apps/reanimated/examples/index.ts     |   8 +
 apps/fabric-example/ios/Podfile.lock          |   2 +-
 packages/react-native-reanimated/CHANGELOG.md |   1 +
 .../LayoutAnimationsProxyCommon.cpp           |  68 +++
 .../LayoutAnimationsProxyCommon.h             |  24 +-
 .../LayoutAnimationsProxy_Experimental.h      |   2 +
 .../LayoutAnimationsProxy_Legacy.cpp          | 109 ++++
 .../LayoutAnimationsProxy_Legacy.h            |  10 +
 .../LayoutAnimations/LayoutMountBoundary.h    |  38 ++
 .../PendingNativeLayoutStarts.cpp             | 195 ++++++++
 .../PendingNativeLayoutStarts.h               |  77 +++
 .../NativeAnimations/NativeAnimationTrace.cpp |   4 +-
 .../NativeAnimations/NativeAnimationTrace.h   |   6 +-
 .../NativeAnimations/tests/CMakeLists.txt     |   8 +-
 .../tests/NativeAnimationServiceTest.cc       |   3 +
 .../tests/PendingNativeLayoutStartsTest.cc    | 470 ++++++++++++++++++
 .../NativeModules/ReanimatedModuleProxy.cpp   |  12 +-
 .../NativeModules/ReanimatedModuleProxy.h     |   1 +
 .../Tools/PlatformDepMethodsHolder.h          |   4 +-
 .../AppleLayoutMountBoundary.h                |  15 +
 .../AppleLayoutMountBoundary.mm               | 151 ++++++
 .../native/PlatformDepMethodsHolderImpl.mm    |   4 +
 23 files changed, 1301 insertions(+), 8 deletions(-)
 create mode 100644 apps/common-app/src/apps/reanimated/examples/LayoutAnimations/FinalStateFirstBenchExample.tsx
 create mode 100644 packages/react-native-reanimated/Common/cpp/reanimated/LayoutAnimations/LayoutMountBoundary.h
 create mode 100644 packages/react-native-reanimated/Common/cpp/reanimated/LayoutAnimations/PendingNativeLayoutStarts.cpp
 create mode 100644 packages/react-native-reanimated/Common/cpp/reanimated/LayoutAnimations/PendingNativeLayoutStarts.h
 create mode 100644 packages/react-native-reanimated/Common/cpp/reanimated/NativeAnimations/tests/PendingNativeLayoutStartsTest.cc
 create mode 100644 packages/react-native-reanimated/apple/reanimated/apple/NativeAnimations/AppleLayoutMountBoundary.h
 create mode 100644 packages/react-native-reanimated/apple/reanimated/apple/NativeAnimations/AppleLayoutMountBoundary.mm

diff --git a/apps/common-app/src/apps/reanimated/examples/LayoutAnimations/FinalStateFirstBenchExample.tsx b/apps/common-app/src/apps/reanimated/examples/LayoutAnimations/FinalStateFirstBenchExample.tsx
new file mode 100644
index 000000000000..c22b40ba757a
--- /dev/null
+++ b/apps/common-app/src/apps/reanimated/examples/LayoutAnimations/FinalStateFirstBenchExample.tsx
@@ -0,0 +1,97 @@
+import { useState } from 'react';
+import { Alert, Button, Pressable, StyleSheet, Text, View } from 'react-native';
+
+// Final-state-first bench (Objective 06). The nativeID markers below make the
+// Legacy proxy enqueue controlled prepared native requests on example-app
+// builds with IOS_LAYOUT_ANIMATIONS_CORE_ANIMATION on; no production Layout
+// Animations run here. With the flag on, the box slides 5 s (taps land at the
+// final frame) and the delayed view holds invisible for 1 s, then fades in.
+// With the flag off, both views jump.
+
+const LAYOUT_BENCH_NATIVE_ID = 'fsf-bench-layout';
+const ENTERING_BENCH_NATIVE_ID = 'fsf-bench-entering';
+
+export default function FinalStateFirstBenchExample() {
+  const [moved, setMoved] = useState(false);
+  const [entered, setEntered] = useState(false);
+  const [lastTap, setLastTap] = useState('none');
+
+  return (
+    <View style={styles.container}>
+      <Text style={styles.header}>Final-state-first bench (Objective 06)</Text>
+
+      <Text style={styles.label}>Layout: A → B over 5 s</Text>
+      <Button title="Move box" onPress={() => setMoved((prev) => !prev)} />
+      <View style={styles.arena}>
+        <Pressable
+          nativeID={LAYOUT_BENCH_NATIVE_ID}
+          testID="fsf-layout-box"
+          onPress={() => {
+            setLastTap(moved ? 'B (final)' : 'A (final)');
+            Alert.alert('Tapped', 'The tap used the mounted final frame.');
+          }}
+          style={[styles.box, moved ? styles.boxMoved : null]}>
+          <Text style={styles.boxLabel}>tap me</Text>
+        </Pressable>
+      </View>
+      <Text style={styles.label}>Last registered tap position: {lastTap}</Text>
+
+      <Text style={styles.label}>Entering: 1 s delay, 2 s fade</Text>
+      <Button
+        title={entered ? 'Unmount delayed view' : 'Mount delayed view'}
+        onPress={() => setEntered((prev) => !prev)}
+      />
+      <View style={styles.arena}>
+        {entered ? (
+          <View
+            nativeID={ENTERING_BENCH_NATIVE_ID}
+            testID="fsf-entering-box"
+            style={[styles.box, styles.enteringBox]}>
+            <Text style={styles.boxLabel}>entered</Text>
+          </View>
+        ) : null}
+      </View>
+    </View>
+  );
+}
+
+const styles = StyleSheet.create({
+  container: {
+    flex: 1,
+    padding: 16,
+    gap: 8,
+  },
+  header: {
+    fontSize: 18,
+    fontWeight: 'bold',
+  },
+  label: {
+    fontSize: 14,
+  },
+  arena: {
+    height: 160,
+    borderWidth: StyleSheet.hairlineWidth,
+    borderColor: 'gray',
+    justifyContent: 'flex-start',
+    alignItems: 'flex-start',
+  },
+  box: {
+    width: 100,
+    height: 60,
+    backgroundColor: 'navy',
+    justifyContent: 'center',
+    alignItems: 'center',
+  },
+  boxMoved: {
+    marginLeft: 220,
+    marginTop: 80,
+  },
+  enteringBox: {
+    backgroundColor: 'darkgreen',
+    marginLeft: 40,
+    marginTop: 40,
+  },
+  boxLabel: {
+    color: 'white',
+  },
+});
diff --git a/apps/common-app/src/apps/reanimated/examples/index.ts b/apps/common-app/src/apps/reanimated/examples/index.ts
index 19f72d96b95c..f8ebbbfcb055 100644
--- a/apps/common-app/src/apps/reanimated/examples/index.ts
+++ b/apps/common-app/src/apps/reanimated/examples/index.ts
@@ -210,6 +210,10 @@ const FlatListExample: React.FC = () =>
   React.createElement(
     require('./SharedElementTransitions/FlatList').default as React.FC
   );
+const FinalStateFirstBench: React.FC = () =>
+  React.createElement(
+    require('./LayoutAnimations/FinalStateFirstBenchExample').default
+  );
 const FlatListSkipEnteringExiting: React.FC = () =>
   React.createElement(
     require('./LayoutAnimations/FlatListSkipEnteringExiting').default
@@ -1192,6 +1196,10 @@ export const EXAMPLES: Record<string, Example> = {
     title: '[LA] Strict Mode Comparison',
     screen: StrictModeComparison,
   },
+  FinalStateFirstBench: {
+    title: '[LA] Final-state-first bench',
+    screen: FinalStateFirstBench,
+  },
   ReactionsCounterExample: {
     title: '[LA] Reactions counter',
     screen: ReactionsCounterExample,
diff --git a/apps/fabric-example/ios/Podfile.lock b/apps/fabric-example/ios/Podfile.lock
index 6e2ce9fcc317..009383b31cd6 100644
--- a/apps/fabric-example/ios/Podfile.lock
+++ b/apps/fabric-example/ios/Podfile.lock
@@ -2441,7 +2441,7 @@ SPEC CHECKSUMS:
   RNCClipboard: f2c861be2669e65f3efa4618c22c95ba1b6dadda
   RNCMaskedView: d4884d6b3b256bd1830a211db3d5f551def82e36
   RNGestureHandler: f09eca0b47053142f7543f5c71d183f215ba5d81
-  RNReanimated: eafd4d6a9bb890ca2b498d42942d9c83c2f6f30e
+  RNReanimated: 7d2a92550e0e973bf4b64be1959e69772b410c00
   RNScreens: a2103f13fa603c405092daf70ca4eb3a6291fd6d
   RNSVG: 6c9bcbf53822153be6f6c1484f6b0b57c0040d21
   RNWorklets: da0d13711190e9ecee4d78b1f16790502ccb5ba3
diff --git a/packages/react-native-reanimated/CHANGELOG.md b/packages/react-native-reanimated/CHANGELOG.md
index 521da6422588..09ab15da2705 100644
--- a/packages/react-native-reanimated/CHANGELOG.md
+++ b/packages/react-native-reanimated/CHANGELOG.md
@@ -9,6 +9,7 @@
 ### 🎉 New features
 
 - Add feature-flagged Shared Native Animation Boundary for CSS Transitions and future Layout Animations ([#10276](https://github.com/software-mansion/react-native-reanimated/pull/10276) by [@pawicao](https://github.com/pawicao))
+- Add feature-flagged final-state-first mount delivery for future native Layout Animations on iOS (by [@pawicao](https://github.com/pawicao))
 
 ### 🐛 Bug fixes
 
diff --git a/packages/react-native-reanimated/Common/cpp/reanimated/LayoutAnimations/LayoutAnimationsProxyCommon.cpp b/packages/react-native-reanimated/Common/cpp/reanimated/LayoutAnimations/LayoutAnimationsProxyCommon.cpp
index aabf0187a8b4..11100fe2d8ed 100644
--- a/packages/react-native-reanimated/Common/cpp/reanimated/LayoutAnimations/LayoutAnimationsProxyCommon.cpp
+++ b/packages/react-native-reanimated/Common/cpp/reanimated/LayoutAnimations/LayoutAnimationsProxyCommon.cpp
@@ -16,6 +16,74 @@ size_t LayoutAnimationsProxyCommon::FrameDrivenLeaseKeyHash::operator()(const Fr
   return facebook::react::hash_combine(key.surfaceId, key.tag);
 }
 
+namespace {
+
+struct LayoutPendingViewSnapshot final : public PendingLayoutViewSnapshot {
+  LayoutPendingViewSnapshot(ShadowView oldView, ShadowView finalView)
+      : oldView(std::move(oldView)), finalView(std::move(finalView)) {}
+
+  ShadowView oldView;
+  ShadowView finalView;
+};
+
+} // namespace
+
+std::shared_ptr<PendingNativeLayoutStarts> LayoutAnimationsProxyCommon::makePendingNativeLayoutStarts(
+    const std::shared_ptr<native_animation::NativeAnimationService> &nativeAnimationService,
+    const std::shared_ptr<LayoutMountBoundary> &layoutMountBoundary) {
+  if (!useNativeLayoutAnimations() || !nativeAnimationService || !layoutMountBoundary) {
+    return nullptr;
+  }
+  auto pendingStarts = std::make_shared<PendingNativeLayoutStarts>(nativeAnimationService, layoutMountBoundary);
+  layoutMountBoundary->setPostMountObserver(
+      [weakPendingStarts = std::weak_ptr<PendingNativeLayoutStarts>(pendingStarts)](const SurfaceId surfaceId) {
+        if (const auto pendingStarts = weakPendingStarts.lock()) {
+          pendingStarts->drainAfterMount(surfaceId);
+        }
+      });
+  return pendingStarts;
+}
+
+void LayoutAnimationsProxyCommon::enqueueNativeLayoutStart(
+    const LayoutAnimationType type,
+    const ShadowView &oldView,
+    const ShadowView &finalView,
+    const MountingTransaction::Number transactionNumber,
+    native_animation::AnimationRequest request,
+    native_animation::AnimationCallbacks callbacks) const {
+  react_native_assert(pendingNativeStarts_ != nullptr && "native layout start delivery is not available");
+  const auto handle = request.handle;
+  pendingNativeStarts_->enqueue({
+      handle,
+      transactionNumber,
+      type,
+      finalView.layoutMetrics.frame,
+      // The snapshot below keeps this props object alive while pending.
+      reinterpret_cast<uintptr_t>(finalView.props.get()),
+      std::make_unique<LayoutPendingViewSnapshot>(oldView, finalView),
+      std::move(request),
+      std::move(callbacks),
+  });
+}
+
+void LayoutAnimationsProxyCommon::cancelNativeLayoutStart(const native_animation::AnimationHandle &handle) const {
+  if (pendingNativeStarts_) {
+    pendingNativeStarts_->cancel(handle);
+  }
+}
+
+void LayoutAnimationsProxyCommon::notifyNativeStartsSurfaceStarted(const SurfaceId surfaceId) const {
+  if (pendingNativeStarts_) {
+    pendingNativeStarts_->notifySurfaceStarted(surfaceId);
+  }
+}
+
+void LayoutAnimationsProxyCommon::cancelNativeStartsSurface(const SurfaceId surfaceId) const {
+  if (pendingNativeStarts_) {
+    pendingNativeStarts_->cancelSurface(surfaceId);
+  }
+}
+
 std::optional<facebook::react::SurfaceId>
 LayoutAnimationsProxyCommon::onTransitionProgress(int tag, double progress, bool isClosing, bool isGoingForward) {
   return std::nullopt;
diff --git a/packages/react-native-reanimated/Common/cpp/reanimated/LayoutAnimations/LayoutAnimationsProxyCommon.h b/packages/react-native-reanimated/Common/cpp/reanimated/LayoutAnimations/LayoutAnimationsProxyCommon.h
index eec06a9f929c..9ee6ef83de7f 100644
--- a/packages/react-native-reanimated/Common/cpp/reanimated/LayoutAnimations/LayoutAnimationsProxyCommon.h
+++ b/packages/react-native-reanimated/Common/cpp/reanimated/LayoutAnimations/LayoutAnimationsProxyCommon.h
@@ -9,7 +9,9 @@
 #include <reanimated/LayoutAnimations/FrameDrivenAnimationLease.h>
 #include <reanimated/LayoutAnimations/LayoutAnimationType.h>
 #include <reanimated/LayoutAnimations/LayoutAnimationsManager.h>
+#include <reanimated/LayoutAnimations/LayoutMountBoundary.h>
 #include <reanimated/LayoutAnimations/LayoutNativeAnimationAdapter.h>
+#include <reanimated/LayoutAnimations/PendingNativeLayoutStarts.h>
 #include <reanimated/NativeAnimations/NativeAnimationService.h>
 #include <reanimated/Tools/FeatureFlags.h>
 #include <reanimated/Tools/PlatformDepMethodsHolder.h>
@@ -78,6 +80,7 @@ class LayoutAnimationsProxyCommon : public facebook::react::MountingOverrideDele
       jsi::Runtime &uiRuntime,
       const std::shared_ptr<UIScheduler> &uiScheduler,
       const std::shared_ptr<native_animation::NativeAnimationService> &nativeAnimationService,
+      const std::shared_ptr<LayoutMountBoundary> &layoutMountBoundary,
       const std::shared_ptr<facebook::react::UIManager> &uiManager
 #ifdef ANDROID
       ,
@@ -98,7 +101,8 @@ class LayoutAnimationsProxyCommon : public facebook::react::MountingOverrideDele
                       [uiScheduler](const native_animation::CallbackOperation &operation) {
                         scheduleOnUI(uiScheduler, operation);
                       })
-                : nullptr)
+                : nullptr),
+        pendingNativeStarts_(makePendingNativeLayoutStarts(nativeAnimationService, layoutMountBoundary))
 #ifdef ANDROID
         ,
         preserveMountedTags_(filterUnmountedTagsFunction),
@@ -125,7 +129,24 @@ class LayoutAnimationsProxyCommon : public facebook::react::MountingOverrideDele
   void releaseFrameDrivenLayoutAnimation(SurfaceId surfaceId, Tag tag, native_animation::AnimationOutcome outcome)
       const;
 
+  // Final-state-first delivery: stores an owned prepared request during
+  // interception; the pending store submits it after the intended mount.
+  void enqueueNativeLayoutStart(
+      LayoutAnimationType type,
+      const ShadowView &oldView,
+      const ShadowView &finalView,
+      MountingTransaction::Number transactionNumber,
+      native_animation::AnimationRequest request,
+      native_animation::AnimationCallbacks callbacks) const;
+  void cancelNativeLayoutStart(const native_animation::AnimationHandle &handle) const;
+  void notifyNativeStartsSurfaceStarted(SurfaceId surfaceId) const;
+  void cancelNativeStartsSurface(SurfaceId surfaceId) const;
+
  protected:
+  static std::shared_ptr<PendingNativeLayoutStarts> makePendingNativeLayoutStarts(
+      const std::shared_ptr<native_animation::NativeAnimationService> &nativeAnimationService,
+      const std::shared_ptr<LayoutMountBoundary> &layoutMountBoundary);
+
   void transferConfigFromNativeID(const std::string &nativeId, const int tag) const;
 
   mutable std::unordered_set<Tag> maybeSettledAnimationTags_;
@@ -137,6 +158,7 @@ class LayoutAnimationsProxyCommon : public facebook::react::MountingOverrideDele
   const std::shared_ptr<UIScheduler> uiScheduler_;
   std::shared_ptr<facebook::react::UIManager> uiManager_;
   const std::shared_ptr<LayoutNativeAnimationAdapter> nativeAnimationAdapter_;
+  const std::shared_ptr<PendingNativeLayoutStarts> pendingNativeStarts_;
   PreserveMountedTagsFunction preserveMountedTags_;
 
   struct FrameDrivenLeaseKey {
diff --git a/packages/react-native-reanimated/Common/cpp/reanimated/LayoutAnimations/LayoutAnimationsProxy_Experimental.h b/packages/react-native-reanimated/Common/cpp/reanimated/LayoutAnimations/LayoutAnimationsProxy_Experimental.h
index 27804f331ba9..233024f02af7 100644
--- a/packages/react-native-reanimated/Common/cpp/reanimated/LayoutAnimations/LayoutAnimationsProxy_Experimental.h
+++ b/packages/react-native-reanimated/Common/cpp/reanimated/LayoutAnimations/LayoutAnimationsProxy_Experimental.h
@@ -69,6 +69,7 @@ struct LayoutAnimationsProxy_Experimental : public LayoutAnimationsProxyCommon,
       jsi::Runtime &uiRuntime,
       const std::shared_ptr<UIScheduler> &uiScheduler,
       const std::shared_ptr<native_animation::NativeAnimationService> &nativeAnimationService,
+      const std::shared_ptr<LayoutMountBoundary> &layoutMountBoundary,
       const std::shared_ptr<UIManager> &uiManager
 #ifdef ANDROID
       ,
@@ -83,6 +84,7 @@ struct LayoutAnimationsProxy_Experimental : public LayoutAnimationsProxyCommon,
             uiRuntime,
             uiScheduler,
             nativeAnimationService,
+            layoutMountBoundary,
             uiManager
 #ifdef ANDROID
             ,
diff --git a/packages/react-native-reanimated/Common/cpp/reanimated/LayoutAnimations/LayoutAnimationsProxy_Legacy.cpp b/packages/react-native-reanimated/Common/cpp/reanimated/LayoutAnimations/LayoutAnimationsProxy_Legacy.cpp
index 0d3bc4b2ce9f..c572d7d99a61 100644
--- a/packages/react-native-reanimated/Common/cpp/reanimated/LayoutAnimations/LayoutAnimationsProxy_Legacy.cpp
+++ b/packages/react-native-reanimated/Common/cpp/reanimated/LayoutAnimations/LayoutAnimationsProxy_Legacy.cpp
@@ -9,6 +9,7 @@
 #include <ranges>
 #include <set>
 #include <string>
+#include <string_view>
 #include <thread>
 #include <unordered_map>
 #include <unordered_set>
@@ -34,6 +35,9 @@ std::optional<MountingTransaction> LayoutAnimationsProxy_Legacy::pullTransaction
   LOG(INFO) << "pullTransaction " << std::this_thread::get_id() << " " << surfaceId << std::endl;
 #endif
   auto lock = std::unique_lock<std::recursive_mutex>(mutex);
+#if defined(IS_REANIMATED_EXAMPLE_APP)
+  benchTransactionNumber_ = transactionNumber;
+#endif
   PropsParserContext propsParserContext{surfaceId, *contextContainer_};
   ShadowViewMutationList filteredMutations;
   auto &surfaceCtx = getSurfaceContext(surfaceId);
@@ -447,6 +451,12 @@ void LayoutAnimationsProxy_Legacy::handleUpdatesAndEnterings(
         }
 
         transferConfigFromNativeID(mutation.newChildShadowView.props->nativeId, mutation.newChildShadowView.tag);
+#if defined(IS_REANIMATED_EXAMPLE_APP)
+        if (maybeEnqueueFinalStateFirstBenchEntering(mutation)) {
+          filteredMutations.push_back(mutation);
+          continue;
+        }
+#endif
         if (!layoutAnimationsManager_->hasLayoutAnimation(tag, LayoutAnimationType::ENTERING)) {
           filteredMutations.push_back(mutation);
           continue;
@@ -474,6 +484,12 @@ void LayoutAnimationsProxy_Legacy::handleUpdatesAndEnterings(
       }
 
       case ShadowViewMutation::Type::Update: {
+#if defined(IS_REANIMATED_EXAMPLE_APP)
+        if (maybeEnqueueFinalStateFirstBenchLayout(mutation)) {
+          filteredMutations.push_back(mutation);
+          continue;
+        }
+#endif
         auto shouldAnimate = hasLayoutChanged(mutation);
         if (!layoutAnimationsManager_->hasLayoutAnimation(tag, LayoutAnimationType::LAYOUT) ||
             (!shouldAnimate && !layoutAnimations_.contains(tag))) {
@@ -1243,6 +1259,99 @@ inline bool MutationNode::isMutationNode() {
   return true;
 }
 
+#if defined(IS_REANIMATED_EXAMPLE_APP)
+
+// Final-state-first bench helpers. They never parse a Layout Animations
+// builder and never route production animations.
+
+namespace {
+
+constexpr std::string_view kFinalStateFirstBenchLayoutNativeId = "fsf-bench-layout";
+constexpr std::string_view kFinalStateFirstBenchEnteringNativeId = "fsf-bench-entering";
+
+bool hasBenchNativeId(const ShadowView &view, const std::string_view marker) {
+  return view.props != nullptr && view.props->nativeId == marker;
+}
+
+native_animation::AnimationPoint centerOfFrame(const facebook::react::Rect &frame) {
+  return {
+      frame.origin.x + frame.size.width / 2.0,
+      frame.origin.y + frame.size.height / 2.0,
+  };
+}
+
+} // namespace
+
+bool LayoutAnimationsProxy_Legacy::maybeEnqueueFinalStateFirstBenchLayout(const ShadowViewMutation &mutation) const {
+  if constexpr (!useNativeLayoutAnimations()) {
+    return false;
+  }
+  if (!pendingNativeStarts_ || !hasBenchNativeId(mutation.newChildShadowView, kFinalStateFirstBenchLayoutNativeId)) {
+    return false;
+  }
+  const auto &oldFrame = mutation.oldChildShadowView.layoutMetrics.frame;
+  const auto &finalFrame = mutation.newChildShadowView.layoutMetrics.frame;
+  if (oldFrame == finalFrame) {
+    return false;
+  }
+  const native_animation::AnimationHandle handle{
+      mutation.newChildShadowView.surfaceId,
+      mutation.newChildShadowView.tag,
+      native_animation::AnimationOwner::Layout,
+      ++frameDrivenGeneration_,
+  };
+  native_animation::AnimationTrack positionTrack{
+      {native_animation::AnimationTargetKind::Position},
+      native_animation::AnimationValue{centerOfFrame(oldFrame)},
+      {{1.0, native_animation::AnimationValue{centerOfFrame(finalFrame)}, native_animation::LinearTiming{}}},
+      0,
+      5000,
+  };
+  enqueueNativeLayoutStart(
+      LayoutAnimationType::LAYOUT,
+      mutation.oldChildShadowView,
+      mutation.newChildShadowView,
+      benchTransactionNumber_,
+      {handle, {{std::move(positionTrack)}}, native_animation::AnimationAdmissionMode::Normal},
+      {});
+  return true;
+}
+
+bool LayoutAnimationsProxy_Legacy::maybeEnqueueFinalStateFirstBenchEntering(const ShadowViewMutation &mutation) const {
+  if constexpr (!useNativeLayoutAnimations()) {
+    return false;
+  }
+  if (!pendingNativeStarts_ || !hasBenchNativeId(mutation.newChildShadowView, kFinalStateFirstBenchEnteringNativeId)) {
+    return false;
+  }
+  const auto &viewProps = static_cast<const ViewProps &>(*mutation.newChildShadowView.props);
+  const native_animation::AnimationHandle handle{
+      mutation.newChildShadowView.surfaceId,
+      mutation.newChildShadowView.tag,
+      native_animation::AnimationOwner::Layout,
+      ++frameDrivenGeneration_,
+  };
+  native_animation::AnimationTrack opacityTrack{
+      {native_animation::AnimationTargetKind::Opacity},
+      native_animation::AnimationValue{0.0},
+      {{1.0,
+        native_animation::AnimationValue{static_cast<double>(viewProps.opacity)},
+        native_animation::LinearTiming{}}},
+      1000,
+      2000,
+  };
+  enqueueNativeLayoutStart(
+      LayoutAnimationType::ENTERING,
+      mutation.newChildShadowView,
+      mutation.newChildShadowView,
+      benchTransactionNumber_,
+      {handle, {{std::move(opacityTrack)}}, native_animation::AnimationAdmissionMode::Normal},
+      {});
+  return true;
+}
+
+#endif // IS_REANIMATED_EXAMPLE_APP
+
 void LayoutAnimationsProxy_Legacy::startSurface(const SurfaceId surfaceId) {
   auto lock = std::unique_lock<std::recursive_mutex>(mutex);
   surfaceContext_.try_emplace(surfaceId);
diff --git a/packages/react-native-reanimated/Common/cpp/reanimated/LayoutAnimations/LayoutAnimationsProxy_Legacy.h b/packages/react-native-reanimated/Common/cpp/reanimated/LayoutAnimations/LayoutAnimationsProxy_Legacy.h
index bbd782e28861..5249f8153f39 100644
--- a/packages/react-native-reanimated/Common/cpp/reanimated/LayoutAnimations/LayoutAnimationsProxy_Legacy.h
+++ b/packages/react-native-reanimated/Common/cpp/reanimated/LayoutAnimations/LayoutAnimationsProxy_Legacy.h
@@ -131,6 +131,7 @@ struct LayoutAnimationsProxy_Legacy : public LayoutAnimationsProxyCommon,
       jsi::Runtime &uiRuntime,
       const std::shared_ptr<UIScheduler> &uiScheduler,
       const std::shared_ptr<native_animation::NativeAnimationService> &nativeAnimationService,
+      const std::shared_ptr<LayoutMountBoundary> &layoutMountBoundary,
       const std::shared_ptr<UIManager> &uiManager
 #ifdef ANDROID
       ,
@@ -145,6 +146,7 @@ struct LayoutAnimationsProxy_Legacy : public LayoutAnimationsProxyCommon,
             uiRuntime,
             uiScheduler,
             nativeAnimationService,
+            layoutMountBoundary,
             uiManager
 #ifdef ANDROID
             ,
@@ -163,6 +165,14 @@ struct LayoutAnimationsProxy_Legacy : public LayoutAnimationsProxyCommon,
   void startExitingAnimation(const int tag, ShadowViewMutation &mutation) const;
   void startLayoutAnimation(const int tag, const ShadowViewMutation &mutation) const;
 
+#if defined(IS_REANIMATED_EXAMPLE_APP)
+  // Final-state-first bench: views with a bench nativeID get a controlled
+  // prepared request through the pending-start mechanism.
+  mutable MountingTransaction::Number benchTransactionNumber_{0};
+  bool maybeEnqueueFinalStateFirstBenchLayout(const ShadowViewMutation &mutation) const;
+  bool maybeEnqueueFinalStateFirstBenchEntering(const ShadowViewMutation &mutation) const;
+#endif
+
   std::optional<SurfaceId> progressLayoutAnimation(int tag, const jsi::Object &newStyle) override;
   std::optional<SurfaceId> endLayoutAnimation(int tag, bool shouldRemove) override;
   void startSurface(const SurfaceId surfaceId) override;
diff --git a/packages/react-native-reanimated/Common/cpp/reanimated/LayoutAnimations/LayoutMountBoundary.h b/packages/react-native-reanimated/Common/cpp/reanimated/LayoutAnimations/LayoutMountBoundary.h
new file mode 100644
index 000000000000..189eb7f6e7e7
--- /dev/null
+++ b/packages/react-native-reanimated/Common/cpp/reanimated/LayoutAnimations/LayoutMountBoundary.h
@@ -0,0 +1,38 @@
+#pragma once
+
+#include <react/renderer/core/ReactPrimitives.h>
+#include <react/renderer/graphics/Rect.h>
+
+#include <cstdint>
+#include <functional>
+#include <optional>
+
+namespace reanimated {
+
+using PostMountObserver = std::function<void(facebook::react::SurfaceId)>;
+
+struct MountedViewState {
+  // Mounted host frame in the parent's coordinates, free of any animation
+  // transform.
+  facebook::react::Rect frame;
+  // Identity of the mounted props object; zero when the platform cannot
+  // report one.
+  uintptr_t propsToken{0};
+};
+
+// Layout-owned, platform-neutral mount contract. The platform calls the
+// registered observer on the UI thread after it applies one mounting
+// transaction for the surface and before the frame becomes visible — an
+// explicit mount signal, never queue order. `mountedState` also runs on the
+// UI thread and returns nullopt when the view is not mounted for the surface.
+class LayoutMountBoundary {
+ public:
+  virtual ~LayoutMountBoundary() = default;
+
+  virtual void setPostMountObserver(PostMountObserver observer) = 0;
+  virtual std::optional<MountedViewState> mountedState(
+      facebook::react::SurfaceId surfaceId,
+      facebook::react::Tag tag) = 0;
+};
+
+} // namespace reanimated
diff --git a/packages/react-native-reanimated/Common/cpp/reanimated/LayoutAnimations/PendingNativeLayoutStarts.cpp b/packages/react-native-reanimated/Common/cpp/reanimated/LayoutAnimations/PendingNativeLayoutStarts.cpp
new file mode 100644
index 000000000000..8e0277409826
--- /dev/null
+++ b/packages/react-native-reanimated/Common/cpp/reanimated/LayoutAnimations/PendingNativeLayoutStarts.cpp
@@ -0,0 +1,195 @@
+#include <reanimated/LayoutAnimations/PendingNativeLayoutStarts.h>
+#include <reanimated/Tools/ReanimatedSystraceSection.h>
+
+#include <algorithm>
+#include <cmath>
+#include <utility>
+
+namespace reanimated {
+
+namespace {
+
+using namespace native_animation;
+
+// Host-state epsilon from the semantic contract.
+constexpr double kLayoutEpsilon = 0.01;
+
+bool layoutsMatch(const facebook::react::Rect &mounted, const facebook::react::Rect &expected) {
+  return std::abs(mounted.origin.x - expected.origin.x) <= kLayoutEpsilon &&
+      std::abs(mounted.origin.y - expected.origin.y) <= kLayoutEpsilon &&
+      std::abs(mounted.size.width - expected.size.width) <= kLayoutEpsilon &&
+      std::abs(mounted.size.height - expected.size.height) <= kLayoutEpsilon;
+}
+
+} // namespace
+
+PendingNativeLayoutStarts::PendingNativeLayoutStarts(
+    std::shared_ptr<NativeAnimationService> service,
+    std::shared_ptr<LayoutMountBoundary> mountBoundary
+#ifndef NDEBUG
+    ,
+    std::shared_ptr<NativeAnimationTraceSink> traceSink)
+#else
+    )
+#endif
+    : service_(std::move(service)),
+      mountBoundary_(std::move(mountBoundary))
+#ifndef NDEBUG
+      ,
+      traceSink_(std::move(traceSink))
+#endif
+{
+}
+
+void PendingNativeLayoutStarts::enqueue(PendingNativeLayoutStart record) {
+  auto droppedResult = AnimationResult{AnimationOutcome::SurfaceDestroyed, AnimationResultReason::None};
+  {
+    std::unique_lock<std::mutex> lock(mutex_);
+    if (stoppedSurfaces_.contains(record.handle.surfaceId)) {
+      // droppedResult already says SurfaceDestroyed.
+    } else if (!pendingHandles_.insert(record.handle).second) {
+      // Handles are single-use.
+      droppedResult = {AnimationOutcome::Rejected, AnimationResultReason::StaleGeneration};
+    } else {
+      recordNativeAnimationTrace(
+          *traceSink_,
+          NativeAnimationTraceEventType::MountEnqueue,
+          record.handle,
+          std::nullopt,
+          std::nullopt,
+          std::nullopt,
+          6);
+      pendingBySurface_[record.handle.surfaceId].push_back(std::move(record));
+      return;
+    }
+  }
+  deliverDropped(std::move(record), droppedResult);
+}
+
+void PendingNativeLayoutStarts::cancel(const AnimationHandle &handle) {
+  PendingNativeLayoutStart cancelled;
+  {
+    std::unique_lock<std::mutex> lock(mutex_);
+    const auto surfaceIt = pendingBySurface_.find(handle.surfaceId);
+    if (surfaceIt == pendingBySurface_.end()) {
+      return;
+    }
+    auto &records = surfaceIt->second;
+    const auto recordIt =
+        std::ranges::find_if(records, [&](const PendingNativeLayoutStart &record) { return record.handle == handle; });
+    if (recordIt == records.end()) {
+      return;
+    }
+    cancelled = std::move(*recordIt);
+    records.erase(recordIt);
+    if (records.empty()) {
+      pendingBySurface_.erase(surfaceIt);
+    }
+    pendingHandles_.erase(handle);
+  }
+  deliverDropped(std::move(cancelled), {AnimationOutcome::Cancelled, AnimationResultReason::None});
+}
+
+void PendingNativeLayoutStarts::drainAfterMount(const facebook::react::SurfaceId surfaceId) {
+  ReanimatedSystraceSection section("PendingNativeLayoutStarts::drainAfterMount");
+  std::vector<PendingNativeLayoutStart> records;
+  {
+    std::unique_lock<std::mutex> lock(mutex_);
+    const auto surfaceIt = pendingBySurface_.find(surfaceId);
+    if (surfaceIt == pendingBySurface_.end()) {
+      return;
+    }
+    records = std::move(surfaceIt->second);
+    pendingBySurface_.erase(surfaceIt);
+    for (const auto &record : records) {
+      pendingHandles_.erase(record.handle);
+    }
+  }
+  for (auto &record : records) {
+    const auto mountedState = mountBoundary_->mountedState(surfaceId, record.handle.tag);
+    if (!mountedState) {
+      deliverDropped(std::move(record), {AnimationOutcome::Rejected, AnimationResultReason::TargetUnavailable});
+      continue;
+    }
+    const bool propsAreStale = record.expectedFinalPropsToken != 0 && mountedState->propsToken != 0 &&
+        mountedState->propsToken != record.expectedFinalPropsToken;
+    if (propsAreStale || !layoutsMatch(mountedState->frame, record.expectedFinalLayout)) {
+      // A newer commit mounted past this record's expected final state.
+      deliverDropped(std::move(record), {AnimationOutcome::Rejected, AnimationResultReason::StaleGeneration});
+      continue;
+    }
+    recordNativeAnimationTrace(
+        *traceSink_,
+        NativeAnimationTraceEventType::MountDrain,
+        record.handle,
+        std::nullopt,
+        std::nullopt,
+        std::nullopt,
+        6);
+    service_->schedule(std::move(record.request), std::move(record.callbacks));
+  }
+}
+
+void PendingNativeLayoutStarts::notifySurfaceStarted(const facebook::react::SurfaceId surfaceId) {
+  std::unique_lock<std::mutex> lock(mutex_);
+  stoppedSurfaces_.erase(surfaceId);
+}
+
+void PendingNativeLayoutStarts::cancelSurface(const facebook::react::SurfaceId surfaceId) {
+  std::vector<PendingNativeLayoutStart> records;
+  {
+    std::unique_lock<std::mutex> lock(mutex_);
+    stoppedSurfaces_.insert(surfaceId);
+    const auto surfaceIt = pendingBySurface_.find(surfaceId);
+    if (surfaceIt == pendingBySurface_.end()) {
+      return;
+    }
+    records = std::move(surfaceIt->second);
+    pendingBySurface_.erase(surfaceIt);
+    for (const auto &record : records) {
+      pendingHandles_.erase(record.handle);
+    }
+  }
+  for (auto &record : records) {
+    deliverDropped(std::move(record), {AnimationOutcome::SurfaceDestroyed, AnimationResultReason::None});
+  }
+}
+
+void PendingNativeLayoutStarts::deliverDropped(PendingNativeLayoutStart record, const AnimationResult result) const {
+  recordNativeAnimationTrace(
+      *traceSink_,
+      NativeAnimationTraceEventType::Rejection,
+      record.handle,
+      std::nullopt,
+      result.outcome,
+      result.reason,
+      6);
+  recordNativeAnimationTrace(
+      *traceSink_,
+      NativeAnimationTraceEventType::Terminal,
+      record.handle,
+      std::nullopt,
+      result.outcome,
+      result.reason,
+      6);
+  auto callbacks = std::move(record.callbacks);
+  if (!callbacks.onAdmission && !callbacks.onTerminal) {
+    return;
+  }
+  auto operation =
+      [admission = std::move(callbacks.onAdmission), terminal = std::move(callbacks.onTerminal), result]() mutable {
+        if (admission) {
+          admission({AnimationAdmissionStatus::Rejected, result.reason});
+        }
+        if (terminal) {
+          terminal(result);
+        }
+      };
+  if (callbacks.scheduler) {
+    callbacks.scheduler(std::move(operation));
+  } else {
+    operation();
+  }
+}
+
+} // namespace reanimated
diff --git a/packages/react-native-reanimated/Common/cpp/reanimated/LayoutAnimations/PendingNativeLayoutStarts.h b/packages/react-native-reanimated/Common/cpp/reanimated/LayoutAnimations/PendingNativeLayoutStarts.h
new file mode 100644
index 000000000000..d7be781d678e
--- /dev/null
+++ b/packages/react-native-reanimated/Common/cpp/reanimated/LayoutAnimations/PendingNativeLayoutStarts.h
@@ -0,0 +1,77 @@
+#pragma once
+
+#include <reanimated/LayoutAnimations/LayoutAnimationType.h>
+#include <reanimated/LayoutAnimations/LayoutMountBoundary.h>
+#include <reanimated/NativeAnimations/NativeAnimationService.h>
+#include <reanimated/NativeAnimations/NativeAnimationTrace.h>
+
+#include <cstdint>
+#include <memory>
+#include <mutex>
+#include <unordered_map>
+#include <unordered_set>
+#include <vector>
+
+namespace reanimated {
+
+// Opaque holder for the old and final ShadowView copies of a pending start.
+// Keeps this store free of renderer headers.
+class PendingLayoutViewSnapshot {
+ public:
+  virtual ~PendingLayoutViewSnapshot() = default;
+};
+
+struct PendingNativeLayoutStart {
+  native_animation::AnimationHandle handle;
+  // MountingTransaction::Number without its heavy header dependency.
+  int64_t transactionNumber{0};
+  LayoutAnimationType type{LayoutAnimationType::LAYOUT};
+  facebook::react::Rect expectedFinalLayout;
+  // Identity of the expected final props object; zero skips the props check.
+  uintptr_t expectedFinalPropsToken{0};
+  std::unique_ptr<PendingLayoutViewSnapshot> views;
+  // Opaque owned execution data; this store never reads the plan.
+  native_animation::AnimationRequest request;
+  native_animation::AnimationCallbacks callbacks;
+};
+
+// Layout-owned store that holds prepared native requests until the mount
+// boundary reports the intended Fabric mount, then validates and submits
+// them. Every record gets exactly one typed result. A mutex guards the state;
+// callbacks and submissions run outside of it.
+class PendingNativeLayoutStarts {
+ public:
+  PendingNativeLayoutStarts(
+      std::shared_ptr<native_animation::NativeAnimationService> service,
+      std::shared_ptr<LayoutMountBoundary> mountBoundary
+#ifndef NDEBUG
+      ,
+      std::shared_ptr<native_animation::NativeAnimationTraceSink> traceSink =
+          std::make_shared<native_animation::NullNativeAnimationTraceSink>());
+#else
+  );
+#endif
+
+  void enqueue(PendingNativeLayoutStart record);
+  // Removes one exact pending handle; disjoint newer generations stay valid.
+  void cancel(const native_animation::AnimationHandle &handle);
+  void drainAfterMount(facebook::react::SurfaceId surfaceId);
+  void notifySurfaceStarted(facebook::react::SurfaceId surfaceId);
+  void cancelSurface(facebook::react::SurfaceId surfaceId);
+
+ private:
+  void deliverDropped(PendingNativeLayoutStart record, native_animation::AnimationResult result) const;
+
+  std::shared_ptr<native_animation::NativeAnimationService> service_;
+  std::shared_ptr<LayoutMountBoundary> mountBoundary_;
+#ifndef NDEBUG
+  std::shared_ptr<native_animation::NativeAnimationTraceSink> traceSink_;
+#endif
+
+  mutable std::mutex mutex_;
+  std::unordered_map<facebook::react::SurfaceId, std::vector<PendingNativeLayoutStart>> pendingBySurface_;
+  std::unordered_set<native_animation::AnimationHandle, native_animation::AnimationHandleHash> pendingHandles_;
+  std::unordered_set<facebook::react::SurfaceId> stoppedSurfaces_;
+};
+
+} // namespace reanimated
diff --git a/packages/react-native-reanimated/Common/cpp/reanimated/NativeAnimations/NativeAnimationTrace.cpp b/packages/react-native-reanimated/Common/cpp/reanimated/NativeAnimations/NativeAnimationTrace.cpp
index 683151a6e4bb..ef55b1f76b11 100644
--- a/packages/react-native-reanimated/Common/cpp/reanimated/NativeAnimations/NativeAnimationTrace.cpp
+++ b/packages/react-native-reanimated/Common/cpp/reanimated/NativeAnimations/NativeAnimationTrace.cpp
@@ -12,13 +12,15 @@ void recordNativeAnimationTrace(
     const AnimationHandle handle,
     std::optional<AnimationTargetClaim> target,
     std::optional<AnimationOutcome> outcome,
-    std::optional<AnimationResultReason> reason) {
+    std::optional<AnimationResultReason> reason,
+    const uint8_t objective) {
   const auto now = std::chrono::steady_clock::now().time_since_epoch();
   sink.record(NativeAnimationTraceEvent{
       .monotonicTimeMs = std::chrono::duration<double, std::milli>(now).count(),
       .event = event,
       .handle = handle,
       .target = target,
+      .objective = objective,
       .outcome = outcome,
       .reason = reason,
   });
diff --git a/packages/react-native-reanimated/Common/cpp/reanimated/NativeAnimations/NativeAnimationTrace.h b/packages/react-native-reanimated/Common/cpp/reanimated/NativeAnimations/NativeAnimationTrace.h
index 52091c7723d7..ef1036600f10 100644
--- a/packages/react-native-reanimated/Common/cpp/reanimated/NativeAnimations/NativeAnimationTrace.h
+++ b/packages/react-native-reanimated/Common/cpp/reanimated/NativeAnimations/NativeAnimationTrace.h
@@ -15,6 +15,9 @@ enum class NativeAnimationTraceEventType : uint8_t {
   Claim,
   Rejection,
   Terminal,
+  // Objective 06 layout mount-order events.
+  MountEnqueue,
+  MountDrain,
 };
 
 struct NativeAnimationTraceEvent {
@@ -53,7 +56,8 @@ void recordNativeAnimationTrace(
     AnimationHandle handle,
     std::optional<AnimationTargetClaim> target = std::nullopt,
     std::optional<AnimationOutcome> outcome = std::nullopt,
-    std::optional<AnimationResultReason> reason = std::nullopt);
+    std::optional<AnimationResultReason> reason = std::nullopt,
+    uint8_t objective = 5);
 
 #else
 
diff --git a/packages/react-native-reanimated/Common/cpp/reanimated/NativeAnimations/tests/CMakeLists.txt b/packages/react-native-reanimated/Common/cpp/reanimated/NativeAnimations/tests/CMakeLists.txt
index 7b9bd8264cfe..51766051903f 100644
--- a/packages/react-native-reanimated/Common/cpp/reanimated/NativeAnimations/tests/CMakeLists.txt
+++ b/packages/react-native-reanimated/Common/cpp/reanimated/NativeAnimations/tests/CMakeLists.txt
@@ -11,7 +11,9 @@ set(REACT_NATIVE_ROOT "${REANIMATED_PACKAGE_ROOT}/../../node_modules/react-nativ
 add_executable(
   native_animation_service_test
   NativeAnimationServiceTest.cc
+  PendingNativeLayoutStartsTest.cc
   ../../LayoutAnimations/LayoutNativeAnimationAdapter.cpp
+  ../../LayoutAnimations/PendingNativeLayoutStarts.cpp
   ../NativeAnimationConflictPolicy.cpp
   ../NativeAnimationCoordinator.cpp
   ../NativeAnimationDispatcher.cpp
@@ -24,7 +26,11 @@ add_executable(
 
 target_include_directories(
   native_animation_service_test
-  PRIVATE "${REANIMATED_PACKAGE_ROOT}/Common/cpp" "${REACT_NATIVE_ROOT}/ReactCommon")
+  PRIVATE
+    "${REANIMATED_PACKAGE_ROOT}/Common/cpp"
+    "${REACT_NATIVE_ROOT}/ReactCommon"
+    # Graphics primitives live outside the main ReactCommon include root.
+    "${REACT_NATIVE_ROOT}/ReactCommon/react/renderer/graphics/platform/cxx")
 
 # In debug builds react_native_assert needs glog, which this standalone build
 # does not have. This flag turns it into a no-op; the suite's own assert()
diff --git a/packages/react-native-reanimated/Common/cpp/reanimated/NativeAnimations/tests/NativeAnimationServiceTest.cc b/packages/react-native-reanimated/Common/cpp/reanimated/NativeAnimations/tests/NativeAnimationServiceTest.cc
index 39ca0ee7d08b..1a89619d55ce 100644
--- a/packages/react-native-reanimated/Common/cpp/reanimated/NativeAnimations/tests/NativeAnimationServiceTest.cc
+++ b/packages/react-native-reanimated/Common/cpp/reanimated/NativeAnimations/tests/NativeAnimationServiceTest.cc
@@ -13,6 +13,8 @@
 using namespace reanimated::native_animation;
 using namespace reanimated::native_animation::testing;
 
+void runPendingNativeLayoutStartsTests();
+
 namespace {
 
 CallbackScheduler immediateScheduler() {
@@ -799,4 +801,5 @@ int main() {
   testCommonFixturesUseAppleAndAndroidExecutors();
   testExternalTraceEnvelope();
   std::cout << "NativeAnimationServiceTest passed\n";
+  runPendingNativeLayoutStartsTests();
 }
diff --git a/packages/react-native-reanimated/Common/cpp/reanimated/NativeAnimations/tests/PendingNativeLayoutStartsTest.cc b/packages/react-native-reanimated/Common/cpp/reanimated/NativeAnimations/tests/PendingNativeLayoutStartsTest.cc
new file mode 100644
index 000000000000..bb4fa801fb2c
--- /dev/null
+++ b/packages/react-native-reanimated/Common/cpp/reanimated/NativeAnimations/tests/PendingNativeLayoutStartsTest.cc
@@ -0,0 +1,470 @@
+#include <reanimated/LayoutAnimations/PendingNativeLayoutStarts.h>
+#include <reanimated/NativeAnimations/testing/FakeNativeAnimationHost.h>
+
+#include <cassert>
+#include <iostream>
+#include <map>
+#include <memory>
+#include <optional>
+#include <utility>
+#include <vector>
+
+// Objective 06 pending-start tests, driven with controlled prepared requests.
+
+void runPendingNativeLayoutStartsTests();
+
+namespace {
+
+using namespace reanimated;
+using namespace reanimated::native_animation;
+using namespace reanimated::native_animation::testing;
+
+class FakeLayoutMountBoundary final : public LayoutMountBoundary {
+ public:
+  void setPostMountObserver(PostMountObserver observer) override {
+    observer_ = std::move(observer);
+  }
+
+  std::optional<MountedViewState> mountedState(
+      const facebook::react::SurfaceId surfaceId,
+      const facebook::react::Tag tag) override {
+    const auto it = mountedStates.find({surfaceId, tag});
+    if (it == mountedStates.end()) {
+      return std::nullopt;
+    }
+    return it->second;
+  }
+
+  void simulateMount(const facebook::react::SurfaceId surfaceId) {
+    assert(observer_ && "the pending store must register a post-mount observer");
+    observer_(surfaceId);
+  }
+
+  bool hasObserver() const {
+    return observer_ != nullptr;
+  }
+
+  std::map<std::pair<facebook::react::SurfaceId, facebook::react::Tag>, MountedViewState> mountedStates;
+
+ private:
+  PostMountObserver observer_;
+};
+
+facebook::react::Rect rect(const double x, const double y, const double width, const double height) {
+  facebook::react::Rect result;
+  result.origin.x = x;
+  result.origin.y = y;
+  result.size.width = width;
+  result.size.height = height;
+  return result;
+}
+
+AnimationTrack pendingOpacityTrack() {
+  return {
+      {AnimationTargetKind::Opacity},
+      AnimationValue{0.0},
+      {{1.0, AnimationValue{1.0}, LinearTiming{}}},
+      0,
+      100,
+  };
+}
+
+AnimationTrack pendingPositionTrack() {
+  return {
+      {AnimationTargetKind::Position},
+      AnimationValue{AnimationPoint{0, 0}},
+      {{1.0, AnimationValue{AnimationPoint{10, 10}}, LinearTiming{}}},
+      0,
+      100,
+  };
+}
+
+struct RecordedResults {
+  std::vector<AnimationAdmissionResult> admissions;
+  std::vector<AnimationResult> terminals;
+};
+
+AnimationCallbacks recordingCallbacks(RecordedResults &results) {
+  return {
+      [](CallbackOperation operation) { operation(); },
+      [&results](const AnimationAdmissionResult result) { results.admissions.push_back(result); },
+      [&results](const AnimationResult result) { results.terminals.push_back(result); },
+  };
+}
+
+struct PendingFixture {
+  std::shared_ptr<TestPlatformUIScheduler> scheduler = std::make_shared<TestPlatformUIScheduler>();
+  std::shared_ptr<TestNativeAnimationTargetResolver> resolver = std::make_shared<TestNativeAnimationTargetResolver>();
+  std::shared_ptr<TestNativeAnimationExecutor> executor = std::make_shared<TestNativeAnimationExecutor>();
+#ifndef NDEBUG
+  std::shared_ptr<TestNativeAnimationTraceRecorder> trace = std::make_shared<TestNativeAnimationTraceRecorder>();
+  std::shared_ptr<NativeAnimationService> service = makeNativeAnimationService(scheduler, resolver, executor, trace);
+#else
+  std::shared_ptr<NativeAnimationService> service = makeNativeAnimationService(scheduler, resolver, executor);
+#endif
+  std::shared_ptr<FakeLayoutMountBoundary> boundary = std::make_shared<FakeLayoutMountBoundary>();
+#ifndef NDEBUG
+  std::shared_ptr<PendingNativeLayoutStarts> pendingStarts =
+      std::make_shared<PendingNativeLayoutStarts>(service, boundary, trace);
+#else
+  std::shared_ptr<PendingNativeLayoutStarts> pendingStarts =
+      std::make_shared<PendingNativeLayoutStarts>(service, boundary);
+#endif
+
+  PendingFixture() {
+    boundary->setPostMountObserver([pendingStarts = std::weak_ptr<PendingNativeLayoutStarts>(pendingStarts)](
+                                       const facebook::react::SurfaceId surfaceId) {
+      if (const auto lockedPendingStarts = pendingStarts.lock()) {
+        lockedPendingStarts->drainAfterMount(surfaceId);
+      }
+    });
+  }
+
+  PendingNativeLayoutStart makeRecord(
+      const AnimationHandle handle,
+      const facebook::react::Rect expectedFinalLayout,
+      RecordedResults &results,
+      AnimationTrack track,
+      const int64_t transactionNumber = 1,
+      const uintptr_t expectedFinalPropsToken = 0) {
+    std::vector<AnimationTrack> tracks;
+    tracks.push_back(std::move(track));
+    return {
+        handle,
+        transactionNumber,
+        LayoutAnimationType::LAYOUT,
+        expectedFinalLayout,
+        expectedFinalPropsToken,
+        nullptr,
+        {handle, {std::move(tracks)}, AnimationAdmissionMode::Normal},
+        recordingCallbacks(results),
+    };
+  }
+};
+
+void testOwnedRequestLifetimeAndMountOrdering() {
+  PendingFixture fixture;
+  const AnimationHandle handle{1, 10, AnimationOwner::Layout, 1};
+  RecordedResults results;
+  fixture.boundary->mountedStates[{1, 10}] = {rect(0, 0, 100, 50)};
+  {
+    auto record = fixture.makeRecord(handle, rect(0, 0, 100, 50), results, pendingOpacityTrack());
+    fixture.pendingStarts->enqueue(std::move(record));
+  }
+
+  // No start before the mount signal.
+  assert(fixture.executor->started.empty());
+  fixture.scheduler->flush();
+  assert(fixture.executor->started.empty());
+
+  fixture.boundary->simulateMount(1);
+  fixture.scheduler->flush();
+  assert(fixture.executor->started.size() == 1);
+  assert(fixture.executor->started.front() == handle);
+  assert(results.admissions.size() == 1);
+  assert(results.admissions.front().status == AnimationAdmissionStatus::Granted);
+
+  fixture.executor->complete(handle, {AnimationTargetKind::Opacity});
+  fixture.executor->complete(handle, {AnimationTargetKind::Opacity});
+  assert((results.terminals == std::vector<AnimationResult>{{AnimationOutcome::Finished, AnimationResultReason::None}}));
+
+#ifndef NDEBUG
+  // Trace order: enqueue < drain < schedule.
+  std::optional<uint64_t> enqueueSequence;
+  std::optional<uint64_t> drainSequence;
+  std::optional<uint64_t> scheduleSequence;
+  for (const auto &event : fixture.trace->events) {
+    if (event.event == NativeAnimationTraceEventType::MountEnqueue) {
+      assert(event.objective == 6);
+      enqueueSequence = event.sequence;
+    } else if (event.event == NativeAnimationTraceEventType::MountDrain) {
+      assert(event.objective == 6);
+      drainSequence = event.sequence;
+    } else if (event.event == NativeAnimationTraceEventType::Schedule) {
+      scheduleSequence = event.sequence;
+    }
+  }
+  assert(enqueueSequence && drainSequence && scheduleSequence);
+  assert(*enqueueSequence < *drainSequence);
+  assert(*drainSequence < *scheduleSequence);
+#endif
+}
+
+void testMissingViewCannotStart() {
+  PendingFixture fixture;
+  const AnimationHandle handle{1, 10, AnimationOwner::Layout, 1};
+  RecordedResults results;
+  fixture.pendingStarts->enqueue(fixture.makeRecord(handle, rect(0, 0, 100, 50), results, pendingOpacityTrack()));
+
+  fixture.boundary->simulateMount(1);
+  fixture.scheduler->flush();
+  assert(fixture.executor->started.empty());
+  assert(results.admissions.size() == 1);
+  assert(results.admissions.front().status == AnimationAdmissionStatus::Rejected);
+  assert(
+      (results.terminals ==
+       std::vector<AnimationResult>{{AnimationOutcome::Rejected, AnimationResultReason::TargetUnavailable}}));
+}
+
+void testStaleFinalLayoutCannotStart() {
+  PendingFixture fixture;
+  const AnimationHandle handle{1, 10, AnimationOwner::Layout, 1};
+  RecordedResults results;
+  fixture.boundary->mountedStates[{1, 10}] = {rect(40, 40, 100, 50)};
+  fixture.pendingStarts->enqueue(fixture.makeRecord(handle, rect(0, 0, 100, 50), results, pendingOpacityTrack()));
+
+  fixture.boundary->simulateMount(1);
+  fixture.scheduler->flush();
+  assert(fixture.executor->started.empty());
+  assert(
+      (results.terminals ==
+       std::vector<AnimationResult>{{AnimationOutcome::Rejected, AnimationResultReason::StaleGeneration}}));
+}
+
+void testCancelledPendingStartCannotStart() {
+  PendingFixture fixture;
+  const AnimationHandle handle{1, 10, AnimationOwner::Layout, 1};
+  RecordedResults results;
+  fixture.boundary->mountedStates[{1, 10}] = {rect(0, 0, 100, 50)};
+  fixture.pendingStarts->enqueue(fixture.makeRecord(handle, rect(0, 0, 100, 50), results, pendingOpacityTrack()));
+
+  fixture.pendingStarts->cancel(handle);
+  assert((results.terminals == std::vector<AnimationResult>{{AnimationOutcome::Cancelled, AnimationResultReason::None}}));
+
+  fixture.boundary->simulateMount(1);
+  fixture.scheduler->flush();
+  assert(fixture.executor->started.empty());
+  assert(results.terminals.size() == 1);
+}
+
+void testNewerDisjointGenerationKeepsPendingStartValid() {
+  PendingFixture fixture;
+  const AnimationHandle pendingHandle{1, 10, AnimationOwner::Layout, 1};
+  const AnimationHandle disjointHandle{1, 10, AnimationOwner::Layout, 2};
+  RecordedResults results;
+  fixture.boundary->mountedStates[{1, 10}] = {rect(0, 0, 100, 50)};
+  fixture.pendingStarts->enqueue(
+      fixture.makeRecord(pendingHandle, rect(0, 0, 100, 50), results, pendingOpacityTrack()));
+
+  std::vector<AnimationTrack> disjointTracks;
+  disjointTracks.push_back(pendingPositionTrack());
+  fixture.service->schedule({disjointHandle, {std::move(disjointTracks)}, AnimationAdmissionMode::Normal}, {});
+  fixture.scheduler->flush();
+  assert(fixture.executor->started.size() == 1);
+
+  fixture.boundary->simulateMount(1);
+  fixture.scheduler->flush();
+  assert(fixture.executor->started.size() == 2);
+  assert(fixture.executor->started.back() == pendingHandle);
+  assert(results.admissions.size() == 1);
+  assert(results.admissions.front().status == AnimationAdmissionStatus::Granted);
+}
+
+void testNewerSameTargetGenerationRejectsOlderPendingStart() {
+  PendingFixture fixture;
+  const AnimationHandle pendingHandle{1, 10, AnimationOwner::Layout, 1};
+  const AnimationHandle newerHandle{1, 10, AnimationOwner::Layout, 2};
+  RecordedResults results;
+  fixture.boundary->mountedStates[{1, 10}] = {rect(0, 0, 100, 50)};
+  fixture.pendingStarts->enqueue(
+      fixture.makeRecord(pendingHandle, rect(0, 0, 100, 50), results, pendingOpacityTrack()));
+
+  std::vector<AnimationTrack> newerTracks;
+  newerTracks.push_back(pendingOpacityTrack());
+  fixture.service->schedule({newerHandle, {std::move(newerTracks)}, AnimationAdmissionMode::Normal}, {});
+  fixture.scheduler->flush();
+  assert(fixture.executor->started.size() == 1);
+
+  fixture.boundary->simulateMount(1);
+  fixture.scheduler->flush();
+  assert(fixture.executor->started.size() == 1);
+  assert(
+      (results.terminals ==
+       std::vector<AnimationResult>{{AnimationOutcome::Rejected, AnimationResultReason::StaleGeneration}}));
+}
+
+void testBackToBackCommitsKeepNewestFinalState() {
+  PendingFixture fixture;
+  const AnimationHandle firstHandle{1, 10, AnimationOwner::Layout, 1};
+  const AnimationHandle secondHandle{1, 10, AnimationOwner::Layout, 2};
+  RecordedResults firstResults;
+  RecordedResults secondResults;
+
+  // A -> B and B -> C queue before any mount; the platform mounts C.
+  fixture.pendingStarts->enqueue(
+      fixture.makeRecord(firstHandle, rect(0, 0, 100, 50), firstResults, pendingOpacityTrack(), 1));
+  fixture.pendingStarts->enqueue(
+      fixture.makeRecord(secondHandle, rect(200, 0, 100, 50), secondResults, pendingOpacityTrack(), 2));
+  fixture.boundary->mountedStates[{1, 10}] = {rect(200, 0, 100, 50)};
+
+  fixture.boundary->simulateMount(1);
+  fixture.scheduler->flush();
+
+  assert(
+      (firstResults.terminals ==
+       std::vector<AnimationResult>{{AnimationOutcome::Rejected, AnimationResultReason::StaleGeneration}}));
+  assert(fixture.executor->started.size() == 1);
+  assert(fixture.executor->started.front() == secondHandle);
+  assert(secondResults.terminals.empty());
+  fixture.executor->complete(secondHandle, {AnimationTargetKind::Opacity});
+  assert(
+      (secondResults.terminals == std::vector<AnimationResult>{{AnimationOutcome::Finished, AnimationResultReason::None}}));
+}
+
+void testSecondCommitRetargetsStartedCommand() {
+  PendingFixture fixture;
+  const AnimationHandle firstHandle{1, 10, AnimationOwner::Layout, 1};
+  const AnimationHandle secondHandle{1, 10, AnimationOwner::Layout, 2};
+  RecordedResults firstResults;
+  RecordedResults secondResults;
+
+  fixture.boundary->mountedStates[{1, 10}] = {rect(0, 0, 100, 50)};
+  fixture.pendingStarts->enqueue(
+      fixture.makeRecord(firstHandle, rect(0, 0, 100, 50), firstResults, pendingOpacityTrack(), 1));
+  fixture.boundary->simulateMount(1);
+  fixture.scheduler->flush();
+  assert(fixture.executor->started.size() == 1);
+
+  fixture.boundary->mountedStates[{1, 10}] = {rect(200, 0, 100, 50)};
+  fixture.pendingStarts->enqueue(
+      fixture.makeRecord(secondHandle, rect(200, 0, 100, 50), secondResults, pendingOpacityTrack(), 2));
+  fixture.boundary->simulateMount(1);
+  fixture.scheduler->flush();
+
+  assert(fixture.executor->started.size() == 2);
+  assert(
+      (firstResults.terminals ==
+       std::vector<AnimationResult>{{AnimationOutcome::Interrupted, AnimationResultReason::None}}));
+  assert(secondResults.terminals.empty());
+}
+
+void testDuplicatePendingHandleIsRejectedAtEnqueue() {
+  PendingFixture fixture;
+  const AnimationHandle handle{1, 10, AnimationOwner::Layout, 1};
+  RecordedResults firstResults;
+  RecordedResults duplicateResults;
+  fixture.boundary->mountedStates[{1, 10}] = {rect(0, 0, 100, 50)};
+  fixture.pendingStarts->enqueue(fixture.makeRecord(handle, rect(0, 0, 100, 50), firstResults, pendingOpacityTrack()));
+  fixture.pendingStarts->enqueue(
+      fixture.makeRecord(handle, rect(0, 0, 100, 50), duplicateResults, pendingOpacityTrack()));
+
+  assert(
+      (duplicateResults.terminals ==
+       std::vector<AnimationResult>{{AnimationOutcome::Rejected, AnimationResultReason::StaleGeneration}}));
+
+  fixture.boundary->simulateMount(1);
+  fixture.scheduler->flush();
+  assert(fixture.executor->started.size() == 1);
+  assert(firstResults.terminals.empty());
+  assert(duplicateResults.terminals.size() == 1);
+}
+
+void testStaleMountedPropsCannotStart() {
+  PendingFixture fixture;
+  const AnimationHandle staleHandle{1, 10, AnimationOwner::Layout, 1};
+  const AnimationHandle currentHandle{1, 11, AnimationOwner::Layout, 2};
+  RecordedResults staleResults;
+  RecordedResults currentResults;
+  fixture.boundary->mountedStates[{1, 10}] = {rect(0, 0, 100, 50), 7};
+  fixture.boundary->mountedStates[{1, 11}] = {rect(0, 0, 100, 50), 9};
+  fixture.pendingStarts->enqueue(
+      fixture.makeRecord(staleHandle, rect(0, 0, 100, 50), staleResults, pendingOpacityTrack(), 1, 8));
+  fixture.pendingStarts->enqueue(
+      fixture.makeRecord(currentHandle, rect(0, 0, 100, 50), currentResults, pendingOpacityTrack(), 1, 9));
+
+  fixture.boundary->simulateMount(1);
+  fixture.scheduler->flush();
+  assert(
+      (staleResults.terminals ==
+       std::vector<AnimationResult>{{AnimationOutcome::Rejected, AnimationResultReason::StaleGeneration}}));
+  assert(fixture.executor->started.size() == 1);
+  assert(fixture.executor->started.front() == currentHandle);
+  assert(currentResults.terminals.empty());
+}
+
+void testSurfaceIsolation() {
+  PendingFixture fixture;
+  const AnimationHandle firstSurfaceHandle{1, 10, AnimationOwner::Layout, 1};
+  const AnimationHandle secondSurfaceHandle{2, 20, AnimationOwner::Layout, 1};
+  RecordedResults firstResults;
+  RecordedResults secondResults;
+  fixture.boundary->mountedStates[{1, 10}] = {rect(0, 0, 100, 50)};
+  fixture.boundary->mountedStates[{2, 20}] = {rect(0, 0, 100, 50)};
+  fixture.pendingStarts->enqueue(
+      fixture.makeRecord(firstSurfaceHandle, rect(0, 0, 100, 50), firstResults, pendingOpacityTrack()));
+  fixture.pendingStarts->enqueue(
+      fixture.makeRecord(secondSurfaceHandle, rect(0, 0, 100, 50), secondResults, pendingOpacityTrack()));
+
+  fixture.boundary->simulateMount(1);
+  fixture.scheduler->flush();
+  assert(fixture.executor->started.size() == 1);
+  assert(fixture.executor->started.front() == firstSurfaceHandle);
+
+  fixture.boundary->simulateMount(2);
+  fixture.scheduler->flush();
+  assert(fixture.executor->started.size() == 2);
+  assert(fixture.executor->started.back() == secondSurfaceHandle);
+}
+
+void testSurfaceTeardownBlocksQueuedStarts() {
+  PendingFixture fixture;
+  const AnimationHandle stoppedHandle{1, 10, AnimationOwner::Layout, 1};
+  const AnimationHandle liveHandle{2, 20, AnimationOwner::Layout, 1};
+  RecordedResults stoppedResults;
+  RecordedResults liveResults;
+  fixture.boundary->mountedStates[{1, 10}] = {rect(0, 0, 100, 50)};
+  fixture.boundary->mountedStates[{2, 20}] = {rect(0, 0, 100, 50)};
+  fixture.pendingStarts->enqueue(
+      fixture.makeRecord(stoppedHandle, rect(0, 0, 100, 50), stoppedResults, pendingOpacityTrack()));
+  fixture.pendingStarts->enqueue(fixture.makeRecord(liveHandle, rect(0, 0, 100, 50), liveResults, pendingOpacityTrack()));
+
+  fixture.pendingStarts->cancelSurface(1);
+  assert(
+      (stoppedResults.terminals ==
+       std::vector<AnimationResult>{{AnimationOutcome::SurfaceDestroyed, AnimationResultReason::None}}));
+
+  fixture.boundary->simulateMount(1);
+  fixture.scheduler->flush();
+  assert(fixture.executor->started.empty());
+
+  RecordedResults lateResults;
+  fixture.pendingStarts->enqueue(
+      fixture.makeRecord({1, 11, AnimationOwner::Layout, 2}, rect(0, 0, 100, 50), lateResults, pendingOpacityTrack()));
+  assert(
+      (lateResults.terminals ==
+       std::vector<AnimationResult>{{AnimationOutcome::SurfaceDestroyed, AnimationResultReason::None}}));
+
+  fixture.boundary->simulateMount(2);
+  fixture.scheduler->flush();
+  assert(fixture.executor->started.size() == 1);
+  assert(fixture.executor->started.front() == liveHandle);
+
+  fixture.pendingStarts->notifySurfaceStarted(1);
+  RecordedResults restartedResults;
+  const AnimationHandle restartedHandle{1, 12, AnimationOwner::Layout, 3};
+  fixture.boundary->mountedStates[{1, 12}] = {rect(0, 0, 100, 50)};
+  fixture.pendingStarts->enqueue(
+      fixture.makeRecord(restartedHandle, rect(0, 0, 100, 50), restartedResults, pendingOpacityTrack()));
+  fixture.boundary->simulateMount(1);
+  fixture.scheduler->flush();
+  assert(fixture.executor->started.size() == 2);
+  assert(fixture.executor->started.back() == restartedHandle);
+}
+
+} // namespace
+
+void runPendingNativeLayoutStartsTests() {
+  testOwnedRequestLifetimeAndMountOrdering();
+  testMissingViewCannotStart();
+  testStaleFinalLayoutCannotStart();
+  testCancelledPendingStartCannotStart();
+  testNewerDisjointGenerationKeepsPendingStartValid();
+  testNewerSameTargetGenerationRejectsOlderPendingStart();
+  testDuplicatePendingHandleIsRejectedAtEnqueue();
+  testStaleMountedPropsCannotStart();
+  testBackToBackCommitsKeepNewestFinalState();
+  testSecondCommitRetargetsStartedCommand();
+  testSurfaceIsolation();
+  testSurfaceTeardownBlocksQueuedStarts();
+  std::cout << "PendingNativeLayoutStartsTest passed\n";
+}
diff --git a/packages/react-native-reanimated/Common/cpp/reanimated/NativeModules/ReanimatedModuleProxy.cpp b/packages/react-native-reanimated/Common/cpp/reanimated/NativeModules/ReanimatedModuleProxy.cpp
index 26eccf2ff967..18c13375affe 100644
--- a/packages/react-native-reanimated/Common/cpp/reanimated/NativeModules/ReanimatedModuleProxy.cpp
+++ b/packages/react-native-reanimated/Common/cpp/reanimated/NativeModules/ReanimatedModuleProxy.cpp
@@ -199,6 +199,7 @@ ReanimatedModuleProxy::ReanimatedModuleProxy(
       requestRender_(platformDepMethodsHolder.requestRender),
       animatedSensorModule_(platformDepMethodsHolder),
       nativeAnimationService_(platformDepMethodsHolder.nativeAnimationService),
+      layoutMountBoundary_(platformDepMethodsHolder.layoutMountBoundary),
       layoutAnimationsManager_(std::make_shared<LayoutAnimationsManager>()),
       getAnimationTimestamp_(platformDepMethodsHolder.getAnimationTimestamp),
 #ifdef __APPLE__
@@ -1226,10 +1227,15 @@ void ReanimatedModuleProxy::initializeFabric(const std::shared_ptr<UIManager> &u
   std::function<void(SurfaceId)> nativeAnimationSurfaceDidStart;
   std::function<void(SurfaceId)> nativeAnimationSurfaceDidStop;
   if constexpr (useNativeLayoutAnimations()) {
-    nativeAnimationSurfaceDidStart = [service = nativeAnimationService_](const SurfaceId surfaceId) {
+    nativeAnimationSurfaceDidStart = [service = nativeAnimationService_,
+                                      layoutProxy = layoutAnimationsProxy_](const SurfaceId surfaceId) {
       service->notifySurfaceStarted(surfaceId);
+      layoutProxy->notifyNativeStartsSurfaceStarted(surfaceId);
     };
-    nativeAnimationSurfaceDidStop = [service = nativeAnimationService_](const SurfaceId surfaceId) {
+    nativeAnimationSurfaceDidStop = [service = nativeAnimationService_,
+                                     layoutProxy = layoutAnimationsProxy_](const SurfaceId surfaceId) {
+      // Drop layout-owned queued starts before shared teardown.
+      layoutProxy->cancelNativeStartsSurface(surfaceId);
       service->cancelSurface(surfaceId);
     };
   }
@@ -1267,6 +1273,7 @@ void ReanimatedModuleProxy::initializeLayoutAnimationsProxy() {
         getJSIRuntimeFromWorkletRuntime(uiRuntime_),
         uiScheduler_,
         nativeAnimationService_,
+        layoutMountBoundary_,
         uiManager_
 #ifdef ANDROID
         ,
@@ -1286,6 +1293,7 @@ void ReanimatedModuleProxy::initializeLayoutAnimationsProxy() {
         getJSIRuntimeFromWorkletRuntime(uiRuntime_),
         uiScheduler_,
         nativeAnimationService_,
+        layoutMountBoundary_,
         uiManager_
 #ifdef ANDROID
         ,
diff --git a/packages/react-native-reanimated/Common/cpp/reanimated/NativeModules/ReanimatedModuleProxy.h b/packages/react-native-reanimated/Common/cpp/reanimated/NativeModules/ReanimatedModuleProxy.h
index 16164b363f23..08010bd59d62 100644
--- a/packages/react-native-reanimated/Common/cpp/reanimated/NativeModules/ReanimatedModuleProxy.h
+++ b/packages/react-native-reanimated/Common/cpp/reanimated/NativeModules/ReanimatedModuleProxy.h
@@ -240,6 +240,7 @@ class ReanimatedModuleProxy : public std::enable_shared_from_this<ReanimatedModu
   std::vector<std::function<void(double)>> pendingFrameCallbacks_;
   AnimatedSensorModule animatedSensorModule_;
   std::shared_ptr<native_animation::NativeAnimationService> nativeAnimationService_;
+  std::shared_ptr<LayoutMountBoundary> layoutMountBoundary_;
   std::shared_ptr<LayoutAnimationsManager> layoutAnimationsManager_;
   GetAnimationTimestampFunction getAnimationTimestamp_;
   std::function<void(double)> pendingAnimationFrameCallbackFromWorklets_;
diff --git a/packages/react-native-reanimated/Common/cpp/reanimated/Tools/PlatformDepMethodsHolder.h b/packages/react-native-reanimated/Common/cpp/reanimated/Tools/PlatformDepMethodsHolder.h
index 53197f243caf..8b0977d54ddd 100644
--- a/packages/react-native-reanimated/Common/cpp/reanimated/Tools/PlatformDepMethodsHolder.h
+++ b/packages/react-native-reanimated/Common/cpp/reanimated/Tools/PlatformDepMethodsHolder.h
@@ -1,6 +1,7 @@
 #pragma once
 
 #include <reanimated/CSS/core/transition/CSSPlatformTransitionProxy.h>
+#include <reanimated/LayoutAnimations/LayoutMountBoundary.h>
 #include <reanimated/NativeAnimations/NativeAnimationService.h>
 #include <reanimated/PseudoStyles/PseudoSelector.h>
 
@@ -74,10 +75,11 @@ struct PlatformDepMethodsHolder {
   css::CSSCanRoutePropertyFunction cssCanRouteProperty;
   css::CSSApplyTransitionFunction cssApplyTransition;
   css::CSSRemoveTransitionFunction cssRemoveTransition;
-  // Keep these two last so platform initializers that don't supply them
+  // Keep these three last so platform initializers that don't supply them
   // can omit them and rely on value-init (= null shared_ptr).
   std::shared_ptr<css::CSSPlatformAnimationFactory> platformAnimationFactory;
   std::shared_ptr<native_animation::NativeAnimationService> nativeAnimationService;
+  std::shared_ptr<LayoutMountBoundary> layoutMountBoundary;
 };
 
 } // namespace reanimated
diff --git a/packages/react-native-reanimated/apple/reanimated/apple/NativeAnimations/AppleLayoutMountBoundary.h b/packages/react-native-reanimated/apple/reanimated/apple/NativeAnimations/AppleLayoutMountBoundary.h
new file mode 100644
index 000000000000..75510aab05b2
--- /dev/null
+++ b/packages/react-native-reanimated/apple/reanimated/apple/NativeAnimations/AppleLayoutMountBoundary.h
@@ -0,0 +1,15 @@
+#pragma once
+
+#import <reanimated/LayoutAnimations/LayoutMountBoundary.h>
+
+#import <React/RCTSurfacePresenter.h>
+
+#import <memory>
+
+namespace reanimated {
+
+// The surface presenter calls the post-mount observer synchronously on the
+// main queue, after the mount instructions and before paint.
+std::shared_ptr<LayoutMountBoundary> makeAppleLayoutMountBoundary(RCTSurfacePresenter *surfacePresenter);
+
+} // namespace reanimated
diff --git a/packages/react-native-reanimated/apple/reanimated/apple/NativeAnimations/AppleLayoutMountBoundary.mm b/packages/react-native-reanimated/apple/reanimated/apple/NativeAnimations/AppleLayoutMountBoundary.mm
new file mode 100644
index 000000000000..30f0ed352687
--- /dev/null
+++ b/packages/react-native-reanimated/apple/reanimated/apple/NativeAnimations/AppleLayoutMountBoundary.mm
@@ -0,0 +1,151 @@
+#import <reanimated/apple/NativeAnimations/AppleLayoutMountBoundary.h>
+
+#import <reanimated/apple/REAUIView.h>
+
+#import <React/RCTAssert.h>
+#import <React/RCTComponent.h>
+#import <React/RCTComponentViewProtocol.h>
+#import <React/RCTComponentViewRegistry.h>
+#import <React/RCTMountingManager.h>
+#import <React/RCTSurfacePresenterStub.h>
+#import <React/RCTUtils.h>
+
+#import <QuartzCore/QuartzCore.h>
+
+#import <mutex>
+#import <utility>
+
+namespace reanimated {
+namespace {
+
+// Mutex-guarded: registration and mount notifications can use different
+// threads.
+struct PostMountObserverSlot {
+  std::mutex mutex;
+  PostMountObserver observer;
+
+  void set(PostMountObserver newObserver)
+  {
+    const std::lock_guard<std::mutex> lock(mutex);
+    observer = std::move(newObserver);
+  }
+
+  void notify(const facebook::react::SurfaceId surfaceId)
+  {
+    PostMountObserver current;
+    {
+      const std::lock_guard<std::mutex> lock(mutex);
+      current = observer;
+    }
+    if (current) {
+      current(surfaceId);
+    }
+  }
+};
+
+facebook::react::SurfaceId surfaceIdForMountedView(REAUIView *view)
+{
+  do {
+    if (RCTIsReactRootView(@(view.tag))) {
+      return static_cast<facebook::react::SurfaceId>(view.tag);
+    }
+    view = view.superview;
+  } while (view != nil);
+  return -1;
+}
+
+} // namespace
+} // namespace reanimated
+
+@interface REALayoutMountObserver : NSObject <RCTSurfacePresenterObserver>
+- (instancetype)initWithSlot:(std::shared_ptr<reanimated::PostMountObserverSlot>)slot;
+@end
+
+@implementation REALayoutMountObserver {
+  std::shared_ptr<reanimated::PostMountObserverSlot> _slot;
+}
+
+- (instancetype)initWithSlot:(std::shared_ptr<reanimated::PostMountObserverSlot>)slot
+{
+  if (self = [super init]) {
+    _slot = std::move(slot);
+  }
+  return self;
+}
+
+- (void)didMountComponentsWithRootTag:(NSInteger)rootTag
+{
+  RCTAssertMainQueue();
+  _slot->notify(static_cast<facebook::react::SurfaceId>(rootTag));
+}
+
+@end
+
+namespace reanimated {
+namespace {
+
+class AppleLayoutMountBoundary final : public LayoutMountBoundary {
+ public:
+  explicit AppleLayoutMountBoundary(RCTSurfacePresenter *surfacePresenter)
+      : surfacePresenter_(surfacePresenter), slot_(std::make_shared<PostMountObserverSlot>())
+  {
+    mountObserver_ = [[REALayoutMountObserver alloc] initWithSlot:slot_];
+    [surfacePresenter addObserver:mountObserver_];
+  }
+
+  ~AppleLayoutMountBoundary() override
+  {
+    RCTSurfacePresenter *surfacePresenter = surfacePresenter_;
+    if (surfacePresenter != nil) {
+      [surfacePresenter removeObserver:mountObserver_];
+    }
+  }
+
+  void setPostMountObserver(PostMountObserver observer) override
+  {
+    slot_->set(std::move(observer));
+  }
+
+  std::optional<MountedViewState> mountedState(
+      const facebook::react::SurfaceId surfaceId,
+      const facebook::react::Tag tag) override
+  {
+    RCTAssertMainQueue();
+    RCTSurfacePresenter *surfacePresenter = surfacePresenter_;
+    if (surfacePresenter == nil) {
+      return std::nullopt;
+    }
+    REAUIView<RCTComponentViewProtocol> *view =
+        [surfacePresenter.mountingManager.componentViewRegistry findComponentViewWithTag:tag];
+    if (view == nil || view.layer == nil || surfaceIdForMountedView(view) != surfaceId) {
+      return std::nullopt;
+    }
+    // Layer position and bounds report the mounted geometry free of any
+    // in-flight animation transform.
+    CALayer *layer = view.layer;
+    const CGPoint position = layer.position;
+    const CGRect bounds = layer.bounds;
+    const CGPoint anchorPoint = layer.anchorPoint;
+    MountedViewState state;
+    state.frame.origin.x = position.x - bounds.size.width * anchorPoint.x;
+    state.frame.origin.y = position.y - bounds.size.height * anchorPoint.y;
+    state.frame.size.width = bounds.size.width;
+    state.frame.size.height = bounds.size.height;
+    state.propsToken = reinterpret_cast<uintptr_t>([view props].get());
+    return state;
+  }
+
+ private:
+  __weak RCTSurfacePresenter *surfacePresenter_;
+  std::shared_ptr<PostMountObserverSlot> slot_;
+  REALayoutMountObserver *mountObserver_;
+};
+
+} // namespace
+
+std::shared_ptr<LayoutMountBoundary> makeAppleLayoutMountBoundary(RCTSurfacePresenter *surfacePresenter)
+{
+  return std::make_shared<AppleLayoutMountBoundary>(surfacePresenter);
+}
+
+} // namespace reanimated
diff --git a/packages/react-native-reanimated/apple/reanimated/apple/native/PlatformDepMethodsHolderImpl.mm b/packages/react-native-reanimated/apple/reanimated/apple/native/PlatformDepMethodsHolderImpl.mm
index 9ab51c0e2426..df6c40580395 100644
--- a/packages/react-native-reanimated/apple/reanimated/apple/native/PlatformDepMethodsHolderImpl.mm
+++ b/packages/react-native-reanimated/apple/reanimated/apple/native/PlatformDepMethodsHolderImpl.mm
@@ -3,6 +3,7 @@
 #import <reanimated/Tools/PlatformDepMethodsHolder.h>
 #import <reanimated/apple/CSS/REACSSPlatformTransitions.h>
 #import <reanimated/apple/CSS/REACSSSharedNativeTransitions.h>
+#import <reanimated/apple/NativeAnimations/AppleLayoutMountBoundary.h>
 #import <reanimated/apple/NativeAnimations/AppleNativeAnimationHost.h>
 #import <reanimated/apple/READisplayLink.h>
 #import <reanimated/apple/REANodesManager.h>
@@ -197,11 +198,13 @@ PlatformDepMethodsHolder makePlatformDepMethodsHolder(RCTModuleRegistry *moduleR
   auto detachPseudoSelectorFunction = makeDetachPseudoSelectorFunction(attachQueue);
 
   std::shared_ptr<native_animation::NativeAnimationService> nativeAnimationService;
+  std::shared_ptr<LayoutMountBoundary> layoutMountBoundary;
   auto cssCanRouteProperty = makeCSSCanRouteProperty();
   css::CSSApplyTransitionFunction cssApplyTransition;
   css::CSSRemoveTransitionFunction cssRemoveTransition;
   if constexpr (StaticFeatureFlags::getFlag("IOS_LAYOUT_ANIMATIONS_CORE_ANIMATION")) {
     nativeAnimationService = native_animation::makeAppleNativeAnimationService(nodesManager.surfacePresenter);
+    layoutMountBoundary = makeAppleLayoutMountBoundary(nodesManager.surfacePresenter);
     REACSSSharedNativeTransitions *platformTransitions =
         [[REACSSSharedNativeTransitions alloc] initWithSurfacePresenter:nodesManager.surfacePresenter
                                                  nativeAnimationService:nativeAnimationService];
@@ -270,6 +273,7 @@ PlatformDepMethodsHolder makePlatformDepMethodsHolder(RCTModuleRegistry *moduleR
       cssRemoveTransition,
       nullptr,
       nativeAnimationService,
+      layoutMountBoundary,
   };
   return platformDepMethodsHolder;
 }

From cdd48fcbfabc4f01d289b6e9ef9c4c262e15065c Mon Sep 17 00:00:00 2001
From: Oskar Pawica <pawicao@gmail.com>
Date: Mon, 17 Aug 2026 15:33:50 +0200
Subject: [PATCH 2/2] fix(Reanimated): replace do-while with while in
 surfaceIdForMountedView

The iOS clang-tidy job rejects do-while loops
(cppcoreguidelines-avoid-do-while); a while loop is equivalent here and
also handles a nil view gracefully.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 .../apple/NativeAnimations/AppleLayoutMountBoundary.mm        | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/packages/react-native-reanimated/apple/reanimated/apple/NativeAnimations/AppleLayoutMountBoundary.mm b/packages/react-native-reanimated/apple/reanimated/apple/NativeAnimations/AppleLayoutMountBoundary.mm
index 30f0ed352687..39d46e21019c 100644
--- a/packages/react-native-reanimated/apple/reanimated/apple/NativeAnimations/AppleLayoutMountBoundary.mm
+++ b/packages/react-native-reanimated/apple/reanimated/apple/NativeAnimations/AppleLayoutMountBoundary.mm
@@ -45,12 +45,12 @@ void notify(const facebook::react::SurfaceId surfaceId)
 
 facebook::react::SurfaceId surfaceIdForMountedView(REAUIView *view)
 {
-  do {
+  while (view != nil) {
     if (RCTIsReactRootView(@(view.tag))) {
       return static_cast<facebook::react::SurfaceId>(view.tag);
     }
     view = view.superview;
-  } while (view != nil);
+  }
   return -1;
 }