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..39d46e21019c
--- /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)
+{
+  while (view != nil) {
+    if (RCTIsReactRootView(@(view.tag))) {
+      return static_cast<facebook::react::SurfaceId>(view.tag);
+    }
+    view = view.superview;
+  }
+  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;
 }