diff --git a/packages/react-native/Libraries/Components/View/__tests__/View-deferYogaChildCloning-itest.js b/packages/react-native/Libraries/Components/View/__tests__/View-deferYogaChildCloning-itest.js
new file mode 100644
index 000000000000..41e37913e95c
--- /dev/null
+++ b/packages/react-native/Libraries/Components/View/__tests__/View-deferYogaChildCloning-itest.js
@@ -0,0 +1,468 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @fantom_flags deferYogaChildCloningUntilLayout:*
+ * @flow strict-local
+ * @format
+ */
+
+import '@react-native/fantom/src/setUpDefaultReactNativeEnvironment';
+
+import type {HostInstance} from 'react-native';
+
+import * as Fantom from '@react-native/fantom';
+import nullthrows from 'nullthrows';
+import * as React from 'react';
+import {useState} from 'react';
+import {ScrollView, Text, TextInput, View} from 'react-native';
+
+// With `deferYogaChildCloningUntilLayout`, the unchanged children of a node
+// that gets a new list of children stay shared with the previous revision of
+// the node until Yoga lays the node out. These tests run with the flag off and
+// on, and check that the mutations and layouts are the same.
+
+const CHILD_COUNT = 50;
+
+function rectOf(ref: {
+  current: HostInstance | null,
+}): [number, number, number, number] {
+  const rect = nullthrows(ref.current).getBoundingClientRect();
+  return [rect.x, rect.y, rect.width, rect.height];
+}
+
+type Refs = ReadonlyArray<React.RefObject<HostInstance | null>>;
+
+function createRefs(count: number): Refs {
+  return Array.from({length: count}, () => React.createRef<HostInstance>());
+}
+
+// Renders `steps` one commit at a time, then renders the last step into a
+// fresh root, and checks that both roots end up with the same layout.
+function expectSameLayoutAsFreshRender(
+  render: (step: number, refs: Refs) => React.MixedElement,
+  stepCount: number,
+  refCount: number,
+): void {
+  const refs = createRefs(refCount);
+  const root = Fantom.createRoot();
+  for (let step = 0; step < stepCount; step++) {
+    Fantom.runTask(() => {
+      root.render(render(step, refs));
+    });
+  }
+
+  const freshRefs = createRefs(refCount);
+  const freshRoot = Fantom.createRoot();
+  Fantom.runTask(() => {
+    freshRoot.render(render(stepCount - 1, freshRefs));
+  });
+
+  expect(refs.map(rectOf)).toEqual(freshRefs.map(rectOf));
+
+  root.destroy();
+  freshRoot.destroy();
+}
+
+function Rows({
+  colorIndex,
+  color,
+  tallIndex,
+  refs,
+}: {
+  colorIndex: number,
+  color: string,
+  tallIndex: number,
+  refs: ReadonlyArray<React.RefObject<HostInstance | null>>,
+}): React.MixedElement {
+  return (
+    <View collapsable={false} nativeID="list">
+      {refs.map((ref, i) => (
+        <View
+          key={i}
+          ref={ref}
+          nativeID={`row-${i}`}
+          style={{
+            height: i === tallIndex ? 30 : 10,
+            backgroundColor: i === colorIndex ? color : 'gray',
+          }}
+        />
+      ))}
+    </View>
+  );
+}
+
+describe('deferYogaChildCloningUntilLayout', () => {
+  it('updates one of many children without touching the others', () => {
+    const root = Fantom.createRoot();
+    const refs = Array.from({length: CHILD_COUNT}, () =>
+      React.createRef<HostInstance>(),
+    );
+
+    Fantom.runTask(() => {
+      root.render(
+        <Rows colorIndex={20} color="red" tallIndex={-1} refs={refs} />,
+      );
+    });
+    root.takeMountingManagerLogs();
+
+    Fantom.runTask(() => {
+      root.render(
+        <Rows colorIndex={20} color="blue" tallIndex={-1} refs={refs} />,
+      );
+    });
+
+    expect(root.takeMountingManagerLogs()).toEqual([
+      'Update {type: "View", nativeID: "row-20"}',
+    ]);
+    expect(rectOf(refs[20])).toEqual([0, 200, 390, 10]);
+    expect(rectOf(refs[CHILD_COUNT - 1])).toEqual([0, 490, 390, 10]);
+
+    root.destroy();
+  });
+
+  it('lays out shared children when a sibling changes size', () => {
+    const root = Fantom.createRoot();
+    const refs = Array.from({length: CHILD_COUNT}, () =>
+      React.createRef<HostInstance>(),
+    );
+
+    Fantom.runTask(() => {
+      root.render(
+        <Rows colorIndex={20} color="red" tallIndex={-1} refs={refs} />,
+      );
+    });
+
+    // Commits that change no layout input, so the list is not laid out and
+    // its unchanged children stay shared.
+    for (const color of ['blue', 'green', 'yellow']) {
+      Fantom.runTask(() => {
+        root.render(
+          <Rows colorIndex={20} color={color} tallIndex={-1} refs={refs} />,
+        );
+      });
+    }
+    root.takeMountingManagerLogs();
+
+    // Row 10 grows by 20, which moves every row after it.
+    Fantom.runTask(() => {
+      root.render(
+        <Rows colorIndex={20} color="yellow" tallIndex={10} refs={refs} />,
+      );
+    });
+
+    expect(rectOf(refs[9])).toEqual([0, 90, 390, 10]);
+    expect(rectOf(refs[10])).toEqual([0, 100, 390, 30]);
+    expect(rectOf(refs[11])).toEqual([0, 130, 390, 10]);
+    expect(rectOf(refs[CHILD_COUNT - 1])).toEqual([0, 510, 390, 10]);
+
+    const logs = root.takeMountingManagerLogs();
+    expect(logs).toContain('Update {type: "View", nativeID: "row-10"}');
+    expect(logs).toContain('Update {type: "View", nativeID: "row-11"}');
+    expect(logs).toContain(
+      `Update {type: "View", nativeID: "row-${CHILD_COUNT - 1}"}`,
+    );
+    expect(logs).not.toContain('Update {type: "View", nativeID: "row-9"}');
+
+    root.destroy();
+  });
+
+  it('lays out a nested child whose parent was shared', () => {
+    const root = Fantom.createRoot();
+    const innerRef = React.createRef<HostInstance>();
+    const groupRef = React.createRef<HostInstance>();
+    const afterRef = React.createRef<HostInstance>();
+
+    function Tree({
+      innerHeight,
+      color,
+    }: {
+      innerHeight: number,
+      color: string,
+    }): React.MixedElement {
+      return (
+        <View collapsable={false}>
+          <View ref={groupRef} collapsable={false}>
+            <View ref={innerRef} style={{height: innerHeight}} />
+          </View>
+          <View ref={afterRef} style={{height: 10, backgroundColor: color}} />
+        </View>
+      );
+    }
+
+    Fantom.runTask(() => {
+      root.render(<Tree innerHeight={10} color="red" />);
+    });
+    // Only the last child changes, so the group stays shared.
+    Fantom.runTask(() => {
+      root.render(<Tree innerHeight={10} color="blue" />);
+    });
+    // The group's child grows, which moves the last child.
+    Fantom.runTask(() => {
+      root.render(<Tree innerHeight={40} color="blue" />);
+    });
+
+    expect(rectOf(groupRef)).toEqual([0, 0, 390, 40]);
+    expect(rectOf(innerRef)).toEqual([0, 0, 390, 40]);
+    expect(rectOf(afterRef)).toEqual([0, 40, 390, 10]);
+
+    root.destroy();
+  });
+
+  it('keeps layouts correct when scrolling and then changing content', () => {
+    const root = Fantom.createRoot();
+    const scrollRef = React.createRef<HostInstance>();
+    const refs = Array.from({length: CHILD_COUNT}, () =>
+      React.createRef<HostInstance>(),
+    );
+
+    function List({tallIndex}: {tallIndex: number}): React.MixedElement {
+      return (
+        <View collapsable={false}>
+          <View style={{height: 50}} collapsable={false} />
+          <ScrollView ref={scrollRef} style={{height: 200}}>
+            {refs.map((ref, i) => (
+              <View
+                key={i}
+                ref={ref}
+                style={{height: i === tallIndex ? 30 : 10}}
+              />
+            ))}
+          </ScrollView>
+        </View>
+      );
+    }
+
+    Fantom.runTask(() => {
+      root.render(<List tallIndex={-1} />);
+    });
+
+    // Each scroll commits a state update of the ScrollView, which clones its
+    // ancestors with a new list of children.
+    Fantom.scrollTo(scrollRef, {x: 0, y: 100});
+    Fantom.scrollTo(scrollRef, {x: 0, y: 150});
+
+    Fantom.runTask(() => {
+      root.render(<List tallIndex={0} />);
+    });
+
+    // Rows are offset by the header (50) and the scroll offset (150).
+    expect(rectOf(refs[0])).toEqual([0, 50 - 150, 390, 30]);
+    expect(rectOf(refs[1])).toEqual([0, 80 - 150, 390, 10]);
+    expect(rectOf(refs[CHILD_COUNT - 1])).toEqual([0, 560 - 150, 390, 10]);
+
+    root.destroy();
+  });
+
+  it('keeps layouts correct when a node with shared children is hidden and shown', () => {
+    const root = Fantom.createRoot();
+    const refs = Array.from({length: 3}, () => React.createRef<HostInstance>());
+    const afterRef = React.createRef<HostInstance>();
+
+    function Tree({
+      hidden,
+      color,
+    }: {
+      hidden: boolean,
+      color: string,
+    }): React.MixedElement {
+      return (
+        <View collapsable={false}>
+          <View collapsable={false} style={{display: hidden ? 'none' : 'flex'}}>
+            {refs.map((ref, i) => (
+              <View
+                key={i}
+                ref={ref}
+                style={{
+                  height: 10,
+                  backgroundColor: i === 0 ? color : 'gray',
+                }}
+              />
+            ))}
+          </View>
+          <View ref={afterRef} style={{height: 10}} />
+        </View>
+      );
+    }
+
+    Fantom.runTask(() => {
+      root.render(<Tree hidden={false} color="red" />);
+    });
+    Fantom.runTask(() => {
+      root.render(<Tree hidden={true} color="red" />);
+    });
+    expect(rectOf(afterRef)).toEqual([0, 0, 390, 10]);
+
+    // A change while hidden: the hidden node gets a new list of children.
+    Fantom.runTask(() => {
+      root.render(<Tree hidden={true} color="blue" />);
+    });
+    Fantom.runTask(() => {
+      root.render(<Tree hidden={false} color="blue" />);
+    });
+
+    expect(rectOf(refs[0])).toEqual([0, 0, 390, 10]);
+    expect(rectOf(refs[2])).toEqual([0, 20, 390, 10]);
+    expect(rectOf(afterRef)).toEqual([0, 30, 390, 10]);
+
+    root.destroy();
+  });
+
+  it('lays out shared children of a node whose layout comes from the cache', () => {
+    // The container's height changes while the row's size doesn't, so Yoga
+    // restores the row from its cache; then a sibling changes color.
+    expectSameLayoutAsFreshRender(
+      (step, refs) => (
+        <View
+          collapsable={false}
+          style={{
+            height: step % 2 === 0 ? 300 : 400,
+            justifyContent: 'center',
+          }}>
+          <View collapsable={false} style={{flexDirection: 'row'}}>
+            <View ref={refs[0]} style={{width: 20, height: 20}} />
+            <View
+              ref={refs[1]}
+              style={{
+                width: 20,
+                height: 20,
+                backgroundColor: step < 2 ? 'red' : 'blue',
+              }}
+            />
+          </View>
+          <View ref={refs[2]} style={{height: 10}} />
+        </View>
+      ),
+      5,
+      3,
+    );
+  });
+
+  it('positions an absolute child of a shared static node', () => {
+    expectSameLayoutAsFreshRender(
+      (step, refs) => (
+        <View
+          ref={refs[0]}
+          collapsable={false}
+          style={{width: 200, height: step < 2 ? 100 : 150}}>
+          <View ref={refs[1]} collapsable={false} style={{position: 'static'}}>
+            <View
+              ref={refs[2]}
+              style={{position: 'absolute', bottom: 0, width: 10, height: 10}}
+            />
+          </View>
+          <View
+            ref={refs[3]}
+            style={{height: 10, backgroundColor: step < 1 ? 'red' : 'blue'}}
+          />
+        </View>
+      ),
+      3,
+      4,
+    );
+  });
+
+  it('lays out shared children of a display: contents node', () => {
+    expectSameLayoutAsFreshRender(
+      (step, refs) => (
+        <View collapsable={false}>
+          <View style={{display: 'contents'}}>
+            <View ref={refs[0]} style={{height: step < 2 ? 10 : 30}} />
+            <View ref={refs[1]} style={{height: 10}} />
+          </View>
+          <View
+            ref={refs[2]}
+            style={{height: 10, backgroundColor: step < 1 ? 'red' : 'blue'}}
+          />
+        </View>
+      ),
+      3,
+      3,
+    );
+  });
+
+  it('aligns shared text to the baseline', () => {
+    expectSameLayoutAsFreshRender(
+      (step, refs) => (
+        <View
+          collapsable={false}
+          style={{flexDirection: 'row', alignItems: 'baseline'}}>
+          <Text ref={refs[0]} style={{fontSize: step < 2 ? 10 : 20}}>
+            Hello
+          </Text>
+          <Text
+            ref={refs[1]}
+            style={{fontSize: 10, color: step < 1 ? 'red' : 'blue'}}>
+            World
+          </Text>
+          <View ref={refs[2]} style={{width: 10, height: 10}} />
+        </View>
+      ),
+      3,
+      3,
+    );
+  });
+
+  // The same steps as View-yogaNodeOwnerAssertion-itest.js, which once left
+  // `hasNewLayout` set on a hidden child shared with an older revision. With
+  // the flag on, more children stay shared, so run them twice.
+  it('does not trip the Yoga node owner assertion after resize then restyle', () => {
+    let triggerResize: () => void = () => {};
+    let triggerRestyle: () => void = () => {};
+
+    function Repro(): React.MixedElement {
+      const [tall, setTall] = useState(false);
+      const [highlighted, setHighlighted] = useState(false);
+
+      triggerResize = () => setTall(v => !v);
+      triggerRestyle = () => setHighlighted(v => !v);
+
+      return (
+        <View style={{flex: 1}}>
+          <View style={{height: tall ? 400 : 300, justifyContent: 'center'}}>
+            <View
+              style={{
+                flexDirection: 'row',
+                alignItems: 'center',
+                justifyContent: 'center',
+              }}>
+              <View style={{justifyContent: 'center'}}>
+                <View style={{display: 'none'}} />
+              </View>
+              <TextInput
+                style={[
+                  {borderWidth: 1, minWidth: 120},
+                  highlighted && {borderColor: 'red'},
+                ]}
+              />
+            </View>
+          </View>
+        </View>
+      );
+    }
+
+    const root = Fantom.createRoot({viewportWidth: 390, viewportHeight: 844});
+
+    Fantom.runTask(() => {
+      root.render(<Repro />);
+    });
+    Fantom.runTask(() => {
+      triggerResize();
+    });
+    Fantom.runTask(() => {
+      triggerRestyle();
+    });
+    Fantom.runTask(() => {
+      triggerResize();
+    });
+    Fantom.runTask(() => {
+      triggerRestyle();
+    });
+
+    expect(root.getRenderedOutput().toJSX()).not.toBe(null);
+
+    root.destroy();
+  });
+});
diff --git a/packages/react-native/ReactAndroid/src/main/java/com/facebook/react/internal/featureflags/ReactNativeFeatureFlags.kt b/packages/react-native/ReactAndroid/src/main/java/com/facebook/react/internal/featureflags/ReactNativeFeatureFlags.kt
index 243a3eae3fa8..af1fb7e602c5 100644
--- a/packages/react-native/ReactAndroid/src/main/java/com/facebook/react/internal/featureflags/ReactNativeFeatureFlags.kt
+++ b/packages/react-native/ReactAndroid/src/main/java/com/facebook/react/internal/featureflags/ReactNativeFeatureFlags.kt
@@ -4,7 +4,7 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- * @generated SignedSource<<b5f4608f47743d0e2e9b1db3db551227>>
+ * @generated SignedSource<<2abf1e8d28c8f625e2a51cf2e48c1c90>>
  */
 
 /**
@@ -60,6 +60,12 @@ public object ReactNativeFeatureFlags {
   @JvmStatic
   public fun deferTextInputTruncationIOS(): Boolean = accessor.deferTextInputTruncationIOS()
 
+  /**
+   * When a node gets a new list of children, the children that a previous revision of the node still owns stay shared with that revision instead of being cloned right away. Yoga clones them if it lays the node out.
+   */
+  @JvmStatic
+  public fun deferYogaChildCloningUntilLayout(): Boolean = accessor.deferYogaChildCloningUntilLayout()
+
   /**
    * Dispatch view commands in mount item order.
    */
diff --git a/packages/react-native/ReactAndroid/src/main/java/com/facebook/react/internal/featureflags/ReactNativeFeatureFlagsCxxAccessor.kt b/packages/react-native/ReactAndroid/src/main/java/com/facebook/react/internal/featureflags/ReactNativeFeatureFlagsCxxAccessor.kt
index 0f110b756115..ee6a8029e445 100644
--- a/packages/react-native/ReactAndroid/src/main/java/com/facebook/react/internal/featureflags/ReactNativeFeatureFlagsCxxAccessor.kt
+++ b/packages/react-native/ReactAndroid/src/main/java/com/facebook/react/internal/featureflags/ReactNativeFeatureFlagsCxxAccessor.kt
@@ -4,7 +4,7 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- * @generated SignedSource<<d2d170d333194ce2f2a4f1d93321ac6d>>
+ * @generated SignedSource<<f41241abd53c60b3203e664b426db32b>>
  */
 
 /**
@@ -25,6 +25,7 @@ internal class ReactNativeFeatureFlagsCxxAccessor : ReactNativeFeatureFlagsAcces
   private var cxxNativeAnimatedEnabledCache: Boolean? = null
   private var defaultTextToOverflowHiddenCache: Boolean? = null
   private var deferTextInputTruncationIOSCache: Boolean? = null
+  private var deferYogaChildCloningUntilLayoutCache: Boolean? = null
   private var disableEarlyViewCommandExecutionCache: Boolean? = null
   private var disableIdleEventDispatchFrameCallbackRearmAndroidCache: Boolean? = null
   private var disableIdleMountItemFrameCallbackRearmAndroidCache: Boolean? = null
@@ -162,6 +163,15 @@ internal class ReactNativeFeatureFlagsCxxAccessor : ReactNativeFeatureFlagsAcces
     return cached
   }
 
+  override fun deferYogaChildCloningUntilLayout(): Boolean {
+    var cached = deferYogaChildCloningUntilLayoutCache
+    if (cached == null) {
+      cached = ReactNativeFeatureFlagsCxxInterop.deferYogaChildCloningUntilLayout()
+      deferYogaChildCloningUntilLayoutCache = cached
+    }
+    return cached
+  }
+
   override fun disableEarlyViewCommandExecution(): Boolean {
     var cached = disableEarlyViewCommandExecutionCache
     if (cached == null) {
diff --git a/packages/react-native/ReactAndroid/src/main/java/com/facebook/react/internal/featureflags/ReactNativeFeatureFlagsCxxInterop.kt b/packages/react-native/ReactAndroid/src/main/java/com/facebook/react/internal/featureflags/ReactNativeFeatureFlagsCxxInterop.kt
index fc4b23624bbd..414017735948 100644
--- a/packages/react-native/ReactAndroid/src/main/java/com/facebook/react/internal/featureflags/ReactNativeFeatureFlagsCxxInterop.kt
+++ b/packages/react-native/ReactAndroid/src/main/java/com/facebook/react/internal/featureflags/ReactNativeFeatureFlagsCxxInterop.kt
@@ -4,7 +4,7 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- * @generated SignedSource<<ec3e384af62c0e672da53b57354bca62>>
+ * @generated SignedSource<<8c3be9a45fa1118c418be24467580edf>>
  */
 
 /**
@@ -38,6 +38,8 @@ public object ReactNativeFeatureFlagsCxxInterop {
 
   @DoNotStrip @JvmStatic public external fun deferTextInputTruncationIOS(): Boolean
 
+  @DoNotStrip @JvmStatic public external fun deferYogaChildCloningUntilLayout(): Boolean
+
   @DoNotStrip @JvmStatic public external fun disableEarlyViewCommandExecution(): Boolean
 
   @DoNotStrip @JvmStatic public external fun disableIdleEventDispatchFrameCallbackRearmAndroid(): Boolean
diff --git a/packages/react-native/ReactAndroid/src/main/java/com/facebook/react/internal/featureflags/ReactNativeFeatureFlagsDefaults.kt b/packages/react-native/ReactAndroid/src/main/java/com/facebook/react/internal/featureflags/ReactNativeFeatureFlagsDefaults.kt
index 380e9ec4c213..4da3b2134b02 100644
--- a/packages/react-native/ReactAndroid/src/main/java/com/facebook/react/internal/featureflags/ReactNativeFeatureFlagsDefaults.kt
+++ b/packages/react-native/ReactAndroid/src/main/java/com/facebook/react/internal/featureflags/ReactNativeFeatureFlagsDefaults.kt
@@ -4,7 +4,7 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- * @generated SignedSource<<cd6aa804d1c10b93775adf83419368e3>>
+ * @generated SignedSource<<b194cf90d38e2d2b538d5be81c24af55>>
  */
 
 /**
@@ -33,6 +33,8 @@ public open class ReactNativeFeatureFlagsDefaults : ReactNativeFeatureFlagsProvi
 
   override fun deferTextInputTruncationIOS(): Boolean = false
 
+  override fun deferYogaChildCloningUntilLayout(): Boolean = false
+
   override fun disableEarlyViewCommandExecution(): Boolean = false
 
   override fun disableIdleEventDispatchFrameCallbackRearmAndroid(): Boolean = false
diff --git a/packages/react-native/ReactAndroid/src/main/java/com/facebook/react/internal/featureflags/ReactNativeFeatureFlagsLocalAccessor.kt b/packages/react-native/ReactAndroid/src/main/java/com/facebook/react/internal/featureflags/ReactNativeFeatureFlagsLocalAccessor.kt
index 073cc2b90a73..328d4a646547 100644
--- a/packages/react-native/ReactAndroid/src/main/java/com/facebook/react/internal/featureflags/ReactNativeFeatureFlagsLocalAccessor.kt
+++ b/packages/react-native/ReactAndroid/src/main/java/com/facebook/react/internal/featureflags/ReactNativeFeatureFlagsLocalAccessor.kt
@@ -4,7 +4,7 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- * @generated SignedSource<<c36b0b2d7173aa78b7cb175658fc89d2>>
+ * @generated SignedSource<<ad04b2eec324da0239508ee8164df70b>>
  */
 
 /**
@@ -29,6 +29,7 @@ internal class ReactNativeFeatureFlagsLocalAccessor : ReactNativeFeatureFlagsAcc
   private var cxxNativeAnimatedEnabledCache: Boolean? = null
   private var defaultTextToOverflowHiddenCache: Boolean? = null
   private var deferTextInputTruncationIOSCache: Boolean? = null
+  private var deferYogaChildCloningUntilLayoutCache: Boolean? = null
   private var disableEarlyViewCommandExecutionCache: Boolean? = null
   private var disableIdleEventDispatchFrameCallbackRearmAndroidCache: Boolean? = null
   private var disableIdleMountItemFrameCallbackRearmAndroidCache: Boolean? = null
@@ -171,6 +172,16 @@ internal class ReactNativeFeatureFlagsLocalAccessor : ReactNativeFeatureFlagsAcc
     return cached
   }
 
+  override fun deferYogaChildCloningUntilLayout(): Boolean {
+    var cached = deferYogaChildCloningUntilLayoutCache
+    if (cached == null) {
+      cached = currentProvider.deferYogaChildCloningUntilLayout()
+      accessedFeatureFlags.add("deferYogaChildCloningUntilLayout")
+      deferYogaChildCloningUntilLayoutCache = cached
+    }
+    return cached
+  }
+
   override fun disableEarlyViewCommandExecution(): Boolean {
     var cached = disableEarlyViewCommandExecutionCache
     if (cached == null) {
diff --git a/packages/react-native/ReactAndroid/src/main/java/com/facebook/react/internal/featureflags/ReactNativeFeatureFlagsProvider.kt b/packages/react-native/ReactAndroid/src/main/java/com/facebook/react/internal/featureflags/ReactNativeFeatureFlagsProvider.kt
index a639fd19fa5e..0581da7ab457 100644
--- a/packages/react-native/ReactAndroid/src/main/java/com/facebook/react/internal/featureflags/ReactNativeFeatureFlagsProvider.kt
+++ b/packages/react-native/ReactAndroid/src/main/java/com/facebook/react/internal/featureflags/ReactNativeFeatureFlagsProvider.kt
@@ -4,7 +4,7 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- * @generated SignedSource<<c5e9b41b76c5580c0a4ba848af4e36a5>>
+ * @generated SignedSource<<e71427d93782550acd6fc378661487fa>>
  */
 
 /**
@@ -33,6 +33,8 @@ public interface ReactNativeFeatureFlagsProvider {
 
   @DoNotStrip public fun deferTextInputTruncationIOS(): Boolean
 
+  @DoNotStrip public fun deferYogaChildCloningUntilLayout(): Boolean
+
   @DoNotStrip public fun disableEarlyViewCommandExecution(): Boolean
 
   @DoNotStrip public fun disableIdleEventDispatchFrameCallbackRearmAndroid(): Boolean
diff --git a/packages/react-native/ReactAndroid/src/main/jni/react/featureflags/JReactNativeFeatureFlagsCxxInterop.cpp b/packages/react-native/ReactAndroid/src/main/jni/react/featureflags/JReactNativeFeatureFlagsCxxInterop.cpp
index 882566ee95ea..fd312743a54f 100644
--- a/packages/react-native/ReactAndroid/src/main/jni/react/featureflags/JReactNativeFeatureFlagsCxxInterop.cpp
+++ b/packages/react-native/ReactAndroid/src/main/jni/react/featureflags/JReactNativeFeatureFlagsCxxInterop.cpp
@@ -4,7 +4,7 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- * @generated SignedSource<<1ab2eec7b9c5bdd181ec5fbfd37149ab>>
+ * @generated SignedSource<<f831fb06cb03ec0e45fa6a9e433e1c89>>
  */
 
 /**
@@ -69,6 +69,12 @@ class ReactNativeFeatureFlagsJavaProvider
     return method(javaProvider_);
   }
 
+  bool deferYogaChildCloningUntilLayout() override {
+    static const auto method =
+        getReactNativeFeatureFlagsProviderJavaClass()->getMethod<jboolean()>("deferYogaChildCloningUntilLayout");
+    return method(javaProvider_);
+  }
+
   bool disableEarlyViewCommandExecution() override {
     static const auto method =
         getReactNativeFeatureFlagsProviderJavaClass()->getMethod<jboolean()>("disableEarlyViewCommandExecution");
@@ -644,6 +650,11 @@ bool JReactNativeFeatureFlagsCxxInterop::deferTextInputTruncationIOS(
   return ReactNativeFeatureFlags::deferTextInputTruncationIOS();
 }
 
+bool JReactNativeFeatureFlagsCxxInterop::deferYogaChildCloningUntilLayout(
+    facebook::jni::alias_ref<JReactNativeFeatureFlagsCxxInterop> /*unused*/) {
+  return ReactNativeFeatureFlags::deferYogaChildCloningUntilLayout();
+}
+
 bool JReactNativeFeatureFlagsCxxInterop::disableEarlyViewCommandExecution(
     facebook::jni::alias_ref<JReactNativeFeatureFlagsCxxInterop> /*unused*/) {
   return ReactNativeFeatureFlags::disableEarlyViewCommandExecution();
@@ -1145,6 +1156,9 @@ void JReactNativeFeatureFlagsCxxInterop::registerNatives() {
       makeNativeMethod(
         "deferTextInputTruncationIOS",
         JReactNativeFeatureFlagsCxxInterop::deferTextInputTruncationIOS),
+      makeNativeMethod(
+        "deferYogaChildCloningUntilLayout",
+        JReactNativeFeatureFlagsCxxInterop::deferYogaChildCloningUntilLayout),
       makeNativeMethod(
         "disableEarlyViewCommandExecution",
         JReactNativeFeatureFlagsCxxInterop::disableEarlyViewCommandExecution),
diff --git a/packages/react-native/ReactAndroid/src/main/jni/react/featureflags/JReactNativeFeatureFlagsCxxInterop.h b/packages/react-native/ReactAndroid/src/main/jni/react/featureflags/JReactNativeFeatureFlagsCxxInterop.h
index 8ae17b1dc3b6..b71f108f9c78 100644
--- a/packages/react-native/ReactAndroid/src/main/jni/react/featureflags/JReactNativeFeatureFlagsCxxInterop.h
+++ b/packages/react-native/ReactAndroid/src/main/jni/react/featureflags/JReactNativeFeatureFlagsCxxInterop.h
@@ -4,7 +4,7 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- * @generated SignedSource<<2c8f9205f1de55591ede3845ba2fa877>>
+ * @generated SignedSource<<5e769fa7ac77deacc90e2ae22182b931>>
  */
 
 /**
@@ -45,6 +45,9 @@ class JReactNativeFeatureFlagsCxxInterop
   static bool deferTextInputTruncationIOS(
     facebook::jni::alias_ref<JReactNativeFeatureFlagsCxxInterop>);
 
+  static bool deferYogaChildCloningUntilLayout(
+    facebook::jni::alias_ref<JReactNativeFeatureFlagsCxxInterop>);
+
   static bool disableEarlyViewCommandExecution(
     facebook::jni::alias_ref<JReactNativeFeatureFlagsCxxInterop>);
 
diff --git a/packages/react-native/ReactCommon/react/featureflags/ReactNativeFeatureFlags.cpp b/packages/react-native/ReactCommon/react/featureflags/ReactNativeFeatureFlags.cpp
index c2457ce7afc5..9c01c56b62d7 100644
--- a/packages/react-native/ReactCommon/react/featureflags/ReactNativeFeatureFlags.cpp
+++ b/packages/react-native/ReactCommon/react/featureflags/ReactNativeFeatureFlags.cpp
@@ -4,7 +4,7 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- * @generated SignedSource<<7542508e6a3b0dd942557748186527b3>>
+ * @generated SignedSource<<8d8245d58026b35edf8a6d2c9a3ee95b>>
  */
 
 /**
@@ -46,6 +46,10 @@ bool ReactNativeFeatureFlags::deferTextInputTruncationIOS() {
   return getAccessor().deferTextInputTruncationIOS();
 }
 
+bool ReactNativeFeatureFlags::deferYogaChildCloningUntilLayout() {
+  return getAccessor().deferYogaChildCloningUntilLayout();
+}
+
 bool ReactNativeFeatureFlags::disableEarlyViewCommandExecution() {
   return getAccessor().disableEarlyViewCommandExecution();
 }
diff --git a/packages/react-native/ReactCommon/react/featureflags/ReactNativeFeatureFlags.h b/packages/react-native/ReactCommon/react/featureflags/ReactNativeFeatureFlags.h
index 9668de64aaee..1ffbacbd95f5 100644
--- a/packages/react-native/ReactCommon/react/featureflags/ReactNativeFeatureFlags.h
+++ b/packages/react-native/ReactCommon/react/featureflags/ReactNativeFeatureFlags.h
@@ -4,7 +4,7 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- * @generated SignedSource<<e3c3ccaf63fcdcf48c6f02f793f77b65>>
+ * @generated SignedSource<<dc1037c6be4656b3eea974b7b20018b0>>
  */
 
 /**
@@ -66,6 +66,11 @@ class ReactNativeFeatureFlags {
    */
   RN_EXPORT static bool deferTextInputTruncationIOS();
 
+  /**
+   * When a node gets a new list of children, the children that a previous revision of the node still owns stay shared with that revision instead of being cloned right away. Yoga clones them if it lays the node out.
+   */
+  RN_EXPORT static bool deferYogaChildCloningUntilLayout();
+
   /**
    * Dispatch view commands in mount item order.
    */
diff --git a/packages/react-native/ReactCommon/react/featureflags/ReactNativeFeatureFlagsAccessor.cpp b/packages/react-native/ReactCommon/react/featureflags/ReactNativeFeatureFlagsAccessor.cpp
index 418d452984b9..c9c6006be3f1 100644
--- a/packages/react-native/ReactCommon/react/featureflags/ReactNativeFeatureFlagsAccessor.cpp
+++ b/packages/react-native/ReactCommon/react/featureflags/ReactNativeFeatureFlagsAccessor.cpp
@@ -4,7 +4,7 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- * @generated SignedSource<<3c7ff59afd1e9e05051e888b51a39ac0>>
+ * @generated SignedSource<<2edb4f583faf80149a6c816fd9da07c5>>
  */
 
 /**
@@ -119,6 +119,24 @@ bool ReactNativeFeatureFlagsAccessor::deferTextInputTruncationIOS() {
   return flagValue.value();
 }
 
+bool ReactNativeFeatureFlagsAccessor::deferYogaChildCloningUntilLayout() {
+  auto flagValue = deferYogaChildCloningUntilLayout_.load();
+
+  if (!flagValue.has_value()) {
+    // This block is not exclusive but it is not necessary.
+    // If multiple threads try to initialize the feature flag, we would only
+    // be accessing the provider multiple times but the end state of this
+    // instance and the returned flag value would be the same.
+
+    markFlagAsAccessed(5, "deferYogaChildCloningUntilLayout");
+
+    flagValue = currentProvider_->deferYogaChildCloningUntilLayout();
+    deferYogaChildCloningUntilLayout_ = flagValue;
+  }
+
+  return flagValue.value();
+}
+
 bool ReactNativeFeatureFlagsAccessor::disableEarlyViewCommandExecution() {
   auto flagValue = disableEarlyViewCommandExecution_.load();
 
@@ -128,7 +146,7 @@ bool ReactNativeFeatureFlagsAccessor::disableEarlyViewCommandExecution() {
     // be accessing the provider multiple times but the end state of this
     // instance and the returned flag value would be the same.
 
-    markFlagAsAccessed(5, "disableEarlyViewCommandExecution");
+    markFlagAsAccessed(6, "disableEarlyViewCommandExecution");
 
     flagValue = currentProvider_->disableEarlyViewCommandExecution();
     disableEarlyViewCommandExecution_ = flagValue;
@@ -146,7 +164,7 @@ bool ReactNativeFeatureFlagsAccessor::disableIdleEventDispatchFrameCallbackRearm
     // be accessing the provider multiple times but the end state of this
     // instance and the returned flag value would be the same.
 
-    markFlagAsAccessed(6, "disableIdleEventDispatchFrameCallbackRearmAndroid");
+    markFlagAsAccessed(7, "disableIdleEventDispatchFrameCallbackRearmAndroid");
 
     flagValue = currentProvider_->disableIdleEventDispatchFrameCallbackRearmAndroid();
     disableIdleEventDispatchFrameCallbackRearmAndroid_ = flagValue;
@@ -164,7 +182,7 @@ bool ReactNativeFeatureFlagsAccessor::disableIdleMountItemFrameCallbackRearmAndr
     // be accessing the provider multiple times but the end state of this
     // instance and the returned flag value would be the same.
 
-    markFlagAsAccessed(7, "disableIdleMountItemFrameCallbackRearmAndroid");
+    markFlagAsAccessed(8, "disableIdleMountItemFrameCallbackRearmAndroid");
 
     flagValue = currentProvider_->disableIdleMountItemFrameCallbackRearmAndroid();
     disableIdleMountItemFrameCallbackRearmAndroid_ = flagValue;
@@ -182,7 +200,7 @@ bool ReactNativeFeatureFlagsAccessor::disableImageViewPreallocationAndroid() {
     // be accessing the provider multiple times but the end state of this
     // instance and the returned flag value would be the same.
 
-    markFlagAsAccessed(8, "disableImageViewPreallocationAndroid");
+    markFlagAsAccessed(9, "disableImageViewPreallocationAndroid");
 
     flagValue = currentProvider_->disableImageViewPreallocationAndroid();
     disableImageViewPreallocationAndroid_ = flagValue;
@@ -200,7 +218,7 @@ bool ReactNativeFeatureFlagsAccessor::disableMountItemReorderingAndroid() {
     // be accessing the provider multiple times but the end state of this
     // instance and the returned flag value would be the same.
 
-    markFlagAsAccessed(9, "disableMountItemReorderingAndroid");
+    markFlagAsAccessed(10, "disableMountItemReorderingAndroid");
 
     flagValue = currentProvider_->disableMountItemReorderingAndroid();
     disableMountItemReorderingAndroid_ = flagValue;
@@ -218,7 +236,7 @@ bool ReactNativeFeatureFlagsAccessor::disableSubviewClippingAndroid() {
     // be accessing the provider multiple times but the end state of this
     // instance and the returned flag value would be the same.
 
-    markFlagAsAccessed(10, "disableSubviewClippingAndroid");
+    markFlagAsAccessed(11, "disableSubviewClippingAndroid");
 
     flagValue = currentProvider_->disableSubviewClippingAndroid();
     disableSubviewClippingAndroid_ = flagValue;
@@ -236,7 +254,7 @@ bool ReactNativeFeatureFlagsAccessor::disableTextLayoutManagerCacheAndroid() {
     // be accessing the provider multiple times but the end state of this
     // instance and the returned flag value would be the same.
 
-    markFlagAsAccessed(11, "disableTextLayoutManagerCacheAndroid");
+    markFlagAsAccessed(12, "disableTextLayoutManagerCacheAndroid");
 
     flagValue = currentProvider_->disableTextLayoutManagerCacheAndroid();
     disableTextLayoutManagerCacheAndroid_ = flagValue;
@@ -254,7 +272,7 @@ bool ReactNativeFeatureFlagsAccessor::disableViewPreallocationAndroid() {
     // be accessing the provider multiple times but the end state of this
     // instance and the returned flag value would be the same.
 
-    markFlagAsAccessed(12, "disableViewPreallocationAndroid");
+    markFlagAsAccessed(13, "disableViewPreallocationAndroid");
 
     flagValue = currentProvider_->disableViewPreallocationAndroid();
     disableViewPreallocationAndroid_ = flagValue;
@@ -272,7 +290,7 @@ bool ReactNativeFeatureFlagsAccessor::enableAccessibilityOrder() {
     // be accessing the provider multiple times but the end state of this
     // instance and the returned flag value would be the same.
 
-    markFlagAsAccessed(13, "enableAccessibilityOrder");
+    markFlagAsAccessed(14, "enableAccessibilityOrder");
 
     flagValue = currentProvider_->enableAccessibilityOrder();
     enableAccessibilityOrder_ = flagValue;
@@ -290,7 +308,7 @@ bool ReactNativeFeatureFlagsAccessor::enableAccumulatedUpdatesInRawPropsAndroid(
     // be accessing the provider multiple times but the end state of this
     // instance and the returned flag value would be the same.
 
-    markFlagAsAccessed(14, "enableAccumulatedUpdatesInRawPropsAndroid");
+    markFlagAsAccessed(15, "enableAccumulatedUpdatesInRawPropsAndroid");
 
     flagValue = currentProvider_->enableAccumulatedUpdatesInRawPropsAndroid();
     enableAccumulatedUpdatesInRawPropsAndroid_ = flagValue;
@@ -308,7 +326,7 @@ bool ReactNativeFeatureFlagsAccessor::enableAndroidAutoOffscreenCompositingForEl
     // be accessing the provider multiple times but the end state of this
     // instance and the returned flag value would be the same.
 
-    markFlagAsAccessed(15, "enableAndroidAutoOffscreenCompositingForElevation");
+    markFlagAsAccessed(16, "enableAndroidAutoOffscreenCompositingForElevation");
 
     flagValue = currentProvider_->enableAndroidAutoOffscreenCompositingForElevation();
     enableAndroidAutoOffscreenCompositingForElevation_ = flagValue;
@@ -326,7 +344,7 @@ bool ReactNativeFeatureFlagsAccessor::enableAndroidTextMeasurementOptimizations(
     // be accessing the provider multiple times but the end state of this
     // instance and the returned flag value would be the same.
 
-    markFlagAsAccessed(16, "enableAndroidTextMeasurementOptimizations");
+    markFlagAsAccessed(17, "enableAndroidTextMeasurementOptimizations");
 
     flagValue = currentProvider_->enableAndroidTextMeasurementOptimizations();
     enableAndroidTextMeasurementOptimizations_ = flagValue;
@@ -344,7 +362,7 @@ bool ReactNativeFeatureFlagsAccessor::enableAsyncDiskCacheCheckInMultiSourceImag
     // be accessing the provider multiple times but the end state of this
     // instance and the returned flag value would be the same.
 
-    markFlagAsAccessed(17, "enableAsyncDiskCacheCheckInMultiSourceImageAndroid");
+    markFlagAsAccessed(18, "enableAsyncDiskCacheCheckInMultiSourceImageAndroid");
 
     flagValue = currentProvider_->enableAsyncDiskCacheCheckInMultiSourceImageAndroid();
     enableAsyncDiskCacheCheckInMultiSourceImageAndroid_ = flagValue;
@@ -362,7 +380,7 @@ bool ReactNativeFeatureFlagsAccessor::enableBridgelessArchitecture() {
     // be accessing the provider multiple times but the end state of this
     // instance and the returned flag value would be the same.
 
-    markFlagAsAccessed(18, "enableBridgelessArchitecture");
+    markFlagAsAccessed(19, "enableBridgelessArchitecture");
 
     flagValue = currentProvider_->enableBridgelessArchitecture();
     enableBridgelessArchitecture_ = flagValue;
@@ -380,7 +398,7 @@ bool ReactNativeFeatureFlagsAccessor::enableCppPropsIteratorSetter() {
     // be accessing the provider multiple times but the end state of this
     // instance and the returned flag value would be the same.
 
-    markFlagAsAccessed(19, "enableCppPropsIteratorSetter");
+    markFlagAsAccessed(20, "enableCppPropsIteratorSetter");
 
     flagValue = currentProvider_->enableCppPropsIteratorSetter();
     enableCppPropsIteratorSetter_ = flagValue;
@@ -398,7 +416,7 @@ bool ReactNativeFeatureFlagsAccessor::enableCustomFocusSearchOnClippedElementsAn
     // be accessing the provider multiple times but the end state of this
     // instance and the returned flag value would be the same.
 
-    markFlagAsAccessed(20, "enableCustomFocusSearchOnClippedElementsAndroid");
+    markFlagAsAccessed(21, "enableCustomFocusSearchOnClippedElementsAndroid");
 
     flagValue = currentProvider_->enableCustomFocusSearchOnClippedElementsAndroid();
     enableCustomFocusSearchOnClippedElementsAndroid_ = flagValue;
@@ -416,7 +434,7 @@ bool ReactNativeFeatureFlagsAccessor::enableDestroyShadowTreeRevisionAsync() {
     // be accessing the provider multiple times but the end state of this
     // instance and the returned flag value would be the same.
 
-    markFlagAsAccessed(21, "enableDestroyShadowTreeRevisionAsync");
+    markFlagAsAccessed(22, "enableDestroyShadowTreeRevisionAsync");
 
     flagValue = currentProvider_->enableDestroyShadowTreeRevisionAsync();
     enableDestroyShadowTreeRevisionAsync_ = flagValue;
@@ -434,7 +452,7 @@ bool ReactNativeFeatureFlagsAccessor::enableDoubleMeasurementFixAndroid() {
     // be accessing the provider multiple times but the end state of this
     // instance and the returned flag value would be the same.
 
-    markFlagAsAccessed(22, "enableDoubleMeasurementFixAndroid");
+    markFlagAsAccessed(23, "enableDoubleMeasurementFixAndroid");
 
     flagValue = currentProvider_->enableDoubleMeasurementFixAndroid();
     enableDoubleMeasurementFixAndroid_ = flagValue;
@@ -452,7 +470,7 @@ bool ReactNativeFeatureFlagsAccessor::enableEagerRootViewAttachment() {
     // be accessing the provider multiple times but the end state of this
     // instance and the returned flag value would be the same.
 
-    markFlagAsAccessed(23, "enableEagerRootViewAttachment");
+    markFlagAsAccessed(24, "enableEagerRootViewAttachment");
 
     flagValue = currentProvider_->enableEagerRootViewAttachment();
     enableEagerRootViewAttachment_ = flagValue;
@@ -470,7 +488,7 @@ bool ReactNativeFeatureFlagsAccessor::enableExclusivePropsUpdateAndroid() {
     // be accessing the provider multiple times but the end state of this
     // instance and the returned flag value would be the same.
 
-    markFlagAsAccessed(24, "enableExclusivePropsUpdateAndroid");
+    markFlagAsAccessed(25, "enableExclusivePropsUpdateAndroid");
 
     flagValue = currentProvider_->enableExclusivePropsUpdateAndroid();
     enableExclusivePropsUpdateAndroid_ = flagValue;
@@ -488,7 +506,7 @@ bool ReactNativeFeatureFlagsAccessor::enableFabricCommitBranching() {
     // be accessing the provider multiple times but the end state of this
     // instance and the returned flag value would be the same.
 
-    markFlagAsAccessed(25, "enableFabricCommitBranching");
+    markFlagAsAccessed(26, "enableFabricCommitBranching");
 
     flagValue = currentProvider_->enableFabricCommitBranching();
     enableFabricCommitBranching_ = flagValue;
@@ -506,7 +524,7 @@ bool ReactNativeFeatureFlagsAccessor::enableFabricCommitBranchingMergeOnMainThre
     // be accessing the provider multiple times but the end state of this
     // instance and the returned flag value would be the same.
 
-    markFlagAsAccessed(26, "enableFabricCommitBranchingMergeOnMainThread");
+    markFlagAsAccessed(27, "enableFabricCommitBranchingMergeOnMainThread");
 
     flagValue = currentProvider_->enableFabricCommitBranchingMergeOnMainThread();
     enableFabricCommitBranchingMergeOnMainThread_ = flagValue;
@@ -524,7 +542,7 @@ bool ReactNativeFeatureFlagsAccessor::enableFabricLogs() {
     // be accessing the provider multiple times but the end state of this
     // instance and the returned flag value would be the same.
 
-    markFlagAsAccessed(27, "enableFabricLogs");
+    markFlagAsAccessed(28, "enableFabricLogs");
 
     flagValue = currentProvider_->enableFabricLogs();
     enableFabricLogs_ = flagValue;
@@ -542,7 +560,7 @@ bool ReactNativeFeatureFlagsAccessor::enableFlexboxAutoMinSizeInStrictMode() {
     // be accessing the provider multiple times but the end state of this
     // instance and the returned flag value would be the same.
 
-    markFlagAsAccessed(28, "enableFlexboxAutoMinSizeInStrictMode");
+    markFlagAsAccessed(29, "enableFlexboxAutoMinSizeInStrictMode");
 
     flagValue = currentProvider_->enableFlexboxAutoMinSizeInStrictMode();
     enableFlexboxAutoMinSizeInStrictMode_ = flagValue;
@@ -560,7 +578,7 @@ bool ReactNativeFeatureFlagsAccessor::enableFontScaleChangesUpdatingLayout() {
     // be accessing the provider multiple times but the end state of this
     // instance and the returned flag value would be the same.
 
-    markFlagAsAccessed(29, "enableFontScaleChangesUpdatingLayout");
+    markFlagAsAccessed(30, "enableFontScaleChangesUpdatingLayout");
 
     flagValue = currentProvider_->enableFontScaleChangesUpdatingLayout();
     enableFontScaleChangesUpdatingLayout_ = flagValue;
@@ -578,7 +596,7 @@ bool ReactNativeFeatureFlagsAccessor::enableIOSCompressedTextFrameAdjustment() {
     // be accessing the provider multiple times but the end state of this
     // instance and the returned flag value would be the same.
 
-    markFlagAsAccessed(30, "enableIOSCompressedTextFrameAdjustment");
+    markFlagAsAccessed(31, "enableIOSCompressedTextFrameAdjustment");
 
     flagValue = currentProvider_->enableIOSCompressedTextFrameAdjustment();
     enableIOSCompressedTextFrameAdjustment_ = flagValue;
@@ -596,7 +614,7 @@ bool ReactNativeFeatureFlagsAccessor::enableIOSTextBaselineOffsetPerLine() {
     // be accessing the provider multiple times but the end state of this
     // instance and the returned flag value would be the same.
 
-    markFlagAsAccessed(31, "enableIOSTextBaselineOffsetPerLine");
+    markFlagAsAccessed(32, "enableIOSTextBaselineOffsetPerLine");
 
     flagValue = currentProvider_->enableIOSTextBaselineOffsetPerLine();
     enableIOSTextBaselineOffsetPerLine_ = flagValue;
@@ -614,7 +632,7 @@ bool ReactNativeFeatureFlagsAccessor::enableIOSViewClipToPaddingBox() {
     // be accessing the provider multiple times but the end state of this
     // instance and the returned flag value would be the same.
 
-    markFlagAsAccessed(32, "enableIOSViewClipToPaddingBox");
+    markFlagAsAccessed(33, "enableIOSViewClipToPaddingBox");
 
     flagValue = currentProvider_->enableIOSViewClipToPaddingBox();
     enableIOSViewClipToPaddingBox_ = flagValue;
@@ -632,7 +650,7 @@ bool ReactNativeFeatureFlagsAccessor::enableImagePrefetchingAndroid() {
     // be accessing the provider multiple times but the end state of this
     // instance and the returned flag value would be the same.
 
-    markFlagAsAccessed(33, "enableImagePrefetchingAndroid");
+    markFlagAsAccessed(34, "enableImagePrefetchingAndroid");
 
     flagValue = currentProvider_->enableImagePrefetchingAndroid();
     enableImagePrefetchingAndroid_ = flagValue;
@@ -650,7 +668,7 @@ bool ReactNativeFeatureFlagsAccessor::enableImageTransparentTintColor() {
     // be accessing the provider multiple times but the end state of this
     // instance and the returned flag value would be the same.
 
-    markFlagAsAccessed(34, "enableImageTransparentTintColor");
+    markFlagAsAccessed(35, "enableImageTransparentTintColor");
 
     flagValue = currentProvider_->enableImageTransparentTintColor();
     enableImageTransparentTintColor_ = flagValue;
@@ -668,7 +686,7 @@ bool ReactNativeFeatureFlagsAccessor::enableImmediateUpdateModeForContentOffsetC
     // be accessing the provider multiple times but the end state of this
     // instance and the returned flag value would be the same.
 
-    markFlagAsAccessed(35, "enableImmediateUpdateModeForContentOffsetChanges");
+    markFlagAsAccessed(36, "enableImmediateUpdateModeForContentOffsetChanges");
 
     flagValue = currentProvider_->enableImmediateUpdateModeForContentOffsetChanges();
     enableImmediateUpdateModeForContentOffsetChanges_ = flagValue;
@@ -686,7 +704,7 @@ bool ReactNativeFeatureFlagsAccessor::enableImperativeEvents() {
     // be accessing the provider multiple times but the end state of this
     // instance and the returned flag value would be the same.
 
-    markFlagAsAccessed(36, "enableImperativeEvents");
+    markFlagAsAccessed(37, "enableImperativeEvents");
 
     flagValue = currentProvider_->enableImperativeEvents();
     enableImperativeEvents_ = flagValue;
@@ -704,7 +722,7 @@ bool ReactNativeFeatureFlagsAccessor::enableImperativeFocus() {
     // be accessing the provider multiple times but the end state of this
     // instance and the returned flag value would be the same.
 
-    markFlagAsAccessed(37, "enableImperativeFocus");
+    markFlagAsAccessed(38, "enableImperativeFocus");
 
     flagValue = currentProvider_->enableImperativeFocus();
     enableImperativeFocus_ = flagValue;
@@ -722,7 +740,7 @@ bool ReactNativeFeatureFlagsAccessor::enableInteropViewManagerClassLookUpOptimiz
     // be accessing the provider multiple times but the end state of this
     // instance and the returned flag value would be the same.
 
-    markFlagAsAccessed(38, "enableInteropViewManagerClassLookUpOptimizationIOS");
+    markFlagAsAccessed(39, "enableInteropViewManagerClassLookUpOptimizationIOS");
 
     flagValue = currentProvider_->enableInteropViewManagerClassLookUpOptimizationIOS();
     enableInteropViewManagerClassLookUpOptimizationIOS_ = flagValue;
@@ -740,7 +758,7 @@ bool ReactNativeFeatureFlagsAccessor::enableIntersectionObserverByDefault() {
     // be accessing the provider multiple times but the end state of this
     // instance and the returned flag value would be the same.
 
-    markFlagAsAccessed(39, "enableIntersectionObserverByDefault");
+    markFlagAsAccessed(40, "enableIntersectionObserverByDefault");
 
     flagValue = currentProvider_->enableIntersectionObserverByDefault();
     enableIntersectionObserverByDefault_ = flagValue;
@@ -758,7 +776,7 @@ bool ReactNativeFeatureFlagsAccessor::enableKeyEvents() {
     // be accessing the provider multiple times but the end state of this
     // instance and the returned flag value would be the same.
 
-    markFlagAsAccessed(40, "enableKeyEvents");
+    markFlagAsAccessed(41, "enableKeyEvents");
 
     flagValue = currentProvider_->enableKeyEvents();
     enableKeyEvents_ = flagValue;
@@ -776,7 +794,7 @@ bool ReactNativeFeatureFlagsAccessor::enableLayoutAnimationsOnAndroid() {
     // be accessing the provider multiple times but the end state of this
     // instance and the returned flag value would be the same.
 
-    markFlagAsAccessed(41, "enableLayoutAnimationsOnAndroid");
+    markFlagAsAccessed(42, "enableLayoutAnimationsOnAndroid");
 
     flagValue = currentProvider_->enableLayoutAnimationsOnAndroid();
     enableLayoutAnimationsOnAndroid_ = flagValue;
@@ -794,7 +812,7 @@ bool ReactNativeFeatureFlagsAccessor::enableLayoutAnimationsOnIOS() {
     // be accessing the provider multiple times but the end state of this
     // instance and the returned flag value would be the same.
 
-    markFlagAsAccessed(42, "enableLayoutAnimationsOnIOS");
+    markFlagAsAccessed(43, "enableLayoutAnimationsOnIOS");
 
     flagValue = currentProvider_->enableLayoutAnimationsOnIOS();
     enableLayoutAnimationsOnIOS_ = flagValue;
@@ -812,7 +830,7 @@ bool ReactNativeFeatureFlagsAccessor::enableModuleArgumentNSNullConversionIOS()
     // be accessing the provider multiple times but the end state of this
     // instance and the returned flag value would be the same.
 
-    markFlagAsAccessed(43, "enableModuleArgumentNSNullConversionIOS");
+    markFlagAsAccessed(44, "enableModuleArgumentNSNullConversionIOS");
 
     flagValue = currentProvider_->enableModuleArgumentNSNullConversionIOS();
     enableModuleArgumentNSNullConversionIOS_ = flagValue;
@@ -830,7 +848,7 @@ bool ReactNativeFeatureFlagsAccessor::enableMountingCoordinatorPullModelAndroid(
     // be accessing the provider multiple times but the end state of this
     // instance and the returned flag value would be the same.
 
-    markFlagAsAccessed(44, "enableMountingCoordinatorPullModelAndroid");
+    markFlagAsAccessed(45, "enableMountingCoordinatorPullModelAndroid");
 
     flagValue = currentProvider_->enableMountingCoordinatorPullModelAndroid();
     enableMountingCoordinatorPullModelAndroid_ = flagValue;
@@ -848,7 +866,7 @@ bool ReactNativeFeatureFlagsAccessor::enableMutationObserverByDefault() {
     // be accessing the provider multiple times but the end state of this
     // instance and the returned flag value would be the same.
 
-    markFlagAsAccessed(45, "enableMutationObserverByDefault");
+    markFlagAsAccessed(46, "enableMutationObserverByDefault");
 
     flagValue = currentProvider_->enableMutationObserverByDefault();
     enableMutationObserverByDefault_ = flagValue;
@@ -866,7 +884,7 @@ bool ReactNativeFeatureFlagsAccessor::enableNativeCSSParsing() {
     // be accessing the provider multiple times but the end state of this
     // instance and the returned flag value would be the same.
 
-    markFlagAsAccessed(46, "enableNativeCSSParsing");
+    markFlagAsAccessed(47, "enableNativeCSSParsing");
 
     flagValue = currentProvider_->enableNativeCSSParsing();
     enableNativeCSSParsing_ = flagValue;
@@ -884,7 +902,7 @@ bool ReactNativeFeatureFlagsAccessor::enablePreallocatedPropsDiffOnInsertAndroid
     // be accessing the provider multiple times but the end state of this
     // instance and the returned flag value would be the same.
 
-    markFlagAsAccessed(47, "enablePreallocatedPropsDiffOnInsertAndroid");
+    markFlagAsAccessed(48, "enablePreallocatedPropsDiffOnInsertAndroid");
 
     flagValue = currentProvider_->enablePreallocatedPropsDiffOnInsertAndroid();
     enablePreallocatedPropsDiffOnInsertAndroid_ = flagValue;
@@ -902,7 +920,7 @@ bool ReactNativeFeatureFlagsAccessor::enablePreparedTextLayout() {
     // be accessing the provider multiple times but the end state of this
     // instance and the returned flag value would be the same.
 
-    markFlagAsAccessed(48, "enablePreparedTextLayout");
+    markFlagAsAccessed(49, "enablePreparedTextLayout");
 
     flagValue = currentProvider_->enablePreparedTextLayout();
     enablePreparedTextLayout_ = flagValue;
@@ -920,7 +938,7 @@ bool ReactNativeFeatureFlagsAccessor::enablePropsUpdateReconciliationAndroid() {
     // be accessing the provider multiple times but the end state of this
     // instance and the returned flag value would be the same.
 
-    markFlagAsAccessed(49, "enablePropsUpdateReconciliationAndroid");
+    markFlagAsAccessed(50, "enablePropsUpdateReconciliationAndroid");
 
     flagValue = currentProvider_->enablePropsUpdateReconciliationAndroid();
     enablePropsUpdateReconciliationAndroid_ = flagValue;
@@ -938,7 +956,7 @@ bool ReactNativeFeatureFlagsAccessor::enableResizeObserverByDefault() {
     // be accessing the provider multiple times but the end state of this
     // instance and the returned flag value would be the same.
 
-    markFlagAsAccessed(50, "enableResizeObserverByDefault");
+    markFlagAsAccessed(51, "enableResizeObserverByDefault");
 
     flagValue = currentProvider_->enableResizeObserverByDefault();
     enableResizeObserverByDefault_ = flagValue;
@@ -956,7 +974,7 @@ bool ReactNativeFeatureFlagsAccessor::enableSwiftUIBasedFilters() {
     // be accessing the provider multiple times but the end state of this
     // instance and the returned flag value would be the same.
 
-    markFlagAsAccessed(51, "enableSwiftUIBasedFilters");
+    markFlagAsAccessed(52, "enableSwiftUIBasedFilters");
 
     flagValue = currentProvider_->enableSwiftUIBasedFilters();
     enableSwiftUIBasedFilters_ = flagValue;
@@ -974,7 +992,7 @@ bool ReactNativeFeatureFlagsAccessor::enableViewCulling() {
     // be accessing the provider multiple times but the end state of this
     // instance and the returned flag value would be the same.
 
-    markFlagAsAccessed(52, "enableViewCulling");
+    markFlagAsAccessed(53, "enableViewCulling");
 
     flagValue = currentProvider_->enableViewCulling();
     enableViewCulling_ = flagValue;
@@ -992,7 +1010,7 @@ bool ReactNativeFeatureFlagsAccessor::enableViewRecycling() {
     // be accessing the provider multiple times but the end state of this
     // instance and the returned flag value would be the same.
 
-    markFlagAsAccessed(53, "enableViewRecycling");
+    markFlagAsAccessed(54, "enableViewRecycling");
 
     flagValue = currentProvider_->enableViewRecycling();
     enableViewRecycling_ = flagValue;
@@ -1010,7 +1028,7 @@ bool ReactNativeFeatureFlagsAccessor::enableViewRecyclingForImage() {
     // be accessing the provider multiple times but the end state of this
     // instance and the returned flag value would be the same.
 
-    markFlagAsAccessed(54, "enableViewRecyclingForImage");
+    markFlagAsAccessed(55, "enableViewRecyclingForImage");
 
     flagValue = currentProvider_->enableViewRecyclingForImage();
     enableViewRecyclingForImage_ = flagValue;
@@ -1028,7 +1046,7 @@ bool ReactNativeFeatureFlagsAccessor::enableViewRecyclingForScrollView() {
     // be accessing the provider multiple times but the end state of this
     // instance and the returned flag value would be the same.
 
-    markFlagAsAccessed(55, "enableViewRecyclingForScrollView");
+    markFlagAsAccessed(56, "enableViewRecyclingForScrollView");
 
     flagValue = currentProvider_->enableViewRecyclingForScrollView();
     enableViewRecyclingForScrollView_ = flagValue;
@@ -1046,7 +1064,7 @@ bool ReactNativeFeatureFlagsAccessor::enableViewRecyclingForText() {
     // be accessing the provider multiple times but the end state of this
     // instance and the returned flag value would be the same.
 
-    markFlagAsAccessed(56, "enableViewRecyclingForText");
+    markFlagAsAccessed(57, "enableViewRecyclingForText");
 
     flagValue = currentProvider_->enableViewRecyclingForText();
     enableViewRecyclingForText_ = flagValue;
@@ -1064,7 +1082,7 @@ bool ReactNativeFeatureFlagsAccessor::enableViewRecyclingForView() {
     // be accessing the provider multiple times but the end state of this
     // instance and the returned flag value would be the same.
 
-    markFlagAsAccessed(57, "enableViewRecyclingForView");
+    markFlagAsAccessed(58, "enableViewRecyclingForView");
 
     flagValue = currentProvider_->enableViewRecyclingForView();
     enableViewRecyclingForView_ = flagValue;
@@ -1082,7 +1100,7 @@ bool ReactNativeFeatureFlagsAccessor::enableVirtualViewContainerStateExperimenta
     // be accessing the provider multiple times but the end state of this
     // instance and the returned flag value would be the same.
 
-    markFlagAsAccessed(58, "enableVirtualViewContainerStateExperimental");
+    markFlagAsAccessed(59, "enableVirtualViewContainerStateExperimental");
 
     flagValue = currentProvider_->enableVirtualViewContainerStateExperimental();
     enableVirtualViewContainerStateExperimental_ = flagValue;
@@ -1100,7 +1118,7 @@ bool ReactNativeFeatureFlagsAccessor::fixBorderlessRippleAndroid() {
     // be accessing the provider multiple times but the end state of this
     // instance and the returned flag value would be the same.
 
-    markFlagAsAccessed(59, "fixBorderlessRippleAndroid");
+    markFlagAsAccessed(60, "fixBorderlessRippleAndroid");
 
     flagValue = currentProvider_->fixBorderlessRippleAndroid();
     fixBorderlessRippleAndroid_ = flagValue;
@@ -1118,7 +1136,7 @@ bool ReactNativeFeatureFlagsAccessor::fixMappingOfEventPrioritiesBetweenFabricAn
     // be accessing the provider multiple times but the end state of this
     // instance and the returned flag value would be the same.
 
-    markFlagAsAccessed(60, "fixMappingOfEventPrioritiesBetweenFabricAndReact");
+    markFlagAsAccessed(61, "fixMappingOfEventPrioritiesBetweenFabricAndReact");
 
     flagValue = currentProvider_->fixMappingOfEventPrioritiesBetweenFabricAndReact();
     fixMappingOfEventPrioritiesBetweenFabricAndReact_ = flagValue;
@@ -1136,7 +1154,7 @@ bool ReactNativeFeatureFlagsAccessor::fixTextLayoutOnPixelDensityChange() {
     // be accessing the provider multiple times but the end state of this
     // instance and the returned flag value would be the same.
 
-    markFlagAsAccessed(61, "fixTextLayoutOnPixelDensityChange");
+    markFlagAsAccessed(62, "fixTextLayoutOnPixelDensityChange");
 
     flagValue = currentProvider_->fixTextLayoutOnPixelDensityChange();
     fixTextLayoutOnPixelDensityChange_ = flagValue;
@@ -1154,7 +1172,7 @@ bool ReactNativeFeatureFlagsAccessor::fixYogaFlexBasisFitContentInMainAxis() {
     // be accessing the provider multiple times but the end state of this
     // instance and the returned flag value would be the same.
 
-    markFlagAsAccessed(62, "fixYogaFlexBasisFitContentInMainAxis");
+    markFlagAsAccessed(63, "fixYogaFlexBasisFitContentInMainAxis");
 
     flagValue = currentProvider_->fixYogaFlexBasisFitContentInMainAxis();
     fixYogaFlexBasisFitContentInMainAxis_ = flagValue;
@@ -1172,7 +1190,7 @@ bool ReactNativeFeatureFlagsAccessor::fuseboxAssertSingleHostState() {
     // be accessing the provider multiple times but the end state of this
     // instance and the returned flag value would be the same.
 
-    markFlagAsAccessed(63, "fuseboxAssertSingleHostState");
+    markFlagAsAccessed(64, "fuseboxAssertSingleHostState");
 
     flagValue = currentProvider_->fuseboxAssertSingleHostState();
     fuseboxAssertSingleHostState_ = flagValue;
@@ -1190,7 +1208,7 @@ bool ReactNativeFeatureFlagsAccessor::fuseboxEnabledRelease() {
     // be accessing the provider multiple times but the end state of this
     // instance and the returned flag value would be the same.
 
-    markFlagAsAccessed(64, "fuseboxEnabledRelease");
+    markFlagAsAccessed(65, "fuseboxEnabledRelease");
 
     flagValue = currentProvider_->fuseboxEnabledRelease();
     fuseboxEnabledRelease_ = flagValue;
@@ -1208,7 +1226,7 @@ bool ReactNativeFeatureFlagsAccessor::fuseboxFrameRecordingEnabled() {
     // be accessing the provider multiple times but the end state of this
     // instance and the returned flag value would be the same.
 
-    markFlagAsAccessed(65, "fuseboxFrameRecordingEnabled");
+    markFlagAsAccessed(66, "fuseboxFrameRecordingEnabled");
 
     flagValue = currentProvider_->fuseboxFrameRecordingEnabled();
     fuseboxFrameRecordingEnabled_ = flagValue;
@@ -1226,7 +1244,7 @@ bool ReactNativeFeatureFlagsAccessor::fuseboxScreenshotCaptureEnabled() {
     // be accessing the provider multiple times but the end state of this
     // instance and the returned flag value would be the same.
 
-    markFlagAsAccessed(66, "fuseboxScreenshotCaptureEnabled");
+    markFlagAsAccessed(67, "fuseboxScreenshotCaptureEnabled");
 
     flagValue = currentProvider_->fuseboxScreenshotCaptureEnabled();
     fuseboxScreenshotCaptureEnabled_ = flagValue;
@@ -1244,7 +1262,7 @@ bool ReactNativeFeatureFlagsAccessor::fuseboxWebSocketEventsEnabled() {
     // be accessing the provider multiple times but the end state of this
     // instance and the returned flag value would be the same.
 
-    markFlagAsAccessed(67, "fuseboxWebSocketEventsEnabled");
+    markFlagAsAccessed(68, "fuseboxWebSocketEventsEnabled");
 
     flagValue = currentProvider_->fuseboxWebSocketEventsEnabled();
     fuseboxWebSocketEventsEnabled_ = flagValue;
@@ -1262,7 +1280,7 @@ bool ReactNativeFeatureFlagsAccessor::optimizedAnimatedPropUpdates() {
     // be accessing the provider multiple times but the end state of this
     // instance and the returned flag value would be the same.
 
-    markFlagAsAccessed(68, "optimizedAnimatedPropUpdates");
+    markFlagAsAccessed(69, "optimizedAnimatedPropUpdates");
 
     flagValue = currentProvider_->optimizedAnimatedPropUpdates();
     optimizedAnimatedPropUpdates_ = flagValue;
@@ -1280,7 +1298,7 @@ bool ReactNativeFeatureFlagsAccessor::overrideBySynchronousMountPropsAtMountingA
     // be accessing the provider multiple times but the end state of this
     // instance and the returned flag value would be the same.
 
-    markFlagAsAccessed(69, "overrideBySynchronousMountPropsAtMountingAndroid");
+    markFlagAsAccessed(70, "overrideBySynchronousMountPropsAtMountingAndroid");
 
     flagValue = currentProvider_->overrideBySynchronousMountPropsAtMountingAndroid();
     overrideBySynchronousMountPropsAtMountingAndroid_ = flagValue;
@@ -1298,7 +1316,7 @@ bool ReactNativeFeatureFlagsAccessor::perfIssuesEnabled() {
     // be accessing the provider multiple times but the end state of this
     // instance and the returned flag value would be the same.
 
-    markFlagAsAccessed(70, "perfIssuesEnabled");
+    markFlagAsAccessed(71, "perfIssuesEnabled");
 
     flagValue = currentProvider_->perfIssuesEnabled();
     perfIssuesEnabled_ = flagValue;
@@ -1316,7 +1334,7 @@ bool ReactNativeFeatureFlagsAccessor::perfMonitorV2Enabled() {
     // be accessing the provider multiple times but the end state of this
     // instance and the returned flag value would be the same.
 
-    markFlagAsAccessed(71, "perfMonitorV2Enabled");
+    markFlagAsAccessed(72, "perfMonitorV2Enabled");
 
     flagValue = currentProvider_->perfMonitorV2Enabled();
     perfMonitorV2Enabled_ = flagValue;
@@ -1334,7 +1352,7 @@ double ReactNativeFeatureFlagsAccessor::preparedTextCacheSize() {
     // be accessing the provider multiple times but the end state of this
     // instance and the returned flag value would be the same.
 
-    markFlagAsAccessed(72, "preparedTextCacheSize");
+    markFlagAsAccessed(73, "preparedTextCacheSize");
 
     flagValue = currentProvider_->preparedTextCacheSize();
     preparedTextCacheSize_ = flagValue;
@@ -1352,7 +1370,7 @@ bool ReactNativeFeatureFlagsAccessor::preventShadowTreeCommitExhaustion() {
     // be accessing the provider multiple times but the end state of this
     // instance and the returned flag value would be the same.
 
-    markFlagAsAccessed(73, "preventShadowTreeCommitExhaustion");
+    markFlagAsAccessed(74, "preventShadowTreeCommitExhaustion");
 
     flagValue = currentProvider_->preventShadowTreeCommitExhaustion();
     preventShadowTreeCommitExhaustion_ = flagValue;
@@ -1370,7 +1388,7 @@ bool ReactNativeFeatureFlagsAccessor::redBoxV2Android() {
     // be accessing the provider multiple times but the end state of this
     // instance and the returned flag value would be the same.
 
-    markFlagAsAccessed(74, "redBoxV2Android");
+    markFlagAsAccessed(75, "redBoxV2Android");
 
     flagValue = currentProvider_->redBoxV2Android();
     redBoxV2Android_ = flagValue;
@@ -1388,7 +1406,7 @@ bool ReactNativeFeatureFlagsAccessor::redBoxV2IOS() {
     // be accessing the provider multiple times but the end state of this
     // instance and the returned flag value would be the same.
 
-    markFlagAsAccessed(75, "redBoxV2IOS");
+    markFlagAsAccessed(76, "redBoxV2IOS");
 
     flagValue = currentProvider_->redBoxV2IOS();
     redBoxV2IOS_ = flagValue;
@@ -1406,7 +1424,7 @@ bool ReactNativeFeatureFlagsAccessor::shouldPressibilityUseW3CPointerEventsForHo
     // be accessing the provider multiple times but the end state of this
     // instance and the returned flag value would be the same.
 
-    markFlagAsAccessed(76, "shouldPressibilityUseW3CPointerEventsForHover");
+    markFlagAsAccessed(77, "shouldPressibilityUseW3CPointerEventsForHover");
 
     flagValue = currentProvider_->shouldPressibilityUseW3CPointerEventsForHover();
     shouldPressibilityUseW3CPointerEventsForHover_ = flagValue;
@@ -1424,7 +1442,7 @@ bool ReactNativeFeatureFlagsAccessor::shouldTriggerResponderTransferOnScrollAndr
     // be accessing the provider multiple times but the end state of this
     // instance and the returned flag value would be the same.
 
-    markFlagAsAccessed(77, "shouldTriggerResponderTransferOnScrollAndroid");
+    markFlagAsAccessed(78, "shouldTriggerResponderTransferOnScrollAndroid");
 
     flagValue = currentProvider_->shouldTriggerResponderTransferOnScrollAndroid();
     shouldTriggerResponderTransferOnScrollAndroid_ = flagValue;
@@ -1442,7 +1460,7 @@ bool ReactNativeFeatureFlagsAccessor::skipActivityIdentityAssertionOnHostPause()
     // be accessing the provider multiple times but the end state of this
     // instance and the returned flag value would be the same.
 
-    markFlagAsAccessed(78, "skipActivityIdentityAssertionOnHostPause");
+    markFlagAsAccessed(79, "skipActivityIdentityAssertionOnHostPause");
 
     flagValue = currentProvider_->skipActivityIdentityAssertionOnHostPause();
     skipActivityIdentityAssertionOnHostPause_ = flagValue;
@@ -1460,7 +1478,7 @@ bool ReactNativeFeatureFlagsAccessor::skipUnchangedChildrenInDifferentiator() {
     // be accessing the provider multiple times but the end state of this
     // instance and the returned flag value would be the same.
 
-    markFlagAsAccessed(79, "skipUnchangedChildrenInDifferentiator");
+    markFlagAsAccessed(80, "skipUnchangedChildrenInDifferentiator");
 
     flagValue = currentProvider_->skipUnchangedChildrenInDifferentiator();
     skipUnchangedChildrenInDifferentiator_ = flagValue;
@@ -1478,7 +1496,7 @@ bool ReactNativeFeatureFlagsAccessor::syncAndroidClipBoundsWithOverflow() {
     // be accessing the provider multiple times but the end state of this
     // instance and the returned flag value would be the same.
 
-    markFlagAsAccessed(80, "syncAndroidClipBoundsWithOverflow");
+    markFlagAsAccessed(81, "syncAndroidClipBoundsWithOverflow");
 
     flagValue = currentProvider_->syncAndroidClipBoundsWithOverflow();
     syncAndroidClipBoundsWithOverflow_ = flagValue;
@@ -1496,7 +1514,7 @@ bool ReactNativeFeatureFlagsAccessor::traceTurboModulePromiseRejectionsOnAndroid
     // be accessing the provider multiple times but the end state of this
     // instance and the returned flag value would be the same.
 
-    markFlagAsAccessed(81, "traceTurboModulePromiseRejectionsOnAndroid");
+    markFlagAsAccessed(82, "traceTurboModulePromiseRejectionsOnAndroid");
 
     flagValue = currentProvider_->traceTurboModulePromiseRejectionsOnAndroid();
     traceTurboModulePromiseRejectionsOnAndroid_ = flagValue;
@@ -1514,7 +1532,7 @@ bool ReactNativeFeatureFlagsAccessor::updateRuntimeShadowNodeReferencesOnCommit(
     // be accessing the provider multiple times but the end state of this
     // instance and the returned flag value would be the same.
 
-    markFlagAsAccessed(82, "updateRuntimeShadowNodeReferencesOnCommit");
+    markFlagAsAccessed(83, "updateRuntimeShadowNodeReferencesOnCommit");
 
     flagValue = currentProvider_->updateRuntimeShadowNodeReferencesOnCommit();
     updateRuntimeShadowNodeReferencesOnCommit_ = flagValue;
@@ -1532,7 +1550,7 @@ bool ReactNativeFeatureFlagsAccessor::updateRuntimeShadowNodeReferencesOnCommitT
     // be accessing the provider multiple times but the end state of this
     // instance and the returned flag value would be the same.
 
-    markFlagAsAccessed(83, "updateRuntimeShadowNodeReferencesOnCommitThread");
+    markFlagAsAccessed(84, "updateRuntimeShadowNodeReferencesOnCommitThread");
 
     flagValue = currentProvider_->updateRuntimeShadowNodeReferencesOnCommitThread();
     updateRuntimeShadowNodeReferencesOnCommitThread_ = flagValue;
@@ -1550,7 +1568,7 @@ bool ReactNativeFeatureFlagsAccessor::useAlwaysAvailableJSErrorHandling() {
     // be accessing the provider multiple times but the end state of this
     // instance and the returned flag value would be the same.
 
-    markFlagAsAccessed(84, "useAlwaysAvailableJSErrorHandling");
+    markFlagAsAccessed(85, "useAlwaysAvailableJSErrorHandling");
 
     flagValue = currentProvider_->useAlwaysAvailableJSErrorHandling();
     useAlwaysAvailableJSErrorHandling_ = flagValue;
@@ -1568,7 +1586,7 @@ bool ReactNativeFeatureFlagsAccessor::useFabricInterop() {
     // be accessing the provider multiple times but the end state of this
     // instance and the returned flag value would be the same.
 
-    markFlagAsAccessed(85, "useFabricInterop");
+    markFlagAsAccessed(86, "useFabricInterop");
 
     flagValue = currentProvider_->useFabricInterop();
     useFabricInterop_ = flagValue;
@@ -1586,7 +1604,7 @@ bool ReactNativeFeatureFlagsAccessor::useNativeViewConfigsInBridgelessMode() {
     // be accessing the provider multiple times but the end state of this
     // instance and the returned flag value would be the same.
 
-    markFlagAsAccessed(86, "useNativeViewConfigsInBridgelessMode");
+    markFlagAsAccessed(87, "useNativeViewConfigsInBridgelessMode");
 
     flagValue = currentProvider_->useNativeViewConfigsInBridgelessMode();
     useNativeViewConfigsInBridgelessMode_ = flagValue;
@@ -1604,7 +1622,7 @@ bool ReactNativeFeatureFlagsAccessor::useNestedScrollViewAndroid() {
     // be accessing the provider multiple times but the end state of this
     // instance and the returned flag value would be the same.
 
-    markFlagAsAccessed(87, "useNestedScrollViewAndroid");
+    markFlagAsAccessed(88, "useNestedScrollViewAndroid");
 
     flagValue = currentProvider_->useNestedScrollViewAndroid();
     useNestedScrollViewAndroid_ = flagValue;
@@ -1622,7 +1640,7 @@ bool ReactNativeFeatureFlagsAccessor::useSharedAnimatedBackend() {
     // be accessing the provider multiple times but the end state of this
     // instance and the returned flag value would be the same.
 
-    markFlagAsAccessed(88, "useSharedAnimatedBackend");
+    markFlagAsAccessed(89, "useSharedAnimatedBackend");
 
     flagValue = currentProvider_->useSharedAnimatedBackend();
     useSharedAnimatedBackend_ = flagValue;
@@ -1640,7 +1658,7 @@ bool ReactNativeFeatureFlagsAccessor::useTraitHiddenOnAndroid() {
     // be accessing the provider multiple times but the end state of this
     // instance and the returned flag value would be the same.
 
-    markFlagAsAccessed(89, "useTraitHiddenOnAndroid");
+    markFlagAsAccessed(90, "useTraitHiddenOnAndroid");
 
     flagValue = currentProvider_->useTraitHiddenOnAndroid();
     useTraitHiddenOnAndroid_ = flagValue;
@@ -1658,7 +1676,7 @@ bool ReactNativeFeatureFlagsAccessor::useTurboModuleInterop() {
     // be accessing the provider multiple times but the end state of this
     // instance and the returned flag value would be the same.
 
-    markFlagAsAccessed(90, "useTurboModuleInterop");
+    markFlagAsAccessed(91, "useTurboModuleInterop");
 
     flagValue = currentProvider_->useTurboModuleInterop();
     useTurboModuleInterop_ = flagValue;
@@ -1676,7 +1694,7 @@ bool ReactNativeFeatureFlagsAccessor::useWindowDensityForDisplayMetricsAndroid()
     // be accessing the provider multiple times but the end state of this
     // instance and the returned flag value would be the same.
 
-    markFlagAsAccessed(91, "useWindowDensityForDisplayMetricsAndroid");
+    markFlagAsAccessed(92, "useWindowDensityForDisplayMetricsAndroid");
 
     flagValue = currentProvider_->useWindowDensityForDisplayMetricsAndroid();
     useWindowDensityForDisplayMetricsAndroid_ = flagValue;
@@ -1694,7 +1712,7 @@ double ReactNativeFeatureFlagsAccessor::viewCullingOutsetRatio() {
     // be accessing the provider multiple times but the end state of this
     // instance and the returned flag value would be the same.
 
-    markFlagAsAccessed(92, "viewCullingOutsetRatio");
+    markFlagAsAccessed(93, "viewCullingOutsetRatio");
 
     flagValue = currentProvider_->viewCullingOutsetRatio();
     viewCullingOutsetRatio_ = flagValue;
@@ -1712,7 +1730,7 @@ bool ReactNativeFeatureFlagsAccessor::viewTransitionEnabled() {
     // be accessing the provider multiple times but the end state of this
     // instance and the returned flag value would be the same.
 
-    markFlagAsAccessed(93, "viewTransitionEnabled");
+    markFlagAsAccessed(94, "viewTransitionEnabled");
 
     flagValue = currentProvider_->viewTransitionEnabled();
     viewTransitionEnabled_ = flagValue;
@@ -1730,7 +1748,7 @@ bool ReactNativeFeatureFlagsAccessor::viewTransitionUseHardwareBitmapAndroid() {
     // be accessing the provider multiple times but the end state of this
     // instance and the returned flag value would be the same.
 
-    markFlagAsAccessed(94, "viewTransitionUseHardwareBitmapAndroid");
+    markFlagAsAccessed(95, "viewTransitionUseHardwareBitmapAndroid");
 
     flagValue = currentProvider_->viewTransitionUseHardwareBitmapAndroid();
     viewTransitionUseHardwareBitmapAndroid_ = flagValue;
@@ -1748,7 +1766,7 @@ double ReactNativeFeatureFlagsAccessor::virtualViewPrerenderRatio() {
     // be accessing the provider multiple times but the end state of this
     // instance and the returned flag value would be the same.
 
-    markFlagAsAccessed(95, "virtualViewPrerenderRatio");
+    markFlagAsAccessed(96, "virtualViewPrerenderRatio");
 
     flagValue = currentProvider_->virtualViewPrerenderRatio();
     virtualViewPrerenderRatio_ = flagValue;
diff --git a/packages/react-native/ReactCommon/react/featureflags/ReactNativeFeatureFlagsAccessor.h b/packages/react-native/ReactCommon/react/featureflags/ReactNativeFeatureFlagsAccessor.h
index a6ba9a46d70f..51e7ab07dffa 100644
--- a/packages/react-native/ReactCommon/react/featureflags/ReactNativeFeatureFlagsAccessor.h
+++ b/packages/react-native/ReactCommon/react/featureflags/ReactNativeFeatureFlagsAccessor.h
@@ -4,7 +4,7 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- * @generated SignedSource<<0b7f6d7766d1e038b3909bb7ea634f83>>
+ * @generated SignedSource<<68c87b23f3fc063f401c060199045b8c>>
  */
 
 /**
@@ -39,6 +39,7 @@ class ReactNativeFeatureFlagsAccessor {
   bool cxxNativeAnimatedEnabled();
   bool defaultTextToOverflowHidden();
   bool deferTextInputTruncationIOS();
+  bool deferYogaChildCloningUntilLayout();
   bool disableEarlyViewCommandExecution();
   bool disableIdleEventDispatchFrameCallbackRearmAndroid();
   bool disableIdleMountItemFrameCallbackRearmAndroid();
@@ -141,13 +142,14 @@ class ReactNativeFeatureFlagsAccessor {
   std::unique_ptr<ReactNativeFeatureFlagsProvider> currentProvider_;
   bool wasOverridden_;
 
-  std::array<std::atomic<const char*>, 96> accessedFeatureFlags_;
+  std::array<std::atomic<const char*>, 97> accessedFeatureFlags_;
 
   std::atomic<std::optional<bool>> commonTestFlag_;
   std::atomic<std::optional<bool>> cdpInteractionMetricsEnabled_;
   std::atomic<std::optional<bool>> cxxNativeAnimatedEnabled_;
   std::atomic<std::optional<bool>> defaultTextToOverflowHidden_;
   std::atomic<std::optional<bool>> deferTextInputTruncationIOS_;
+  std::atomic<std::optional<bool>> deferYogaChildCloningUntilLayout_;
   std::atomic<std::optional<bool>> disableEarlyViewCommandExecution_;
   std::atomic<std::optional<bool>> disableIdleEventDispatchFrameCallbackRearmAndroid_;
   std::atomic<std::optional<bool>> disableIdleMountItemFrameCallbackRearmAndroid_;
diff --git a/packages/react-native/ReactCommon/react/featureflags/ReactNativeFeatureFlagsDefaults.h b/packages/react-native/ReactCommon/react/featureflags/ReactNativeFeatureFlagsDefaults.h
index 76bb504681e3..0a73c9edb177 100644
--- a/packages/react-native/ReactCommon/react/featureflags/ReactNativeFeatureFlagsDefaults.h
+++ b/packages/react-native/ReactCommon/react/featureflags/ReactNativeFeatureFlagsDefaults.h
@@ -4,7 +4,7 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- * @generated SignedSource<<46e48274f8b27b9c6136b13048682252>>
+ * @generated SignedSource<<8c6dbc4687f193fd2aaa537eed281ab9>>
  */
 
 /**
@@ -49,6 +49,10 @@ class ReactNativeFeatureFlagsDefaults : public ReactNativeFeatureFlagsProvider {
     return false;
   }
 
+  bool deferYogaChildCloningUntilLayout() override {
+    return false;
+  }
+
   bool disableEarlyViewCommandExecution() override {
     return false;
   }
diff --git a/packages/react-native/ReactCommon/react/featureflags/ReactNativeFeatureFlagsDynamicProvider.h b/packages/react-native/ReactCommon/react/featureflags/ReactNativeFeatureFlagsDynamicProvider.h
index bda4465a9160..52811ef2238e 100644
--- a/packages/react-native/ReactCommon/react/featureflags/ReactNativeFeatureFlagsDynamicProvider.h
+++ b/packages/react-native/ReactCommon/react/featureflags/ReactNativeFeatureFlagsDynamicProvider.h
@@ -4,7 +4,7 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- * @generated SignedSource<<ec15d61f2d6f06c6ec5998f8524de016>>
+ * @generated SignedSource<<8055b18812c46f782673688416ee1625>>
  */
 
 /**
@@ -92,6 +92,15 @@ class ReactNativeFeatureFlagsDynamicProvider : public ReactNativeFeatureFlagsDef
     return ReactNativeFeatureFlagsDefaults::deferTextInputTruncationIOS();
   }
 
+  bool deferYogaChildCloningUntilLayout() override {
+    auto value = values_["deferYogaChildCloningUntilLayout"];
+    if (!value.isNull()) {
+      return value.getBool();
+    }
+
+    return ReactNativeFeatureFlagsDefaults::deferYogaChildCloningUntilLayout();
+  }
+
   bool disableEarlyViewCommandExecution() override {
     auto value = values_["disableEarlyViewCommandExecution"];
     if (!value.isNull()) {
diff --git a/packages/react-native/ReactCommon/react/featureflags/ReactNativeFeatureFlagsProvider.h b/packages/react-native/ReactCommon/react/featureflags/ReactNativeFeatureFlagsProvider.h
index bc1459bef441..0ebc84c09a4d 100644
--- a/packages/react-native/ReactCommon/react/featureflags/ReactNativeFeatureFlagsProvider.h
+++ b/packages/react-native/ReactCommon/react/featureflags/ReactNativeFeatureFlagsProvider.h
@@ -4,7 +4,7 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- * @generated SignedSource<<7626d25a1450564a30de026870f4d094>>
+ * @generated SignedSource<<8bbf8f87b1d254353caed0c6cef8470a>>
  */
 
 /**
@@ -32,6 +32,7 @@ class ReactNativeFeatureFlagsProvider {
   virtual bool cxxNativeAnimatedEnabled() = 0;
   virtual bool defaultTextToOverflowHidden() = 0;
   virtual bool deferTextInputTruncationIOS() = 0;
+  virtual bool deferYogaChildCloningUntilLayout() = 0;
   virtual bool disableEarlyViewCommandExecution() = 0;
   virtual bool disableIdleEventDispatchFrameCallbackRearmAndroid() = 0;
   virtual bool disableIdleMountItemFrameCallbackRearmAndroid() = 0;
diff --git a/packages/react-native/ReactCommon/react/nativemodule/featureflags/NativeReactNativeFeatureFlags.cpp b/packages/react-native/ReactCommon/react/nativemodule/featureflags/NativeReactNativeFeatureFlags.cpp
index 9d8c414b2686..1d9eb75c1b1f 100644
--- a/packages/react-native/ReactCommon/react/nativemodule/featureflags/NativeReactNativeFeatureFlags.cpp
+++ b/packages/react-native/ReactCommon/react/nativemodule/featureflags/NativeReactNativeFeatureFlags.cpp
@@ -4,7 +4,7 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- * @generated SignedSource<<ca361bb00c0b31657c5a1559a12d5f5a>>
+ * @generated SignedSource<<cff1b1e324367dd9e2565b089f1a5d84>>
  */
 
 /**
@@ -69,6 +69,11 @@ bool NativeReactNativeFeatureFlags::deferTextInputTruncationIOS(
   return ReactNativeFeatureFlags::deferTextInputTruncationIOS();
 }
 
+bool NativeReactNativeFeatureFlags::deferYogaChildCloningUntilLayout(
+    jsi::Runtime& /*runtime*/) {
+  return ReactNativeFeatureFlags::deferYogaChildCloningUntilLayout();
+}
+
 bool NativeReactNativeFeatureFlags::disableEarlyViewCommandExecution(
     jsi::Runtime& /*runtime*/) {
   return ReactNativeFeatureFlags::disableEarlyViewCommandExecution();
diff --git a/packages/react-native/ReactCommon/react/nativemodule/featureflags/NativeReactNativeFeatureFlags.h b/packages/react-native/ReactCommon/react/nativemodule/featureflags/NativeReactNativeFeatureFlags.h
index 4014c7ac6551..5e2e8e8a3d08 100644
--- a/packages/react-native/ReactCommon/react/nativemodule/featureflags/NativeReactNativeFeatureFlags.h
+++ b/packages/react-native/ReactCommon/react/nativemodule/featureflags/NativeReactNativeFeatureFlags.h
@@ -4,7 +4,7 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- * @generated SignedSource<<4d3151d0ce9a022c5b9b74e2a910229d>>
+ * @generated SignedSource<<b9184567b0209fd819429e359c7a1f91>>
  */
 
 /**
@@ -48,6 +48,8 @@ class NativeReactNativeFeatureFlags
 
   bool deferTextInputTruncationIOS(jsi::Runtime& runtime);
 
+  bool deferYogaChildCloningUntilLayout(jsi::Runtime& runtime);
+
   bool disableEarlyViewCommandExecution(jsi::Runtime& runtime);
 
   bool disableIdleEventDispatchFrameCallbackRearmAndroid(jsi::Runtime& runtime);
diff --git a/packages/react-native/ReactCommon/react/renderer/components/view/YogaLayoutableShadowNode.cpp b/packages/react-native/ReactCommon/react/renderer/components/view/YogaLayoutableShadowNode.cpp
index fb7c6e4ffe87..50fa03444521 100644
--- a/packages/react-native/ReactCommon/react/renderer/components/view/YogaLayoutableShadowNode.cpp
+++ b/packages/react-native/ReactCommon/react/renderer/components/view/YogaLayoutableShadowNode.cpp
@@ -203,11 +203,20 @@ void YogaLayoutableShadowNode::adoptYogaChild(size_t index) {
   auto& childNode =
       dynamic_cast<const YogaLayoutableShadowNode&>(*getChildren().at(index));
 
-  if (YGNodeGetOwner(&childNode.yogaNode_) == nullptr) {
+  auto childOwner = YGNodeGetOwner(&childNode.yogaNode_);
+  if (childOwner == nullptr) {
     // The child node is not owned.
     childNode.yogaNode_.setOwner(&yogaNode_);
     // At this point the child yoga node must be already inserted by the caller.
     // react_native_assert(layoutableChildNode.yogaNode_.isDirty());
+  } else if (
+      childOwner != &yogaNode_ &&
+      ReactNativeFeatureFlags::deferYogaChildCloningUntilLayout()) {
+    // The child is owned by another node, usually a previous revision of this
+    // node that the child is unchanged from. Keep sharing it instead of
+    // cloning it here: Yoga clones each child it doesn't own before laying it
+    // out (see `yogaNodeCloneCallbackConnector`), so the child is only cloned
+    // if this node is laid out.
   } else {
     // The child is owned by some other node, we need to clone that.
     // TODO: At this point, React has wrong reference to the node. (T138668036)
@@ -747,6 +756,19 @@ void YogaLayoutableShadowNode::layout(LayoutContext layoutContext) {
   // Reading data from a dirtied node does not make sense.
   react_native_assert(!YGNodeIsDirty(&yogaNode_));
 
+  if (ReactNativeFeatureFlags::deferYogaChildCloningUntilLayout()) {
+    // A child that Yoga lays out is a clone that this node owns, but Yoga can
+    // set a new layout on this node from its cache without cloning its
+    // children. A child that is still shared with another revision must not
+    // be written to below, so clone it first if it carries a new layout.
+    for (size_t i = 0; i < yogaLayoutableChildren_.size(); i++) {
+      const auto& child = *yogaLayoutableChildren_[i];
+      if (child.yogaNode_.getHasNewLayout() && !doesOwn(child)) {
+        cloneChildInPlace(i);
+      }
+    }
+  }
+
   for (auto childYogaNode : yogaNode_.getChildren()) {
     auto& childNode = shadowNodeFromContext(childYogaNode);
 
diff --git a/packages/react-native/scripts/featureflags/ReactNativeFeatureFlags.config.js b/packages/react-native/scripts/featureflags/ReactNativeFeatureFlags.config.js
index ac6c41e0a8e3..22370efe12ea 100644
--- a/packages/react-native/scripts/featureflags/ReactNativeFeatureFlags.config.js
+++ b/packages/react-native/scripts/featureflags/ReactNativeFeatureFlags.config.js
@@ -104,6 +104,17 @@ const definitions: FeatureFlagDefinitions = {
       },
       ossReleaseStage: 'none',
     },
+    deferYogaChildCloningUntilLayout: {
+      defaultValue: false,
+      metadata: {
+        dateAdded: '2026-10-21',
+        description:
+          'When a node gets a new list of children, the children that a previous revision of the node still owns stay shared with that revision instead of being cloned right away. Yoga clones them if it lays the node out.',
+        expectedReleaseValue: true,
+        purpose: 'experimentation',
+      },
+      ossReleaseStage: 'none',
+    },
     disableEarlyViewCommandExecution: {
       defaultValue: false,
       metadata: {
diff --git a/packages/react-native/src/private/featureflags/ReactNativeFeatureFlags.js b/packages/react-native/src/private/featureflags/ReactNativeFeatureFlags.js
index c1c6f65c21d1..b86e034139c4 100644
--- a/packages/react-native/src/private/featureflags/ReactNativeFeatureFlags.js
+++ b/packages/react-native/src/private/featureflags/ReactNativeFeatureFlags.js
@@ -4,7 +4,7 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- * @generated SignedSource<<5a79107fda7ef89a1d68594cad01b8e7>>
+ * @generated SignedSource<<439409b673303df5cbf7695cf1a1763c>>
  * @flow strict
  * @noformat
  */
@@ -54,6 +54,7 @@ export type ReactNativeFeatureFlags = Readonly<{
   cxxNativeAnimatedEnabled: Getter<boolean>,
   defaultTextToOverflowHidden: Getter<boolean>,
   deferTextInputTruncationIOS: Getter<boolean>,
+  deferYogaChildCloningUntilLayout: Getter<boolean>,
   disableEarlyViewCommandExecution: Getter<boolean>,
   disableIdleEventDispatchFrameCallbackRearmAndroid: Getter<boolean>,
   disableIdleMountItemFrameCallbackRearmAndroid: Getter<boolean>,
@@ -241,6 +242,10 @@ export const defaultTextToOverflowHidden: Getter<boolean> = createNativeFlagGett
  * When enabled, iOS TextInput applies edits that JS transforms (e.g. maxLength truncation) incrementally after the UIKit text change delegate call returns, avoiding synchronous text and selection rewrites that can deadlock UIKeyboardTaskQueue.
  */
 export const deferTextInputTruncationIOS: Getter<boolean> = createNativeFlagGetter('deferTextInputTruncationIOS', false);
+/**
+ * When a node gets a new list of children, the children that a previous revision of the node still owns stay shared with that revision instead of being cloned right away. Yoga clones them if it lays the node out.
+ */
+export const deferYogaChildCloningUntilLayout: Getter<boolean> = createNativeFlagGetter('deferYogaChildCloningUntilLayout', false);
 /**
  * Dispatch view commands in mount item order.
  */
diff --git a/packages/react-native/src/private/featureflags/specs/NativeReactNativeFeatureFlags.js b/packages/react-native/src/private/featureflags/specs/NativeReactNativeFeatureFlags.js
index 48355705857f..29551deb1e6c 100644
--- a/packages/react-native/src/private/featureflags/specs/NativeReactNativeFeatureFlags.js
+++ b/packages/react-native/src/private/featureflags/specs/NativeReactNativeFeatureFlags.js
@@ -4,7 +4,7 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- * @generated SignedSource<<a21712fc03890b45ea92ecb883fa3139>>
+ * @generated SignedSource<<538f8732e00af035f969924e1ed33e3a>>
  * @flow strict
  * @noformat
  */
@@ -30,6 +30,7 @@ export interface Spec extends TurboModule {
   readonly cxxNativeAnimatedEnabled?: () => boolean;
   readonly defaultTextToOverflowHidden?: () => boolean;
   readonly deferTextInputTruncationIOS?: () => boolean;
+  readonly deferYogaChildCloningUntilLayout?: () => boolean;
   readonly disableEarlyViewCommandExecution?: () => boolean;
   readonly disableIdleEventDispatchFrameCallbackRearmAndroid?: () => boolean;
   readonly disableIdleMountItemFrameCallbackRearmAndroid?: () => boolean;