Add fragment handles to children of FragmentInstances by jackpope · Pull Request #34935 · react/react

jackpope · 2025-10-21T21:37:53Z

This PR adds a unstable_reactFragments?: Set<FragmentInstance> property to DOM nodes that belong to a Fragment with a ref (top level host components). This allows you to access a FragmentInstance from a DOM node.

This is flagged behind enableFragmentRefsInstanceHandles.

The primary use case to unblock is reusing IntersectionObserver instances. A fairly common practice is to cache and reuse IntersectionObservers that share the same config, with a map of node->callbacks to run for each entry in the IO callback. Currently this is not possible with Fragment Ref observeUsing because the key in the cache would have to be the FragmentInstance and you can't find it without a handle from the node. This works now by accessing entry.target.fragments.

This also opens up possibilities to use FragmentInstance operations in other places, such as events. We can do event.target.unstable_reactFragments, then access fragmentInstance.getClientRects for example. In a future PR, we can assign an event's currentTarget as the Fragment Ref for a more direct handle when the event has been dispatched by the Fragment itself.

The first commit here implemented a handle only on observed elements. This is awkward because there isn't a good way to document or expose this temporary property. element.fragments is closer to what we would expect from a DOM API if a standard was implemented here. And by assigning it to all top-level nodes of a Fragment, it can be used beyond the cached IntersectionObserver callback.

One tradeoff here is adding extra work during the creation of FragmentInstances as well as keeping track of adding/removing nodes. Previously we only track the Fiber on creation but here we add a traversal which could apply to a large set of top-level host children. The element.unstable_reactFragments Set can also be randomly ordered.

react-sizebot · 2025-10-21T21:41:28Z

The size diff is too large to display in a single comment. The GitHub action for this pull request contains an artifact called 'sizebot-message.md' with the full message.

Generated by 🚫 dangerJS against 2d226ab

rickhanlonii · 2025-11-03T19:28:44Z

 };
 }

+function addFragmentHandleToFiber(


I'd gate inside these fns too

rickhanlonii

lgtm

This PR adds a `unstable_reactFragments?: Set<FragmentInstance>` property to DOM nodes that belong to a Fragment with a ref (top level host components). This allows you to access a FragmentInstance from a DOM node. This is flagged behind `enableFragmentRefsInstanceHandles`. The primary use case to unblock is reusing IntersectionObserver instances. A fairly common practice is to cache and reuse IntersectionObservers that share the same config, with a map of node->callbacks to run for each entry in the IO callback. Currently this is not possible with Fragment Ref `observeUsing` because the key in the cache would have to be the `FragmentInstance` and you can't find it without a handle from the node. This works now by accessing `entry.target.fragments`. This also opens up possibilities to use `FragmentInstance` operations in other places, such as events. We can do `event.target.unstable_reactFragments`, then access `fragmentInstance.getClientRects` for example. In a future PR, we can assign an event's `currentTarget` as the Fragment Ref for a more direct handle when the event has been dispatched by the Fragment itself. The first commit here implemented a handle only on observed elements. This is awkward because there isn't a good way to document or expose this temporary property. `element.fragments` is closer to what we would expect from a DOM API if a standard was implemented here. And by assigning it to all top-level nodes of a Fragment, it can be used beyond the cached IntersectionObserver callback. One tradeoff here is adding extra work during the creation of FragmentInstances as well as keeping track of adding/removing nodes. Previously we only track the Fiber on creation but here we add a traversal which could apply to a large set of top-level host children. The `element.unstable_reactFragments` Set can also be randomly ordered. DiffTrain build for [edd05f1](edd05f1)

This PR adds a `unstable_reactFragments?: Set<FragmentInstance>` property to DOM nodes that belong to a Fragment with a ref (top level host components). This allows you to access a FragmentInstance from a DOM node. This is flagged behind `enableFragmentRefsInstanceHandles`. The primary use case to unblock is reusing IntersectionObserver instances. A fairly common practice is to cache and reuse IntersectionObservers that share the same config, with a map of node->callbacks to run for each entry in the IO callback. Currently this is not possible with Fragment Ref `observeUsing` because the key in the cache would have to be the `FragmentInstance` and you can't find it without a handle from the node. This works now by accessing `entry.target.fragments`. This also opens up possibilities to use `FragmentInstance` operations in other places, such as events. We can do `event.target.unstable_reactFragments`, then access `fragmentInstance.getClientRects` for example. In a future PR, we can assign an event's `currentTarget` as the Fragment Ref for a more direct handle when the event has been dispatched by the Fragment itself. The first commit here implemented a handle only on observed elements. This is awkward because there isn't a good way to document or expose this temporary property. `element.fragments` is closer to what we would expect from a DOM API if a standard was implemented here. And by assigning it to all top-level nodes of a Fragment, it can be used beyond the cached IntersectionObserver callback. One tradeoff here is adding extra work during the creation of FragmentInstances as well as keeping track of adding/removing nodes. Previously we only track the Fiber on creation but here we add a traversal which could apply to a large set of top-level host children. The `element.unstable_reactFragments` Set can also be randomly ordered. DiffTrain build for [edd05f1](react@edd05f1)

Summary: Pull Request resolved: #55614 - enableFragmentRefsInstanceHandles - Enables a pointer on each element back to the FragmentInstances that control it. Needed to implement the common IntersectionObserver pattern of reusing IntersectionObservers across multiple callbacks. See more in react/react#34935 - enableFragmentRefsTextNodes - This should be a noop on RN as unlike dom, text nodes are considered host components and already handled. Text without a `<Text/>` wrapper throws an error. Changelog: [Internal] Reviewed By: christophpurrer Differential Revision: D93479122 fbshipit-source-id: 639369893c8aafc1d2bf0ffbdf4bf09fe6dca45c

#34935 Introduced `unstable_reactFragments` handle on DOM nodes to enable caching of Observers. This has been tested in production and is stable so it can be rolled out with the Fragment Refs feature.

#34935 Introduced `unstable_reactFragments` handle on DOM nodes to enable caching of Observers. This has been tested in production and is stable so it can be rolled out with the Fragment Refs feature. DiffTrain build for [9c0323e](9c0323e)

react#34935 Introduced `unstable_reactFragments` handle on DOM nodes to enable caching of Observers. This has been tested in production and is stable so it can be rolled out with the Fragment Refs feature. DiffTrain build for [9c0323e](react@9c0323e)

jackpope · 2025-10-21T21:37:53Z

This PR adds a unstable_reactFragments?: Set<FragmentInstance> property to DOM nodes that belong to a Fragment with a ref (top level host components). This allows you to access a FragmentInstance from a DOM node.

This is flagged behind enableFragmentRefsInstanceHandles.

The primary use case to unblock is reusing IntersectionObserver instances. A fairly common practice is to cache and reuse IntersectionObservers that share the same config, with a map of node->callbacks to run for each entry in the IO callback. Currently this is not possible with Fragment Ref observeUsing because the key in the cache would have to be the FragmentInstance and you can't find it without a handle from the node. This works now by accessing entry.target.fragments.

This also opens up possibilities to use FragmentInstance operations in other places, such as events. We can do event.target.unstable_reactFragments, then access fragmentInstance.getClientRects for example. In a future PR, we can assign an event's currentTarget as the Fragment Ref for a more direct handle when the event has been dispatched by the Fragment itself.

The first commit here implemented a handle only on observed elements. This is awkward because there isn't a good way to document or expose this temporary property. element.fragments is closer to what we would expect from a DOM API if a standard was implemented here. And by assigning it to all top-level nodes of a Fragment, it can be used beyond the cached IntersectionObserver callback.

One tradeoff here is adding extra work during the creation of FragmentInstances as well as keeping track of adding/removing nodes. Previously we only track the Fiber on creation but here we add a traversal which could apply to a large set of top-level host children. The element.unstable_reactFragments Set can also be randomly ordered.

react-sizebot · 2025-10-21T21:41:28Z

The size diff is too large to display in a single comment. The GitHub action for this pull request contains an artifact called 'sizebot-message.md' with the full message.

Generated by 🚫 dangerJS against 2d226ab

rickhanlonii · 2025-11-03T19:28:44Z

 };
 }

+function addFragmentHandleToFiber(


I'd gate inside these fns too

rickhanlonii

lgtm

This PR adds a `unstable_reactFragments?: Set<FragmentInstance>` property to DOM nodes that belong to a Fragment with a ref (top level host components). This allows you to access a FragmentInstance from a DOM node. This is flagged behind `enableFragmentRefsInstanceHandles`. The primary use case to unblock is reusing IntersectionObserver instances. A fairly common practice is to cache and reuse IntersectionObservers that share the same config, with a map of node->callbacks to run for each entry in the IO callback. Currently this is not possible with Fragment Ref `observeUsing` because the key in the cache would have to be the `FragmentInstance` and you can't find it without a handle from the node. This works now by accessing `entry.target.fragments`. This also opens up possibilities to use `FragmentInstance` operations in other places, such as events. We can do `event.target.unstable_reactFragments`, then access `fragmentInstance.getClientRects` for example. In a future PR, we can assign an event's `currentTarget` as the Fragment Ref for a more direct handle when the event has been dispatched by the Fragment itself. The first commit here implemented a handle only on observed elements. This is awkward because there isn't a good way to document or expose this temporary property. `element.fragments` is closer to what we would expect from a DOM API if a standard was implemented here. And by assigning it to all top-level nodes of a Fragment, it can be used beyond the cached IntersectionObserver callback. One tradeoff here is adding extra work during the creation of FragmentInstances as well as keeping track of adding/removing nodes. Previously we only track the Fiber on creation but here we add a traversal which could apply to a large set of top-level host children. The `element.unstable_reactFragments` Set can also be randomly ordered. DiffTrain build for [edd05f1](edd05f1)

This PR adds a `unstable_reactFragments?: Set<FragmentInstance>` property to DOM nodes that belong to a Fragment with a ref (top level host components). This allows you to access a FragmentInstance from a DOM node. This is flagged behind `enableFragmentRefsInstanceHandles`. The primary use case to unblock is reusing IntersectionObserver instances. A fairly common practice is to cache and reuse IntersectionObservers that share the same config, with a map of node->callbacks to run for each entry in the IO callback. Currently this is not possible with Fragment Ref `observeUsing` because the key in the cache would have to be the `FragmentInstance` and you can't find it without a handle from the node. This works now by accessing `entry.target.fragments`. This also opens up possibilities to use `FragmentInstance` operations in other places, such as events. We can do `event.target.unstable_reactFragments`, then access `fragmentInstance.getClientRects` for example. In a future PR, we can assign an event's `currentTarget` as the Fragment Ref for a more direct handle when the event has been dispatched by the Fragment itself. The first commit here implemented a handle only on observed elements. This is awkward because there isn't a good way to document or expose this temporary property. `element.fragments` is closer to what we would expect from a DOM API if a standard was implemented here. And by assigning it to all top-level nodes of a Fragment, it can be used beyond the cached IntersectionObserver callback. One tradeoff here is adding extra work during the creation of FragmentInstances as well as keeping track of adding/removing nodes. Previously we only track the Fiber on creation but here we add a traversal which could apply to a large set of top-level host children. The `element.unstable_reactFragments` Set can also be randomly ordered. DiffTrain build for [edd05f1](react@edd05f1)

Summary: Pull Request resolved: #55614 - enableFragmentRefsInstanceHandles - Enables a pointer on each element back to the FragmentInstances that control it. Needed to implement the common IntersectionObserver pattern of reusing IntersectionObservers across multiple callbacks. See more in react/react#34935 - enableFragmentRefsTextNodes - This should be a noop on RN as unlike dom, text nodes are considered host components and already handled. Text without a `<Text/>` wrapper throws an error. Changelog: [Internal] Reviewed By: christophpurrer Differential Revision: D93479122 fbshipit-source-id: 639369893c8aafc1d2bf0ffbdf4bf09fe6dca45c

#34935 Introduced `unstable_reactFragments` handle on DOM nodes to enable caching of Observers. This has been tested in production and is stable so it can be rolled out with the Fragment Refs feature.

#34935 Introduced `unstable_reactFragments` handle on DOM nodes to enable caching of Observers. This has been tested in production and is stable so it can be rolled out with the Fragment Refs feature. DiffTrain build for [9c0323e](9c0323e)

react#34935 Introduced `unstable_reactFragments` handle on DOM nodes to enable caching of Observers. This has been tested in production and is stable so it can be rolled out with the Fragment Refs feature. DiffTrain build for [9c0323e](react@9c0323e)

jackpope · 2025-10-21T21:37:53Z

This PR adds a unstable_reactFragments?: Set<FragmentInstance> property to DOM nodes that belong to a Fragment with a ref (top level host components). This allows you to access a FragmentInstance from a DOM node.

This is flagged behind enableFragmentRefsInstanceHandles.

The primary use case to unblock is reusing IntersectionObserver instances. A fairly common practice is to cache and reuse IntersectionObservers that share the same config, with a map of node->callbacks to run for each entry in the IO callback. Currently this is not possible with Fragment Ref observeUsing because the key in the cache would have to be the FragmentInstance and you can't find it without a handle from the node. This works now by accessing entry.target.fragments.

This also opens up possibilities to use FragmentInstance operations in other places, such as events. We can do event.target.unstable_reactFragments, then access fragmentInstance.getClientRects for example. In a future PR, we can assign an event's currentTarget as the Fragment Ref for a more direct handle when the event has been dispatched by the Fragment itself.

The first commit here implemented a handle only on observed elements. This is awkward because there isn't a good way to document or expose this temporary property. element.fragments is closer to what we would expect from a DOM API if a standard was implemented here. And by assigning it to all top-level nodes of a Fragment, it can be used beyond the cached IntersectionObserver callback.

One tradeoff here is adding extra work during the creation of FragmentInstances as well as keeping track of adding/removing nodes. Previously we only track the Fiber on creation but here we add a traversal which could apply to a large set of top-level host children. The element.unstable_reactFragments Set can also be randomly ordered.

react-sizebot · 2025-10-21T21:41:28Z

The size diff is too large to display in a single comment. The GitHub action for this pull request contains an artifact called 'sizebot-message.md' with the full message.

Generated by 🚫 dangerJS against 2d226ab

rickhanlonii · 2025-11-03T19:28:44Z

 };
 }

+function addFragmentHandleToFiber(


I'd gate inside these fns too

rickhanlonii

lgtm

This PR adds a `unstable_reactFragments?: Set<FragmentInstance>` property to DOM nodes that belong to a Fragment with a ref (top level host components). This allows you to access a FragmentInstance from a DOM node. This is flagged behind `enableFragmentRefsInstanceHandles`. The primary use case to unblock is reusing IntersectionObserver instances. A fairly common practice is to cache and reuse IntersectionObservers that share the same config, with a map of node->callbacks to run for each entry in the IO callback. Currently this is not possible with Fragment Ref `observeUsing` because the key in the cache would have to be the `FragmentInstance` and you can't find it without a handle from the node. This works now by accessing `entry.target.fragments`. This also opens up possibilities to use `FragmentInstance` operations in other places, such as events. We can do `event.target.unstable_reactFragments`, then access `fragmentInstance.getClientRects` for example. In a future PR, we can assign an event's `currentTarget` as the Fragment Ref for a more direct handle when the event has been dispatched by the Fragment itself. The first commit here implemented a handle only on observed elements. This is awkward because there isn't a good way to document or expose this temporary property. `element.fragments` is closer to what we would expect from a DOM API if a standard was implemented here. And by assigning it to all top-level nodes of a Fragment, it can be used beyond the cached IntersectionObserver callback. One tradeoff here is adding extra work during the creation of FragmentInstances as well as keeping track of adding/removing nodes. Previously we only track the Fiber on creation but here we add a traversal which could apply to a large set of top-level host children. The `element.unstable_reactFragments` Set can also be randomly ordered. DiffTrain build for [edd05f1](edd05f1)

This PR adds a `unstable_reactFragments?: Set<FragmentInstance>` property to DOM nodes that belong to a Fragment with a ref (top level host components). This allows you to access a FragmentInstance from a DOM node. This is flagged behind `enableFragmentRefsInstanceHandles`. The primary use case to unblock is reusing IntersectionObserver instances. A fairly common practice is to cache and reuse IntersectionObservers that share the same config, with a map of node->callbacks to run for each entry in the IO callback. Currently this is not possible with Fragment Ref `observeUsing` because the key in the cache would have to be the `FragmentInstance` and you can't find it without a handle from the node. This works now by accessing `entry.target.fragments`. This also opens up possibilities to use `FragmentInstance` operations in other places, such as events. We can do `event.target.unstable_reactFragments`, then access `fragmentInstance.getClientRects` for example. In a future PR, we can assign an event's `currentTarget` as the Fragment Ref for a more direct handle when the event has been dispatched by the Fragment itself. The first commit here implemented a handle only on observed elements. This is awkward because there isn't a good way to document or expose this temporary property. `element.fragments` is closer to what we would expect from a DOM API if a standard was implemented here. And by assigning it to all top-level nodes of a Fragment, it can be used beyond the cached IntersectionObserver callback. One tradeoff here is adding extra work during the creation of FragmentInstances as well as keeping track of adding/removing nodes. Previously we only track the Fiber on creation but here we add a traversal which could apply to a large set of top-level host children. The `element.unstable_reactFragments` Set can also be randomly ordered. DiffTrain build for [edd05f1](react@edd05f1)

Summary: Pull Request resolved: #55614 - enableFragmentRefsInstanceHandles - Enables a pointer on each element back to the FragmentInstances that control it. Needed to implement the common IntersectionObserver pattern of reusing IntersectionObservers across multiple callbacks. See more in react/react#34935 - enableFragmentRefsTextNodes - This should be a noop on RN as unlike dom, text nodes are considered host components and already handled. Text without a `<Text/>` wrapper throws an error. Changelog: [Internal] Reviewed By: christophpurrer Differential Revision: D93479122 fbshipit-source-id: 639369893c8aafc1d2bf0ffbdf4bf09fe6dca45c

#34935 Introduced `unstable_reactFragments` handle on DOM nodes to enable caching of Observers. This has been tested in production and is stable so it can be rolled out with the Fragment Refs feature.

#34935 Introduced `unstable_reactFragments` handle on DOM nodes to enable caching of Observers. This has been tested in production and is stable so it can be rolled out with the Fragment Refs feature. DiffTrain build for [9c0323e](9c0323e)

react#34935 Introduced `unstable_reactFragments` handle on DOM nodes to enable caching of Observers. This has been tested in production and is stable so it can be rolled out with the Fragment Refs feature. DiffTrain build for [9c0323e](react@9c0323e)

jackpope · 2025-10-21T21:37:53Z

This PR adds a unstable_reactFragments?: Set<FragmentInstance> property to DOM nodes that belong to a Fragment with a ref (top level host components). This allows you to access a FragmentInstance from a DOM node.

This is flagged behind enableFragmentRefsInstanceHandles.

The primary use case to unblock is reusing IntersectionObserver instances. A fairly common practice is to cache and reuse IntersectionObservers that share the same config, with a map of node->callbacks to run for each entry in the IO callback. Currently this is not possible with Fragment Ref observeUsing because the key in the cache would have to be the FragmentInstance and you can't find it without a handle from the node. This works now by accessing entry.target.fragments.

This also opens up possibilities to use FragmentInstance operations in other places, such as events. We can do event.target.unstable_reactFragments, then access fragmentInstance.getClientRects for example. In a future PR, we can assign an event's currentTarget as the Fragment Ref for a more direct handle when the event has been dispatched by the Fragment itself.

The first commit here implemented a handle only on observed elements. This is awkward because there isn't a good way to document or expose this temporary property. element.fragments is closer to what we would expect from a DOM API if a standard was implemented here. And by assigning it to all top-level nodes of a Fragment, it can be used beyond the cached IntersectionObserver callback.

One tradeoff here is adding extra work during the creation of FragmentInstances as well as keeping track of adding/removing nodes. Previously we only track the Fiber on creation but here we add a traversal which could apply to a large set of top-level host children. The element.unstable_reactFragments Set can also be randomly ordered.

react-sizebot · 2025-10-21T21:41:28Z

The size diff is too large to display in a single comment. The GitHub action for this pull request contains an artifact called 'sizebot-message.md' with the full message.

Generated by 🚫 dangerJS against 2d226ab

rickhanlonii · 2025-11-03T19:28:44Z

 };
 }

+function addFragmentHandleToFiber(


I'd gate inside these fns too

rickhanlonii

lgtm

This PR adds a `unstable_reactFragments?: Set<FragmentInstance>` property to DOM nodes that belong to a Fragment with a ref (top level host components). This allows you to access a FragmentInstance from a DOM node. This is flagged behind `enableFragmentRefsInstanceHandles`. The primary use case to unblock is reusing IntersectionObserver instances. A fairly common practice is to cache and reuse IntersectionObservers that share the same config, with a map of node->callbacks to run for each entry in the IO callback. Currently this is not possible with Fragment Ref `observeUsing` because the key in the cache would have to be the `FragmentInstance` and you can't find it without a handle from the node. This works now by accessing `entry.target.fragments`. This also opens up possibilities to use `FragmentInstance` operations in other places, such as events. We can do `event.target.unstable_reactFragments`, then access `fragmentInstance.getClientRects` for example. In a future PR, we can assign an event's `currentTarget` as the Fragment Ref for a more direct handle when the event has been dispatched by the Fragment itself. The first commit here implemented a handle only on observed elements. This is awkward because there isn't a good way to document or expose this temporary property. `element.fragments` is closer to what we would expect from a DOM API if a standard was implemented here. And by assigning it to all top-level nodes of a Fragment, it can be used beyond the cached IntersectionObserver callback. One tradeoff here is adding extra work during the creation of FragmentInstances as well as keeping track of adding/removing nodes. Previously we only track the Fiber on creation but here we add a traversal which could apply to a large set of top-level host children. The `element.unstable_reactFragments` Set can also be randomly ordered. DiffTrain build for [edd05f1](edd05f1)

This PR adds a `unstable_reactFragments?: Set<FragmentInstance>` property to DOM nodes that belong to a Fragment with a ref (top level host components). This allows you to access a FragmentInstance from a DOM node. This is flagged behind `enableFragmentRefsInstanceHandles`. The primary use case to unblock is reusing IntersectionObserver instances. A fairly common practice is to cache and reuse IntersectionObservers that share the same config, with a map of node->callbacks to run for each entry in the IO callback. Currently this is not possible with Fragment Ref `observeUsing` because the key in the cache would have to be the `FragmentInstance` and you can't find it without a handle from the node. This works now by accessing `entry.target.fragments`. This also opens up possibilities to use `FragmentInstance` operations in other places, such as events. We can do `event.target.unstable_reactFragments`, then access `fragmentInstance.getClientRects` for example. In a future PR, we can assign an event's `currentTarget` as the Fragment Ref for a more direct handle when the event has been dispatched by the Fragment itself. The first commit here implemented a handle only on observed elements. This is awkward because there isn't a good way to document or expose this temporary property. `element.fragments` is closer to what we would expect from a DOM API if a standard was implemented here. And by assigning it to all top-level nodes of a Fragment, it can be used beyond the cached IntersectionObserver callback. One tradeoff here is adding extra work during the creation of FragmentInstances as well as keeping track of adding/removing nodes. Previously we only track the Fiber on creation but here we add a traversal which could apply to a large set of top-level host children. The `element.unstable_reactFragments` Set can also be randomly ordered. DiffTrain build for [edd05f1](react@edd05f1)

Summary: Pull Request resolved: #55614 - enableFragmentRefsInstanceHandles - Enables a pointer on each element back to the FragmentInstances that control it. Needed to implement the common IntersectionObserver pattern of reusing IntersectionObservers across multiple callbacks. See more in react/react#34935 - enableFragmentRefsTextNodes - This should be a noop on RN as unlike dom, text nodes are considered host components and already handled. Text without a `<Text/>` wrapper throws an error. Changelog: [Internal] Reviewed By: christophpurrer Differential Revision: D93479122 fbshipit-source-id: 639369893c8aafc1d2bf0ffbdf4bf09fe6dca45c

#34935 Introduced `unstable_reactFragments` handle on DOM nodes to enable caching of Observers. This has been tested in production and is stable so it can be rolled out with the Fragment Refs feature.

#34935 Introduced `unstable_reactFragments` handle on DOM nodes to enable caching of Observers. This has been tested in production and is stable so it can be rolled out with the Fragment Refs feature. DiffTrain build for [9c0323e](9c0323e)

react#34935 Introduced `unstable_reactFragments` handle on DOM nodes to enable caching of Observers. This has been tested in production and is stable so it can be rolled out with the Fragment Refs feature. DiffTrain build for [9c0323e](react@9c0323e)

jackpope · 2025-10-21T21:37:53Z

This PR adds a unstable_reactFragments?: Set<FragmentInstance> property to DOM nodes that belong to a Fragment with a ref (top level host components). This allows you to access a FragmentInstance from a DOM node.

This is flagged behind enableFragmentRefsInstanceHandles.

The primary use case to unblock is reusing IntersectionObserver instances. A fairly common practice is to cache and reuse IntersectionObservers that share the same config, with a map of node->callbacks to run for each entry in the IO callback. Currently this is not possible with Fragment Ref observeUsing because the key in the cache would have to be the FragmentInstance and you can't find it without a handle from the node. This works now by accessing entry.target.fragments.

This also opens up possibilities to use FragmentInstance operations in other places, such as events. We can do event.target.unstable_reactFragments, then access fragmentInstance.getClientRects for example. In a future PR, we can assign an event's currentTarget as the Fragment Ref for a more direct handle when the event has been dispatched by the Fragment itself.

The first commit here implemented a handle only on observed elements. This is awkward because there isn't a good way to document or expose this temporary property. element.fragments is closer to what we would expect from a DOM API if a standard was implemented here. And by assigning it to all top-level nodes of a Fragment, it can be used beyond the cached IntersectionObserver callback.

One tradeoff here is adding extra work during the creation of FragmentInstances as well as keeping track of adding/removing nodes. Previously we only track the Fiber on creation but here we add a traversal which could apply to a large set of top-level host children. The element.unstable_reactFragments Set can also be randomly ordered.

react-sizebot · 2025-10-21T21:41:28Z

The size diff is too large to display in a single comment. The GitHub action for this pull request contains an artifact called 'sizebot-message.md' with the full message.

Generated by 🚫 dangerJS against 2d226ab

rickhanlonii · 2025-11-03T19:28:44Z

 };
 }

+function addFragmentHandleToFiber(


I'd gate inside these fns too

rickhanlonii

lgtm

This PR adds a `unstable_reactFragments?: Set<FragmentInstance>` property to DOM nodes that belong to a Fragment with a ref (top level host components). This allows you to access a FragmentInstance from a DOM node. This is flagged behind `enableFragmentRefsInstanceHandles`. The primary use case to unblock is reusing IntersectionObserver instances. A fairly common practice is to cache and reuse IntersectionObservers that share the same config, with a map of node->callbacks to run for each entry in the IO callback. Currently this is not possible with Fragment Ref `observeUsing` because the key in the cache would have to be the `FragmentInstance` and you can't find it without a handle from the node. This works now by accessing `entry.target.fragments`. This also opens up possibilities to use `FragmentInstance` operations in other places, such as events. We can do `event.target.unstable_reactFragments`, then access `fragmentInstance.getClientRects` for example. In a future PR, we can assign an event's `currentTarget` as the Fragment Ref for a more direct handle when the event has been dispatched by the Fragment itself. The first commit here implemented a handle only on observed elements. This is awkward because there isn't a good way to document or expose this temporary property. `element.fragments` is closer to what we would expect from a DOM API if a standard was implemented here. And by assigning it to all top-level nodes of a Fragment, it can be used beyond the cached IntersectionObserver callback. One tradeoff here is adding extra work during the creation of FragmentInstances as well as keeping track of adding/removing nodes. Previously we only track the Fiber on creation but here we add a traversal which could apply to a large set of top-level host children. The `element.unstable_reactFragments` Set can also be randomly ordered. DiffTrain build for [edd05f1](edd05f1)

This PR adds a `unstable_reactFragments?: Set<FragmentInstance>` property to DOM nodes that belong to a Fragment with a ref (top level host components). This allows you to access a FragmentInstance from a DOM node. This is flagged behind `enableFragmentRefsInstanceHandles`. The primary use case to unblock is reusing IntersectionObserver instances. A fairly common practice is to cache and reuse IntersectionObservers that share the same config, with a map of node->callbacks to run for each entry in the IO callback. Currently this is not possible with Fragment Ref `observeUsing` because the key in the cache would have to be the `FragmentInstance` and you can't find it without a handle from the node. This works now by accessing `entry.target.fragments`. This also opens up possibilities to use `FragmentInstance` operations in other places, such as events. We can do `event.target.unstable_reactFragments`, then access `fragmentInstance.getClientRects` for example. In a future PR, we can assign an event's `currentTarget` as the Fragment Ref for a more direct handle when the event has been dispatched by the Fragment itself. The first commit here implemented a handle only on observed elements. This is awkward because there isn't a good way to document or expose this temporary property. `element.fragments` is closer to what we would expect from a DOM API if a standard was implemented here. And by assigning it to all top-level nodes of a Fragment, it can be used beyond the cached IntersectionObserver callback. One tradeoff here is adding extra work during the creation of FragmentInstances as well as keeping track of adding/removing nodes. Previously we only track the Fiber on creation but here we add a traversal which could apply to a large set of top-level host children. The `element.unstable_reactFragments` Set can also be randomly ordered. DiffTrain build for [edd05f1](react@edd05f1)

Summary: Pull Request resolved: #55614 - enableFragmentRefsInstanceHandles - Enables a pointer on each element back to the FragmentInstances that control it. Needed to implement the common IntersectionObserver pattern of reusing IntersectionObservers across multiple callbacks. See more in react/react#34935 - enableFragmentRefsTextNodes - This should be a noop on RN as unlike dom, text nodes are considered host components and already handled. Text without a `<Text/>` wrapper throws an error. Changelog: [Internal] Reviewed By: christophpurrer Differential Revision: D93479122 fbshipit-source-id: 639369893c8aafc1d2bf0ffbdf4bf09fe6dca45c

#34935 Introduced `unstable_reactFragments` handle on DOM nodes to enable caching of Observers. This has been tested in production and is stable so it can be rolled out with the Fragment Refs feature.

#34935 Introduced `unstable_reactFragments` handle on DOM nodes to enable caching of Observers. This has been tested in production and is stable so it can be rolled out with the Fragment Refs feature. DiffTrain build for [9c0323e](9c0323e)

react#34935 Introduced `unstable_reactFragments` handle on DOM nodes to enable caching of Observers. This has been tested in production and is stable so it can be rolled out with the Fragment Refs feature. DiffTrain build for [9c0323e](react@9c0323e)

jackpope · 2025-10-21T21:37:53Z

This PR adds a unstable_reactFragments?: Set<FragmentInstance> property to DOM nodes that belong to a Fragment with a ref (top level host components). This allows you to access a FragmentInstance from a DOM node.

This is flagged behind enableFragmentRefsInstanceHandles.

The primary use case to unblock is reusing IntersectionObserver instances. A fairly common practice is to cache and reuse IntersectionObservers that share the same config, with a map of node->callbacks to run for each entry in the IO callback. Currently this is not possible with Fragment Ref observeUsing because the key in the cache would have to be the FragmentInstance and you can't find it without a handle from the node. This works now by accessing entry.target.fragments.

This also opens up possibilities to use FragmentInstance operations in other places, such as events. We can do event.target.unstable_reactFragments, then access fragmentInstance.getClientRects for example. In a future PR, we can assign an event's currentTarget as the Fragment Ref for a more direct handle when the event has been dispatched by the Fragment itself.

The first commit here implemented a handle only on observed elements. This is awkward because there isn't a good way to document or expose this temporary property. element.fragments is closer to what we would expect from a DOM API if a standard was implemented here. And by assigning it to all top-level nodes of a Fragment, it can be used beyond the cached IntersectionObserver callback.

One tradeoff here is adding extra work during the creation of FragmentInstances as well as keeping track of adding/removing nodes. Previously we only track the Fiber on creation but here we add a traversal which could apply to a large set of top-level host children. The element.unstable_reactFragments Set can also be randomly ordered.

react-sizebot · 2025-10-21T21:41:28Z

The size diff is too large to display in a single comment. The GitHub action for this pull request contains an artifact called 'sizebot-message.md' with the full message.

Generated by 🚫 dangerJS against 2d226ab

rickhanlonii · 2025-11-03T19:28:44Z

 };
 }

+function addFragmentHandleToFiber(


I'd gate inside these fns too

rickhanlonii

lgtm

This PR adds a `unstable_reactFragments?: Set<FragmentInstance>` property to DOM nodes that belong to a Fragment with a ref (top level host components). This allows you to access a FragmentInstance from a DOM node. This is flagged behind `enableFragmentRefsInstanceHandles`. The primary use case to unblock is reusing IntersectionObserver instances. A fairly common practice is to cache and reuse IntersectionObservers that share the same config, with a map of node->callbacks to run for each entry in the IO callback. Currently this is not possible with Fragment Ref `observeUsing` because the key in the cache would have to be the `FragmentInstance` and you can't find it without a handle from the node. This works now by accessing `entry.target.fragments`. This also opens up possibilities to use `FragmentInstance` operations in other places, such as events. We can do `event.target.unstable_reactFragments`, then access `fragmentInstance.getClientRects` for example. In a future PR, we can assign an event's `currentTarget` as the Fragment Ref for a more direct handle when the event has been dispatched by the Fragment itself. The first commit here implemented a handle only on observed elements. This is awkward because there isn't a good way to document or expose this temporary property. `element.fragments` is closer to what we would expect from a DOM API if a standard was implemented here. And by assigning it to all top-level nodes of a Fragment, it can be used beyond the cached IntersectionObserver callback. One tradeoff here is adding extra work during the creation of FragmentInstances as well as keeping track of adding/removing nodes. Previously we only track the Fiber on creation but here we add a traversal which could apply to a large set of top-level host children. The `element.unstable_reactFragments` Set can also be randomly ordered. DiffTrain build for [edd05f1](edd05f1)

This PR adds a `unstable_reactFragments?: Set<FragmentInstance>` property to DOM nodes that belong to a Fragment with a ref (top level host components). This allows you to access a FragmentInstance from a DOM node. This is flagged behind `enableFragmentRefsInstanceHandles`. The primary use case to unblock is reusing IntersectionObserver instances. A fairly common practice is to cache and reuse IntersectionObservers that share the same config, with a map of node->callbacks to run for each entry in the IO callback. Currently this is not possible with Fragment Ref `observeUsing` because the key in the cache would have to be the `FragmentInstance` and you can't find it without a handle from the node. This works now by accessing `entry.target.fragments`. This also opens up possibilities to use `FragmentInstance` operations in other places, such as events. We can do `event.target.unstable_reactFragments`, then access `fragmentInstance.getClientRects` for example. In a future PR, we can assign an event's `currentTarget` as the Fragment Ref for a more direct handle when the event has been dispatched by the Fragment itself. The first commit here implemented a handle only on observed elements. This is awkward because there isn't a good way to document or expose this temporary property. `element.fragments` is closer to what we would expect from a DOM API if a standard was implemented here. And by assigning it to all top-level nodes of a Fragment, it can be used beyond the cached IntersectionObserver callback. One tradeoff here is adding extra work during the creation of FragmentInstances as well as keeping track of adding/removing nodes. Previously we only track the Fiber on creation but here we add a traversal which could apply to a large set of top-level host children. The `element.unstable_reactFragments` Set can also be randomly ordered. DiffTrain build for [edd05f1](react@edd05f1)

Summary: Pull Request resolved: #55614 - enableFragmentRefsInstanceHandles - Enables a pointer on each element back to the FragmentInstances that control it. Needed to implement the common IntersectionObserver pattern of reusing IntersectionObservers across multiple callbacks. See more in react/react#34935 - enableFragmentRefsTextNodes - This should be a noop on RN as unlike dom, text nodes are considered host components and already handled. Text without a `<Text/>` wrapper throws an error. Changelog: [Internal] Reviewed By: christophpurrer Differential Revision: D93479122 fbshipit-source-id: 639369893c8aafc1d2bf0ffbdf4bf09fe6dca45c

#34935 Introduced `unstable_reactFragments` handle on DOM nodes to enable caching of Observers. This has been tested in production and is stable so it can be rolled out with the Fragment Refs feature.

#34935 Introduced `unstable_reactFragments` handle on DOM nodes to enable caching of Observers. This has been tested in production and is stable so it can be rolled out with the Fragment Refs feature. DiffTrain build for [9c0323e](9c0323e)

react#34935 Introduced `unstable_reactFragments` handle on DOM nodes to enable caching of Observers. This has been tested in production and is stable so it can be rolled out with the Fragment Refs feature. DiffTrain build for [9c0323e](react@9c0323e)

jackpope · 2025-10-21T21:37:53Z

This PR adds a unstable_reactFragments?: Set<FragmentInstance> property to DOM nodes that belong to a Fragment with a ref (top level host components). This allows you to access a FragmentInstance from a DOM node.

This is flagged behind enableFragmentRefsInstanceHandles.

The primary use case to unblock is reusing IntersectionObserver instances. A fairly common practice is to cache and reuse IntersectionObservers that share the same config, with a map of node->callbacks to run for each entry in the IO callback. Currently this is not possible with Fragment Ref observeUsing because the key in the cache would have to be the FragmentInstance and you can't find it without a handle from the node. This works now by accessing entry.target.fragments.

This also opens up possibilities to use FragmentInstance operations in other places, such as events. We can do event.target.unstable_reactFragments, then access fragmentInstance.getClientRects for example. In a future PR, we can assign an event's currentTarget as the Fragment Ref for a more direct handle when the event has been dispatched by the Fragment itself.

The first commit here implemented a handle only on observed elements. This is awkward because there isn't a good way to document or expose this temporary property. element.fragments is closer to what we would expect from a DOM API if a standard was implemented here. And by assigning it to all top-level nodes of a Fragment, it can be used beyond the cached IntersectionObserver callback.

One tradeoff here is adding extra work during the creation of FragmentInstances as well as keeping track of adding/removing nodes. Previously we only track the Fiber on creation but here we add a traversal which could apply to a large set of top-level host children. The element.unstable_reactFragments Set can also be randomly ordered.

react-sizebot · 2025-10-21T21:41:28Z

The size diff is too large to display in a single comment. The GitHub action for this pull request contains an artifact called 'sizebot-message.md' with the full message.

Generated by 🚫 dangerJS against 2d226ab

rickhanlonii · 2025-11-03T19:28:44Z

 };
 }

+function addFragmentHandleToFiber(


I'd gate inside these fns too

rickhanlonii

lgtm

This PR adds a `unstable_reactFragments?: Set<FragmentInstance>` property to DOM nodes that belong to a Fragment with a ref (top level host components). This allows you to access a FragmentInstance from a DOM node. This is flagged behind `enableFragmentRefsInstanceHandles`. The primary use case to unblock is reusing IntersectionObserver instances. A fairly common practice is to cache and reuse IntersectionObservers that share the same config, with a map of node->callbacks to run for each entry in the IO callback. Currently this is not possible with Fragment Ref `observeUsing` because the key in the cache would have to be the `FragmentInstance` and you can't find it without a handle from the node. This works now by accessing `entry.target.fragments`. This also opens up possibilities to use `FragmentInstance` operations in other places, such as events. We can do `event.target.unstable_reactFragments`, then access `fragmentInstance.getClientRects` for example. In a future PR, we can assign an event's `currentTarget` as the Fragment Ref for a more direct handle when the event has been dispatched by the Fragment itself. The first commit here implemented a handle only on observed elements. This is awkward because there isn't a good way to document or expose this temporary property. `element.fragments` is closer to what we would expect from a DOM API if a standard was implemented here. And by assigning it to all top-level nodes of a Fragment, it can be used beyond the cached IntersectionObserver callback. One tradeoff here is adding extra work during the creation of FragmentInstances as well as keeping track of adding/removing nodes. Previously we only track the Fiber on creation but here we add a traversal which could apply to a large set of top-level host children. The `element.unstable_reactFragments` Set can also be randomly ordered. DiffTrain build for [edd05f1](edd05f1)

This PR adds a `unstable_reactFragments?: Set<FragmentInstance>` property to DOM nodes that belong to a Fragment with a ref (top level host components). This allows you to access a FragmentInstance from a DOM node. This is flagged behind `enableFragmentRefsInstanceHandles`. The primary use case to unblock is reusing IntersectionObserver instances. A fairly common practice is to cache and reuse IntersectionObservers that share the same config, with a map of node->callbacks to run for each entry in the IO callback. Currently this is not possible with Fragment Ref `observeUsing` because the key in the cache would have to be the `FragmentInstance` and you can't find it without a handle from the node. This works now by accessing `entry.target.fragments`. This also opens up possibilities to use `FragmentInstance` operations in other places, such as events. We can do `event.target.unstable_reactFragments`, then access `fragmentInstance.getClientRects` for example. In a future PR, we can assign an event's `currentTarget` as the Fragment Ref for a more direct handle when the event has been dispatched by the Fragment itself. The first commit here implemented a handle only on observed elements. This is awkward because there isn't a good way to document or expose this temporary property. `element.fragments` is closer to what we would expect from a DOM API if a standard was implemented here. And by assigning it to all top-level nodes of a Fragment, it can be used beyond the cached IntersectionObserver callback. One tradeoff here is adding extra work during the creation of FragmentInstances as well as keeping track of adding/removing nodes. Previously we only track the Fiber on creation but here we add a traversal which could apply to a large set of top-level host children. The `element.unstable_reactFragments` Set can also be randomly ordered. DiffTrain build for [edd05f1](react@edd05f1)

Summary: Pull Request resolved: #55614 - enableFragmentRefsInstanceHandles - Enables a pointer on each element back to the FragmentInstances that control it. Needed to implement the common IntersectionObserver pattern of reusing IntersectionObservers across multiple callbacks. See more in react/react#34935 - enableFragmentRefsTextNodes - This should be a noop on RN as unlike dom, text nodes are considered host components and already handled. Text without a `<Text/>` wrapper throws an error. Changelog: [Internal] Reviewed By: christophpurrer Differential Revision: D93479122 fbshipit-source-id: 639369893c8aafc1d2bf0ffbdf4bf09fe6dca45c

#34935 Introduced `unstable_reactFragments` handle on DOM nodes to enable caching of Observers. This has been tested in production and is stable so it can be rolled out with the Fragment Refs feature.

#34935 Introduced `unstable_reactFragments` handle on DOM nodes to enable caching of Observers. This has been tested in production and is stable so it can be rolled out with the Fragment Refs feature. DiffTrain build for [9c0323e](9c0323e)

react#34935 Introduced `unstable_reactFragments` handle on DOM nodes to enable caching of Observers. This has been tested in production and is stable so it can be rolled out with the Fragment Refs feature. DiffTrain build for [9c0323e](react@9c0323e)

jackpope · 2025-10-21T21:37:53Z

This PR adds a unstable_reactFragments?: Set<FragmentInstance> property to DOM nodes that belong to a Fragment with a ref (top level host components). This allows you to access a FragmentInstance from a DOM node.

This is flagged behind enableFragmentRefsInstanceHandles.

The primary use case to unblock is reusing IntersectionObserver instances. A fairly common practice is to cache and reuse IntersectionObservers that share the same config, with a map of node->callbacks to run for each entry in the IO callback. Currently this is not possible with Fragment Ref observeUsing because the key in the cache would have to be the FragmentInstance and you can't find it without a handle from the node. This works now by accessing entry.target.fragments.

This also opens up possibilities to use FragmentInstance operations in other places, such as events. We can do event.target.unstable_reactFragments, then access fragmentInstance.getClientRects for example. In a future PR, we can assign an event's currentTarget as the Fragment Ref for a more direct handle when the event has been dispatched by the Fragment itself.

The first commit here implemented a handle only on observed elements. This is awkward because there isn't a good way to document or expose this temporary property. element.fragments is closer to what we would expect from a DOM API if a standard was implemented here. And by assigning it to all top-level nodes of a Fragment, it can be used beyond the cached IntersectionObserver callback.

One tradeoff here is adding extra work during the creation of FragmentInstances as well as keeping track of adding/removing nodes. Previously we only track the Fiber on creation but here we add a traversal which could apply to a large set of top-level host children. The element.unstable_reactFragments Set can also be randomly ordered.

react-sizebot · 2025-10-21T21:41:28Z

The size diff is too large to display in a single comment. The GitHub action for this pull request contains an artifact called 'sizebot-message.md' with the full message.

Generated by 🚫 dangerJS against 2d226ab

rickhanlonii · 2025-11-03T19:28:44Z

 };
 }

+function addFragmentHandleToFiber(


I'd gate inside these fns too

rickhanlonii

lgtm

This PR adds a `unstable_reactFragments?: Set<FragmentInstance>` property to DOM nodes that belong to a Fragment with a ref (top level host components). This allows you to access a FragmentInstance from a DOM node. This is flagged behind `enableFragmentRefsInstanceHandles`. The primary use case to unblock is reusing IntersectionObserver instances. A fairly common practice is to cache and reuse IntersectionObservers that share the same config, with a map of node->callbacks to run for each entry in the IO callback. Currently this is not possible with Fragment Ref `observeUsing` because the key in the cache would have to be the `FragmentInstance` and you can't find it without a handle from the node. This works now by accessing `entry.target.fragments`. This also opens up possibilities to use `FragmentInstance` operations in other places, such as events. We can do `event.target.unstable_reactFragments`, then access `fragmentInstance.getClientRects` for example. In a future PR, we can assign an event's `currentTarget` as the Fragment Ref for a more direct handle when the event has been dispatched by the Fragment itself. The first commit here implemented a handle only on observed elements. This is awkward because there isn't a good way to document or expose this temporary property. `element.fragments` is closer to what we would expect from a DOM API if a standard was implemented here. And by assigning it to all top-level nodes of a Fragment, it can be used beyond the cached IntersectionObserver callback. One tradeoff here is adding extra work during the creation of FragmentInstances as well as keeping track of adding/removing nodes. Previously we only track the Fiber on creation but here we add a traversal which could apply to a large set of top-level host children. The `element.unstable_reactFragments` Set can also be randomly ordered. DiffTrain build for [edd05f1](edd05f1)

This PR adds a `unstable_reactFragments?: Set<FragmentInstance>` property to DOM nodes that belong to a Fragment with a ref (top level host components). This allows you to access a FragmentInstance from a DOM node. This is flagged behind `enableFragmentRefsInstanceHandles`. The primary use case to unblock is reusing IntersectionObserver instances. A fairly common practice is to cache and reuse IntersectionObservers that share the same config, with a map of node->callbacks to run for each entry in the IO callback. Currently this is not possible with Fragment Ref `observeUsing` because the key in the cache would have to be the `FragmentInstance` and you can't find it without a handle from the node. This works now by accessing `entry.target.fragments`. This also opens up possibilities to use `FragmentInstance` operations in other places, such as events. We can do `event.target.unstable_reactFragments`, then access `fragmentInstance.getClientRects` for example. In a future PR, we can assign an event's `currentTarget` as the Fragment Ref for a more direct handle when the event has been dispatched by the Fragment itself. The first commit here implemented a handle only on observed elements. This is awkward because there isn't a good way to document or expose this temporary property. `element.fragments` is closer to what we would expect from a DOM API if a standard was implemented here. And by assigning it to all top-level nodes of a Fragment, it can be used beyond the cached IntersectionObserver callback. One tradeoff here is adding extra work during the creation of FragmentInstances as well as keeping track of adding/removing nodes. Previously we only track the Fiber on creation but here we add a traversal which could apply to a large set of top-level host children. The `element.unstable_reactFragments` Set can also be randomly ordered. DiffTrain build for [edd05f1](react@edd05f1)

Summary: Pull Request resolved: #55614 - enableFragmentRefsInstanceHandles - Enables a pointer on each element back to the FragmentInstances that control it. Needed to implement the common IntersectionObserver pattern of reusing IntersectionObservers across multiple callbacks. See more in react/react#34935 - enableFragmentRefsTextNodes - This should be a noop on RN as unlike dom, text nodes are considered host components and already handled. Text without a `<Text/>` wrapper throws an error. Changelog: [Internal] Reviewed By: christophpurrer Differential Revision: D93479122 fbshipit-source-id: 639369893c8aafc1d2bf0ffbdf4bf09fe6dca45c

#34935 Introduced `unstable_reactFragments` handle on DOM nodes to enable caching of Observers. This has been tested in production and is stable so it can be rolled out with the Fragment Refs feature.

#34935 Introduced `unstable_reactFragments` handle on DOM nodes to enable caching of Observers. This has been tested in production and is stable so it can be rolled out with the Fragment Refs feature. DiffTrain build for [9c0323e](9c0323e)

react#34935 Introduced `unstable_reactFragments` handle on DOM nodes to enable caching of Observers. This has been tested in production and is stable so it can be rolled out with the Fragment Refs feature. DiffTrain build for [9c0323e](react@9c0323e)

meta-claBot added the CLA Signed label Oct 21, 2025

Add observing fragment instance handles to elements
5d00603

jackpope force-pushed the fr-observing-handles branch from e9e40c3 to 5d00603Compare October 21, 2025 21:43

jackpope requested review from rickhanlonii and sebmarkbage October 21, 2025 21:51

Add observing fragment handles for fabric
d79367a

jackpope force-pushed the fr-observing-handles branch from c18af3d to f825e46Compare November 3, 2025 16:34

jackpope changed the title ~~Add observing fragment instance handles to elements~~Add fragment handles to children of FragmentInstances Nov 3, 2025

Add fragments property to all fragment child host nodes
8406f06

jackpope force-pushed the fr-observing-handles branch from f825e46 to 8406f06Compare November 3, 2025 16:49

Mark fragment handles unstable and add rollout flag
71f7ccc

jackpope force-pushed the fr-observing-handles branch from 7cd8c23 to 71f7cccCompare November 3, 2025 19:22

rickhanlonii reviewed Nov 3, 2025
View reviewed changes

rickhanlonii approved these changes Nov 3, 2025
View reviewed changes

Add additional flags
2d226ab

jackpope merged commit edd05f1 into react:mainNov 3, 2025
240 checks passed

nextjs-bot mentioned this pull request Nov 4, 2025
Upgrade React from 67f7d47a-20251103 to f646e8ff-20251104vercel/next.js#85772
Merged

jackpope mentioned this pull request Jan 27, 2026
Stabilize reactFragments host node handle #35642
Merged

jackpope mentioned this pull request Feb 18, 2026
Add host instance pointer and text node feature flags react/react-native#55614
Closed

rubennorte mentioned this pull request Jun 5, 2026
Upgrade React and renderers from 19.2.3 to 19.2.7 react/react-native#57089
Closed

meta-claBot added the CLA Signed label Oct 21, 2025

Add observing fragment instance handles to elements
5d00603

jackpope force-pushed the fr-observing-handles branch from e9e40c3 to 5d00603Compare October 21, 2025 21:43

jackpope requested review from rickhanlonii and sebmarkbage October 21, 2025 21:51

Add observing fragment handles for fabric
d79367a

jackpope force-pushed the fr-observing-handles branch from c18af3d to f825e46Compare November 3, 2025 16:34

jackpope changed the title ~~Add observing fragment instance handles to elements~~Add fragment handles to children of FragmentInstances Nov 3, 2025

Add fragments property to all fragment child host nodes
8406f06

jackpope force-pushed the fr-observing-handles branch from f825e46 to 8406f06Compare November 3, 2025 16:49

Mark fragment handles unstable and add rollout flag
71f7ccc

jackpope force-pushed the fr-observing-handles branch from 7cd8c23 to 71f7cccCompare November 3, 2025 19:22

rickhanlonii reviewed Nov 3, 2025
View reviewed changes

rickhanlonii approved these changes Nov 3, 2025
View reviewed changes

Add additional flags
2d226ab

jackpope merged commit edd05f1 into react:mainNov 3, 2025
240 checks passed

nextjs-bot mentioned this pull request Nov 4, 2025
Upgrade React from 67f7d47a-20251103 to f646e8ff-20251104vercel/next.js#85772
Merged

jackpope mentioned this pull request Jan 27, 2026
Stabilize reactFragments host node handle #35642
Merged

jackpope mentioned this pull request Feb 18, 2026
Add host instance pointer and text node feature flags react/react-native#55614
Closed

rubennorte mentioned this pull request Jun 5, 2026
Upgrade React and renderers from 19.2.3 to 19.2.7 react/react-native#57089
Closed

meta-claBot added the CLA Signed label Oct 21, 2025

Add observing fragment instance handles to elements
5d00603

jackpope force-pushed the fr-observing-handles branch from e9e40c3 to 5d00603Compare October 21, 2025 21:43

jackpope requested review from rickhanlonii and sebmarkbage October 21, 2025 21:51

Add observing fragment handles for fabric
d79367a

jackpope force-pushed the fr-observing-handles branch from c18af3d to f825e46Compare November 3, 2025 16:34

jackpope changed the title ~~Add observing fragment instance handles to elements~~Add fragment handles to children of FragmentInstances Nov 3, 2025

Add fragments property to all fragment child host nodes
8406f06

jackpope force-pushed the fr-observing-handles branch from f825e46 to 8406f06Compare November 3, 2025 16:49

Mark fragment handles unstable and add rollout flag
71f7ccc

jackpope force-pushed the fr-observing-handles branch from 7cd8c23 to 71f7cccCompare November 3, 2025 19:22

rickhanlonii reviewed Nov 3, 2025
View reviewed changes

rickhanlonii approved these changes Nov 3, 2025
View reviewed changes

Add additional flags
2d226ab

jackpope merged commit edd05f1 into react:mainNov 3, 2025
240 checks passed

nextjs-bot mentioned this pull request Nov 4, 2025
Upgrade React from 67f7d47a-20251103 to f646e8ff-20251104vercel/next.js#85772
Merged

jackpope mentioned this pull request Jan 27, 2026
Stabilize reactFragments host node handle #35642
Merged

jackpope mentioned this pull request Feb 18, 2026
Add host instance pointer and text node feature flags react/react-native#55614
Closed

rubennorte mentioned this pull request Jun 5, 2026
Upgrade React and renderers from 19.2.3 to 19.2.7 react/react-native#57089
Closed

meta-claBot added the CLA Signed label Oct 21, 2025

Add observing fragment instance handles to elements
5d00603

jackpope force-pushed the fr-observing-handles branch from e9e40c3 to 5d00603Compare October 21, 2025 21:43

jackpope requested review from rickhanlonii and sebmarkbage October 21, 2025 21:51

Add observing fragment handles for fabric
d79367a

jackpope force-pushed the fr-observing-handles branch from c18af3d to f825e46Compare November 3, 2025 16:34

jackpope changed the title ~~Add observing fragment instance handles to elements~~Add fragment handles to children of FragmentInstances Nov 3, 2025

Add fragments property to all fragment child host nodes
8406f06

jackpope force-pushed the fr-observing-handles branch from f825e46 to 8406f06Compare November 3, 2025 16:49

Mark fragment handles unstable and add rollout flag
71f7ccc

jackpope force-pushed the fr-observing-handles branch from 7cd8c23 to 71f7cccCompare November 3, 2025 19:22

rickhanlonii reviewed Nov 3, 2025
View reviewed changes

rickhanlonii approved these changes Nov 3, 2025
View reviewed changes

Add additional flags
2d226ab

jackpope merged commit edd05f1 into react:mainNov 3, 2025
240 checks passed

nextjs-bot mentioned this pull request Nov 4, 2025
Upgrade React from 67f7d47a-20251103 to f646e8ff-20251104vercel/next.js#85772
Merged

jackpope mentioned this pull request Jan 27, 2026
Stabilize reactFragments host node handle #35642
Merged

jackpope mentioned this pull request Feb 18, 2026
Add host instance pointer and text node feature flags react/react-native#55614
Closed

rubennorte mentioned this pull request Jun 5, 2026
Upgrade React and renderers from 19.2.3 to 19.2.7 react/react-native#57089
Closed

meta-claBot added the CLA Signed label Oct 21, 2025

Add observing fragment instance handles to elements
5d00603

jackpope force-pushed the fr-observing-handles branch from e9e40c3 to 5d00603Compare October 21, 2025 21:43

jackpope requested review from rickhanlonii and sebmarkbage October 21, 2025 21:51

Add observing fragment handles for fabric
d79367a

jackpope force-pushed the fr-observing-handles branch from c18af3d to f825e46Compare November 3, 2025 16:34

jackpope changed the title ~~Add observing fragment instance handles to elements~~Add fragment handles to children of FragmentInstances Nov 3, 2025

Add fragments property to all fragment child host nodes
8406f06

jackpope force-pushed the fr-observing-handles branch from f825e46 to 8406f06Compare November 3, 2025 16:49

Mark fragment handles unstable and add rollout flag
71f7ccc

jackpope force-pushed the fr-observing-handles branch from 7cd8c23 to 71f7cccCompare November 3, 2025 19:22

rickhanlonii reviewed Nov 3, 2025
View reviewed changes

rickhanlonii approved these changes Nov 3, 2025
View reviewed changes

Add additional flags
2d226ab

jackpope merged commit edd05f1 into react:mainNov 3, 2025
240 checks passed

nextjs-bot mentioned this pull request Nov 4, 2025
Upgrade React from 67f7d47a-20251103 to f646e8ff-20251104vercel/next.js#85772
Merged

jackpope mentioned this pull request Jan 27, 2026
Stabilize reactFragments host node handle #35642
Merged

jackpope mentioned this pull request Feb 18, 2026
Add host instance pointer and text node feature flags react/react-native#55614
Closed

rubennorte mentioned this pull request Jun 5, 2026
Upgrade React and renderers from 19.2.3 to 19.2.7 react/react-native#57089
Closed

meta-claBot added the CLA Signed label Oct 21, 2025

Add observing fragment instance handles to elements
5d00603

jackpope force-pushed the fr-observing-handles branch from e9e40c3 to 5d00603Compare October 21, 2025 21:43

jackpope requested review from rickhanlonii and sebmarkbage October 21, 2025 21:51

Add observing fragment handles for fabric
d79367a

jackpope force-pushed the fr-observing-handles branch from c18af3d to f825e46Compare November 3, 2025 16:34

jackpope changed the title ~~Add observing fragment instance handles to elements~~Add fragment handles to children of FragmentInstances Nov 3, 2025

Add fragments property to all fragment child host nodes
8406f06

jackpope force-pushed the fr-observing-handles branch from f825e46 to 8406f06Compare November 3, 2025 16:49

Mark fragment handles unstable and add rollout flag
71f7ccc

jackpope force-pushed the fr-observing-handles branch from 7cd8c23 to 71f7cccCompare November 3, 2025 19:22

rickhanlonii reviewed Nov 3, 2025
View reviewed changes

rickhanlonii approved these changes Nov 3, 2025
View reviewed changes

Add additional flags
2d226ab

jackpope merged commit edd05f1 into react:mainNov 3, 2025
240 checks passed

nextjs-bot mentioned this pull request Nov 4, 2025
Upgrade React from 67f7d47a-20251103 to f646e8ff-20251104vercel/next.js#85772
Merged

jackpope mentioned this pull request Jan 27, 2026
Stabilize reactFragments host node handle #35642
Merged

jackpope mentioned this pull request Feb 18, 2026
Add host instance pointer and text node feature flags react/react-native#55614
Closed

rubennorte mentioned this pull request Jun 5, 2026
Upgrade React and renderers from 19.2.3 to 19.2.7 react/react-native#57089
Closed

meta-claBot added the CLA Signed label Oct 21, 2025

Add observing fragment instance handles to elements
5d00603

jackpope force-pushed the fr-observing-handles branch from e9e40c3 to 5d00603Compare October 21, 2025 21:43

jackpope requested review from rickhanlonii and sebmarkbage October 21, 2025 21:51

Add observing fragment handles for fabric
d79367a

jackpope force-pushed the fr-observing-handles branch from c18af3d to f825e46Compare November 3, 2025 16:34

jackpope changed the title ~~Add observing fragment instance handles to elements~~Add fragment handles to children of FragmentInstances Nov 3, 2025

Add fragments property to all fragment child host nodes
8406f06

jackpope force-pushed the fr-observing-handles branch from f825e46 to 8406f06Compare November 3, 2025 16:49

Mark fragment handles unstable and add rollout flag
71f7ccc

jackpope force-pushed the fr-observing-handles branch from 7cd8c23 to 71f7cccCompare November 3, 2025 19:22

rickhanlonii reviewed Nov 3, 2025
View reviewed changes

rickhanlonii approved these changes Nov 3, 2025
View reviewed changes

Add additional flags
2d226ab

jackpope merged commit edd05f1 into react:mainNov 3, 2025
240 checks passed

nextjs-bot mentioned this pull request Nov 4, 2025
Upgrade React from 67f7d47a-20251103 to f646e8ff-20251104vercel/next.js#85772
Merged

jackpope mentioned this pull request Jan 27, 2026
Stabilize reactFragments host node handle #35642
Merged

jackpope mentioned this pull request Feb 18, 2026
Add host instance pointer and text node feature flags react/react-native#55614
Closed

rubennorte mentioned this pull request Jun 5, 2026
Upgrade React and renderers from 19.2.3 to 19.2.7 react/react-native#57089
Closed

meta-claBot added the CLA Signed label Oct 21, 2025

Add observing fragment instance handles to elements
5d00603

jackpope force-pushed the fr-observing-handles branch from e9e40c3 to 5d00603Compare October 21, 2025 21:43

jackpope requested review from rickhanlonii and sebmarkbage October 21, 2025 21:51

Add observing fragment handles for fabric
d79367a

jackpope force-pushed the fr-observing-handles branch from c18af3d to f825e46Compare November 3, 2025 16:34

jackpope changed the title ~~Add observing fragment instance handles to elements~~Add fragment handles to children of FragmentInstances Nov 3, 2025

Add fragments property to all fragment child host nodes
8406f06

jackpope force-pushed the fr-observing-handles branch from f825e46 to 8406f06Compare November 3, 2025 16:49

Mark fragment handles unstable and add rollout flag
71f7ccc

jackpope force-pushed the fr-observing-handles branch from 7cd8c23 to 71f7cccCompare November 3, 2025 19:22

rickhanlonii reviewed Nov 3, 2025
View reviewed changes

rickhanlonii approved these changes Nov 3, 2025
View reviewed changes

Add additional flags
2d226ab

jackpope merged commit edd05f1 into react:mainNov 3, 2025
240 checks passed

nextjs-bot mentioned this pull request Nov 4, 2025
Upgrade React from 67f7d47a-20251103 to f646e8ff-20251104vercel/next.js#85772
Merged

jackpope mentioned this pull request Jan 27, 2026
Stabilize reactFragments host node handle #35642
Merged

jackpope mentioned this pull request Feb 18, 2026
Add host instance pointer and text node feature flags react/react-native#55614
Closed

rubennorte mentioned this pull request Jun 5, 2026
Upgrade React and renderers from 19.2.3 to 19.2.7 react/react-native#57089
Closed

Uh oh!

Conversation

jackpope commented Oct 21, 2025• edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

react-sizebot commented Oct 21, 2025• edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

rickhanloniiNov 3, 2025

Choose a reason for hiding this comment

Uh oh!

rickhanlonii left a comment

Choose a reason for hiding this comment

Uh oh!

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

3 participants

Uh oh!

Conversation

jackpope commented Oct 21, 2025• edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

react-sizebot commented Oct 21, 2025• edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

rickhanloniiNov 3, 2025

Choose a reason for hiding this comment

Uh oh!

rickhanlonii left a comment

Choose a reason for hiding this comment

Uh oh!

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

3 participants

Uh oh!

Conversation

jackpope commented Oct 21, 2025• edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

react-sizebot commented Oct 21, 2025• edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

rickhanloniiNov 3, 2025

Choose a reason for hiding this comment

Uh oh!

rickhanlonii left a comment

Choose a reason for hiding this comment

Uh oh!

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

3 participants

Uh oh!

Conversation

jackpope commented Oct 21, 2025• edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

react-sizebot commented Oct 21, 2025• edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

rickhanloniiNov 3, 2025

Choose a reason for hiding this comment

Uh oh!

jackpope commented Oct 21, 2025•
edited
Loading

react-sizebot commented Oct 21, 2025•
edited
Loading

jackpope commented Oct 21, 2025•
edited
Loading

react-sizebot commented Oct 21, 2025•
edited
Loading

jackpope commented Oct 21, 2025•
edited
Loading

react-sizebot commented Oct 21, 2025•
edited
Loading

jackpope commented Oct 21, 2025•
edited
Loading

react-sizebot commented Oct 21, 2025•
edited
Loading

jackpope commented Oct 21, 2025•
edited
Loading

react-sizebot commented Oct 21, 2025•
edited
Loading

jackpope commented Oct 21, 2025•
edited
Loading

react-sizebot commented Oct 21, 2025•
edited
Loading