react-native-tvos 0.87.1-0 → 0.88.0-0rc2

package/ReactCommon/react/renderer/mounting/internal/ShadowViewNodePair.h

@@ -7,6 +7,8 @@
 
 #pragma once
 
+#include <react/cxxstableapi/FrameworksGuard.h>
+
 #include <react/renderer/core/ShadowNode.h>
 #include <react/renderer/graphics/Point.h>
 #include <react/renderer/mounting/ShadowView.h>

package/ReactCommon/react/renderer/mounting/internal/sliceChildShadowNodeViewPairs.h

@@ -7,6 +7,8 @@
 
 #pragma once
 
+#include <react/cxxstableapi/FrameworksGuard.h>
+
 #include <deque>
 
 #include "CullingContext.h"

package/ReactCommon/react/renderer/mounting/stubs/StubView.h

@@ -7,6 +7,8 @@
 
 #pragma once
 
+#include <react/cxxstableapi/FrameworksGuard.h>
+
 #include <memory>
 #include <vector>
 

package/ReactCommon/react/renderer/mounting/stubs/StubViewTree.h

@@ -7,6 +7,8 @@
 
 #pragma once
 
+#include <react/cxxstableapi/FrameworksGuard.h>
+
 #include <memory>
 #include <unordered_map>
 

package/ReactCommon/react/renderer/mounting/stubs/stubs.h

@@ -7,6 +7,8 @@
 
 #pragma once
 
+#include <react/cxxstableapi/FrameworksGuard.h>
+
 #include <react/renderer/core/ShadowNode.h>
 #include <react/renderer/mounting/stubs/StubView.h>
 #include <react/renderer/mounting/stubs/StubViewTree.h>

package/ReactCommon/react/renderer/mounting/tests/MountingTransactionTest.cpp

@@ -0,0 +1,123 @@
+/*
+ * 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.
+ */
+
+#include <gtest/gtest.h>
+
+#include <react/renderer/mounting/MountingTransaction.h>
+#include <react/renderer/mounting/ShadowView.h>
+#include <react/renderer/mounting/ShadowViewMutation.h>
+#include <react/renderer/telemetry/TransactionTelemetry.h>
+
+namespace facebook::react {
+
+namespace {
+
+ShadowView makeShadowView(Tag tag) {
+  ShadowView view;
+  view.tag = tag;
+  return view;
+}
+
+MountingTransaction makeTransaction(
+    SurfaceId surfaceId,
+    MountingTransaction::Number number,
+    const std::vector<Tag>& createTags,
+    int telemetryRevision = 0) {
+  ShadowViewMutationList mutations;
+  mutations.reserve(createTags.size());
+  for (auto tag : createTags) {
+    mutations.push_back(
+        ShadowViewMutation::CreateMutation(makeShadowView(tag)));
+  }
+  TransactionTelemetry telemetry;
+  telemetry.setRevisionNumber(telemetryRevision);
+  return MountingTransaction{
+      surfaceId, number, std::move(mutations), std::move(telemetry)};
+}
+
+} // namespace
+
+// Verifies that `mergeWith` concatenates mutations from the incoming
+// transaction after the existing ones, preserving relative order across both.
+// Catches regressions where the merged list is reversed, overwrites the
+// original, or drops mutations from either side.
+TEST(MountingTransactionTest, testMergeWithAppendsMutationsInOrder) {
+  auto transaction = makeTransaction(
+      /* surfaceId */ 1, /* number */ 1, /* tags */ {10, 11});
+  auto incoming = makeTransaction(
+      /* surfaceId */ 1, /* number */ 2, /* tags */ {20, 21, 22});
+
+  transaction.mergeWith(std::move(incoming));
+
+  const auto& merged = transaction.getMutations();
+  ASSERT_EQ(merged.size(), 5u);
+  EXPECT_EQ(merged[0].newChildShadowView.tag, 10);
+  EXPECT_EQ(merged[1].newChildShadowView.tag, 11);
+  EXPECT_EQ(merged[2].newChildShadowView.tag, 20);
+  EXPECT_EQ(merged[3].newChildShadowView.tag, 21);
+  EXPECT_EQ(merged[4].newChildShadowView.tag, 22);
+}
+
+// Verifies that `mergeWith` advances `number` to that of the incoming
+// transaction while leaving `surfaceId` untouched. Catches regressions where
+// the number is not updated or the surfaceId is accidentally overwritten.
+TEST(MountingTransactionTest, testMergeWithUpdatesNumberButPreservesSurfaceId) {
+  auto transaction = makeTransaction(
+      /* surfaceId */ 7, /* number */ 3, /* tags */ {100});
+  auto incoming = makeTransaction(
+      /* surfaceId */ 7, /* number */ 42, /* tags */ {200});
+
+  transaction.mergeWith(std::move(incoming));
+
+  EXPECT_EQ(transaction.getSurfaceId(), 7);
+  EXPECT_EQ(transaction.getNumber(), 42);
+}
+
+// Verifies that `mergeWith` replaces the existing telemetry with that of the
+// incoming transaction (per the documented "use the latest instance"
+// behavior). We use a distinguishing revision number so the assertion checks a
+// computed value rather than restating a source constant.
+TEST(MountingTransactionTest, testMergeWithAdoptsIncomingTelemetry) {
+  auto transaction = makeTransaction(
+      /* surfaceId */ 1,
+      /* number */ 1,
+      /* tags */ {},
+      /* telemetryRevision */ 5);
+  auto incoming = makeTransaction(
+      /* surfaceId */ 1,
+      /* number */ 2,
+      /* tags */ {},
+      /* telemetryRevision */ 99);
+
+  transaction.mergeWith(std::move(incoming));
+
+  EXPECT_EQ(transaction.getTelemetry().getRevisionNumber(), 99);
+}
+
+// Verifies that merging an empty incoming transaction is a no-op for the
+// mutation list — the existing mutations remain intact, just with the number
+// bumped. Guards against a naive `= std::move(other.mutations_)` implementation
+// that would clobber the original list.
+TEST(
+    MountingTransactionTest,
+    testMergeWithEmptyIncomingPreservesOriginalMutations) {
+  auto transaction = makeTransaction(
+      /* surfaceId */ 1, /* number */ 1, /* tags */ {10, 11, 12});
+  auto incoming = makeTransaction(
+      /* surfaceId */ 1, /* number */ 2, /* tags */ {});
+
+  transaction.mergeWith(std::move(incoming));
+
+  const auto& merged = transaction.getMutations();
+  ASSERT_EQ(merged.size(), 3u);
+  EXPECT_EQ(merged[0].newChildShadowView.tag, 10);
+  EXPECT_EQ(merged[1].newChildShadowView.tag, 11);
+  EXPECT_EQ(merged[2].newChildShadowView.tag, 12);
+  EXPECT_EQ(transaction.getNumber(), 2);
+}
+
+} // namespace facebook::react

package/ReactCommon/react/renderer/mounting/updateMountedFlag.cpp

@@ -38,7 +38,8 @@ void updateMountedFlag(
   // Runtime shadow node references are updated during the React revision
   // commits so that JS can access layout data from the merged tree.
   bool shouldUpdateRuntimeReference =
-      (commitSource == ShadowTreeCommitSource::React &&
+      ((commitSource == ShadowTreeCommitSource::React ||
+        commitSource == ShadowTreeCommitSource::AnimationEndSync) &&
        ReactNativeFeatureFlags::updateRuntimeShadowNodeReferencesOnCommit()) ||
       (ReactNativeFeatureFlags::
            updateRuntimeShadowNodeReferencesOnCommitThread() &&

package/ReactCommon/react/renderer/mounting/updateMountedFlag.h

@@ -7,6 +7,8 @@
 
 #pragma once
 
+#include <react/cxxstableapi/FrameworksGuard.h>
+
 #include <react/renderer/core/ShadowNode.h>
 #include <react/renderer/mounting/ShadowTree.h>
 

package/ReactCommon/react/renderer/observers/events/CMakeLists.txt

@@ -13,6 +13,7 @@ add_library(react_renderer_observers_events OBJECT ${react_renderer_observers_ev
 
 target_include_directories(react_renderer_observers_events PUBLIC ${REACT_COMMON_DIR})
 target_link_libraries(react_renderer_observers_events
+        react_cxxstableapi
         react_debug
         react_performance_timeline
         react_timing

package/ReactCommon/react/renderer/observers/events/EventPerformanceLogger.h

@@ -7,6 +7,8 @@
 
 #pragma once
 
+#include <react/cxxstableapi/PrivateGuard.h>
+
 #include <react/performance/timeline/PerformanceEntryReporter.h>
 #include <react/renderer/core/EventLogger.h>
 #include <react/renderer/runtimescheduler/RuntimeSchedulerEventTimingDelegate.h>

package/ReactCommon/react/renderer/observers/intersection/CMakeLists.txt

@@ -16,6 +16,7 @@ target_include_directories(react_renderer_observers_intersection PUBLIC ${REACT_
 target_link_libraries(react_renderer_observers_intersection
       react_cxxreact
       react_bridging
+      react_cxxstableapi
       react_debug
       react_renderer_core
       react_renderer_graphics

package/ReactCommon/react/renderer/observers/intersection/IntersectionObserver.h

@@ -7,6 +7,8 @@
 
 #pragma once
 
+#include <react/cxxstableapi/PrivateGuard.h>
+
 #include <react/renderer/components/root/RootShadowNode.h>
 #include <react/renderer/core/ShadowNodeFamily.h>
 #include <react/renderer/graphics/Float.h>

package/ReactCommon/react/renderer/observers/intersection/IntersectionObserverManager.h

@@ -7,6 +7,8 @@
 
 #pragma once
 
+#include <react/cxxstableapi/PrivateGuard.h>
+
 #include <react/renderer/core/ShadowNode.h>
 #include <react/renderer/graphics/Float.h>
 #include <react/renderer/runtimescheduler/RuntimeScheduler.h>

package/ReactCommon/react/renderer/observers/intersection/IntersectionObserverState.h

@@ -7,6 +7,8 @@
 
 #pragma once
 
+#include <react/cxxstableapi/PrivateGuard.h>
+
 #include <react/renderer/graphics/Float.h>
 #include <optional>
 

package/ReactCommon/react/renderer/observers/mutation/CMakeLists.txt

@@ -15,6 +15,7 @@ target_include_directories(react_renderer_observers_mutation PUBLIC ${REACT_COMM
 
 target_link_libraries(react_renderer_observers_mutation
       react_cxxreact
+      react_cxxstableapi
       react_renderer_core
       react_renderer_uimanager
       react_renderer_mounting

package/ReactCommon/react/renderer/observers/mutation/MutationObserver.h

@@ -7,6 +7,8 @@
 
 #pragma once
 
+#include <react/cxxstableapi/PrivateGuard.h>
+
 #include <react/renderer/components/root/RootShadowNode.h>
 #include <react/renderer/core/ShadowNode.h>
 #include <react/renderer/core/ShadowNodeFamily.h>

package/ReactCommon/react/renderer/observers/mutation/MutationObserverManager.h

@@ -7,6 +7,8 @@
 
 #pragma once
 
+#include <react/cxxstableapi/PrivateGuard.h>
+
 #include <react/renderer/core/ShadowNode.h>
 #include <react/renderer/mounting/ShadowTree.h>
 #include <react/renderer/uimanager/UIManager.h>

package/ReactCommon/react/renderer/observers/resize/CMakeLists.txt

@@ -0,0 +1,27 @@
+# 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.
+
+cmake_minimum_required(VERSION 3.13)
+set(CMAKE_VERBOSE_MAKEFILE on)
+
+include(${REACT_COMMON_DIR}/cmake-utils/react-native-flags.cmake)
+
+file(GLOB react_renderer_observers_resize_SRC CONFIGURE_DEPENDS *.cpp)
+add_library(react_renderer_observers_resize OBJECT ${react_renderer_observers_resize_SRC})
+
+target_include_directories(react_renderer_observers_resize PUBLIC ${REACT_COMMON_DIR})
+
+target_link_libraries(react_renderer_observers_resize
+      react_cxxreact
+      react_bridging
+      react_cxxstableapi
+      react_renderer_core
+      react_renderer_graphics
+      react_renderer_mounting
+      react_renderer_runtimescheduler
+      react_renderer_uimanager
+)
+target_compile_reactnative_options(react_renderer_observers_resize PRIVATE)
+target_compile_options(react_renderer_observers_resize PRIVATE -Wpedantic)

package/ReactCommon/react/renderer/observers/resize/ResizeObserver.cpp

@@ -0,0 +1,236 @@
+/*
+ * 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.
+ */
+
+#include "ResizeObserver.h"
+#include <react/debug/react_native_assert.h>
+#include <react/renderer/core/LayoutableShadowNode.h>
+#include <react/renderer/core/ShadowNode.h>
+#include <react/renderer/core/ShadowNodeTraits.h>
+#include <algorithm>
+#include <cmath>
+#include <utility>
+
+namespace facebook::react {
+
+namespace {
+
+const ShadowNode* FOLLY_NULLABLE
+getTargetShadowNode(const ShadowNodeFamily::AncestorList& ancestors) {
+  if (ancestors.empty()) {
+    return nullptr;
+  }
+
+  const auto& parentChildPair = ancestors.back();
+  return parentChildPair.first.get()
+      .getChildren()
+      .at(parentChildPair.second)
+      .get();
+}
+
+bool isHidden(const ShadowNode& shadowNode) {
+  // `display: 'none'` sets the Hidden trait when props commit, possibly before
+  // layout updates `displayType`.
+  if (shadowNode.getTraits().check(ShadowNodeTraits::Trait::Hidden)) {
+    return true;
+  }
+
+  if (const auto* layoutableShadowNode =
+          dynamic_cast<const LayoutableShadowNode*>(&shadowNode)) {
+    return layoutableShadowNode->getLayoutMetrics().displayType ==
+        DisplayType::None;
+  }
+
+  return false;
+}
+
+// Descendants of a `display: none` node are not laid out, so their own layout
+// metrics are not a size we can report.
+bool hasHiddenAncestor(const ShadowNodeFamily::AncestorList& ancestors) {
+  return std::any_of(
+      ancestors.begin(), ancestors.end(), [](const auto& parentChildPair) {
+        return isHidden(parentChildPair.first.get());
+      });
+}
+
+Size getObservedSize(
+    ResizeObserverBoxOptions boxOptions,
+    Size borderBoxSize,
+    Size contentBoxSize,
+    Size devicePixelContentBoxSize) {
+  if (boxOptions == ResizeObserverBoxOptions::ContentBox) {
+    return contentBoxSize;
+  }
+  if (boxOptions == ResizeObserverBoxOptions::DevicePixelContentBox) {
+    return devicePixelContentBoxSize;
+  }
+  return borderBoxSize;
+}
+
+ResizeObserverEntry makeResizeObserverEntry(
+    ResizeObserverObserverId resizeObserverId,
+    const ShadowNodeFamily::Shared& targetShadowNodeFamily,
+    Size borderBoxSize,
+    Size contentBoxSize,
+    Size devicePixelContentBoxSize,
+    Rect contentRect) {
+  return ResizeObserverEntry{
+      .resizeObserverId = resizeObserverId,
+      .shadowNodeFamily = targetShadowNodeFamily,
+      .contentRect = contentRect,
+      .borderBoxSize = borderBoxSize,
+      .contentBoxSize = contentBoxSize,
+      .devicePixelContentBoxSize = devicePixelContentBoxSize};
+}
+
+} // namespace
+
+ResizeObserver::ResizeObserver(
+    ResizeObserverObserverId resizeObserverId,
+    ShadowNodeFamily::Shared targetShadowNodeFamily,
+    ResizeObserverBoxOptions boxOptions,
+    uint64_t observationSequence)
+    : resizeObserverId_{resizeObserverId},
+      targetShadowNodeFamily_{std::move(targetShadowNodeFamily)},
+      boxOptions_{boxOptions},
+      observationSequence_{observationSequence} {}
+
+ResizeObservationResult ResizeObserver::computeActiveObservation(
+    const RootShadowNode& rootShadowNode) const {
+  auto ancestors = targetShadowNodeFamily_->getAncestors(rootShadowNode);
+  const auto* targetShadowNode = getTargetShadowNode(ancestors);
+
+  // Spec "calculate depth for node": number of nodes on the parent-traversal
+  // path from the target to the root (inclusive). `ancestors` excludes the
+  // target, so add one.
+  ResizeObservationResult result{};
+  result.targetDepth = ancestors.size() + 1;
+
+  if (targetShadowNode == nullptr) {
+    // Target left the tree. Per spec, removal fires one final 0x0 entry. Keep
+    // `lastReportedSize_` at 0x0 so we don't re-deliver, and mark detached to
+    // stop re-checking until it's reinserted (via the dirty-family path).
+    // Every box is 0x0, so the observed box is too, whichever was requested.
+    auto zeroSize = Size{.width = 0, .height = 0};
+    auto observedSize = zeroSize;
+
+    result.detached = true;
+
+    const auto alreadyDelivered = lastReportedSize_.has_value() &&
+        lastReportedSize_.value() == observedSize;
+    if (alreadyDelivered) {
+      return result;
+    }
+
+    result.observedSize = observedSize;
+    result.entry = makeResizeObserverEntry(
+        resizeObserverId_,
+        targetShadowNodeFamily_,
+        zeroSize,
+        zeroSize,
+        zeroSize,
+        Rect{.origin = {.x = 0, .y = 0}, .size = zeroSize});
+    return result;
+  }
+
+  const auto isInitialDelivery = !lastReportedSize_.has_value();
+
+  // Per spec, `display: none` reports zero-sized boxes. Use the Hidden trait
+  // instead of possibly-stale layout metrics and check ancestors.
+  if (isHidden(*targetShadowNode) || hasHiddenAncestor(ancestors)) {
+    auto zeroSize = Size{.width = 0, .height = 0};
+    auto zeroContentRect = Rect{.origin = {.x = 0, .y = 0}, .size = zeroSize};
+    auto observedSize = zeroSize;
+
+    // Exact float comparison is intentional: each pass recomputes the size from
+    // the same layout metrics, so an unchanged box compares equal with no
+    // accumulated error.
+    if (!isInitialDelivery && lastReportedSize_.value() == observedSize) {
+      return result;
+    }
+
+    result.observedSize = observedSize;
+    result.entry = makeResizeObserverEntry(
+        resizeObserverId_,
+        targetShadowNodeFamily_,
+        zeroSize,
+        zeroSize,
+        zeroSize,
+        zeroContentRect);
+    return result;
+  }
+
+  // Only the target's size matters here, never its position, so we read its own
+  // layout metrics instead of computing viewport-relative ones.
+  const auto* layoutableShadowNode =
+      dynamic_cast<const LayoutableShadowNode*>(targetShadowNode);
+
+  // Not layoutable, so there is no size to report. Observed targets are always
+  // host components, so this is not expected to happen.
+  if (layoutableShadowNode == nullptr) {
+    return result;
+  }
+
+  auto layoutMetrics = layoutableShadowNode->getLayoutMetrics();
+  auto borderBoxSize = layoutMetrics.frame.size;
+
+  // RN's `contentInsets` is border + padding per side, matching the Web
+  // content-box. Clamp to zero: a frame can be smaller than its insets, but a
+  // content box is never negative.
+  auto contentFrame = layoutMetrics.getContentFrame();
+  auto contentBoxSize = Size{
+      .width = std::max(Float{0}, contentFrame.size.width),
+      .height = std::max(Float{0}, contentFrame.size.height)};
+
+  // Per spec, `contentRect`'s origin is the offset of the content box from
+  // the padding box (i.e. the paddings only, excluding borders).
+  // https://w3c.github.io/csswg-drafts/resize-observer/#dom-resizeobserverentry-contentrect
+  auto contentRect = Rect{
+      .origin =
+          {.x = layoutMetrics.contentInsets.left -
+               layoutMetrics.borderWidth.left,
+           .y =
+               layoutMetrics.contentInsets.top - layoutMetrics.borderWidth.top},
+      .size = contentBoxSize};
+
+  // Per spec the device-pixel-content-box holds integers. Round each axis
+  // (best-effort: we have no pixel-snapped origin or sibling to align to).
+  auto devicePixelContentBoxSize = Size{
+      .width =
+          std::round(contentBoxSize.width * layoutMetrics.pointScaleFactor),
+      .height =
+          std::round(contentBoxSize.height * layoutMetrics.pointScaleFactor)};
+
+  auto observedSize = getObservedSize(
+      boxOptions_, borderBoxSize, contentBoxSize, devicePixelContentBoxSize);
+
+  // Skip when the observed box is unchanged. The first delivery always runs
+  // (including 0x0 content-box), matching browser behavior on `observe()`.
+  if (!isInitialDelivery && lastReportedSize_.value() == observedSize) {
+    return result;
+  }
+
+  result.observedSize = observedSize;
+  result.entry = makeResizeObserverEntry(
+      resizeObserverId_,
+      targetShadowNodeFamily_,
+      borderBoxSize,
+      contentBoxSize,
+      devicePixelContentBoxSize,
+      contentRect);
+  return result;
+}
+
+void ResizeObserver::markAsReported(const ResizeObservationResult& result) {
+  // Only broadcast results carry a size to report; marking anything else
+  // would regress `lastReportedSize_` to 0x0.
+  react_native_assert(result.entry.has_value());
+
+  lastReportedSize_ = result.observedSize;
+  detached_ = result.detached;
+}
+
+} // namespace facebook::react

package/ReactCommon/react/renderer/observers/resize/ResizeObserver.h

@@ -0,0 +1,114 @@
+/*
+ * 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.
+ */
+
+#pragma once
+
+#include <react/cxxstableapi/PrivateGuard.h>
+
+#include <react/renderer/components/root/RootShadowNode.h>
+#include <react/renderer/core/ShadowNodeFamily.h>
+#include <react/renderer/graphics/Rect.h>
+#include <react/renderer/graphics/Size.h>
+#include <cstdint>
+#include <optional>
+
+namespace facebook::react {
+
+using ResizeObserverObserverId = int32_t;
+
+// Corresponds to the `box` option of `ResizeObserver#observe`.
+// https://w3c.github.io/csswg-drafts/resize-observer/#resize-observer-box-options
+enum class ResizeObserverBoxOptions { ContentBox, BorderBox, DevicePixelContentBox };
+
+struct ResizeObserverEntry {
+  ResizeObserverObserverId resizeObserverId;
+  ShadowNodeFamily::Shared shadowNodeFamily;
+  Rect contentRect;
+  Size borderBoxSize;
+  Size contentBoxSize;
+  Size devicePixelContentBoxSize;
+};
+
+struct ResizeObservationResult {
+  // Set when the observed box changed (i.e. the observation is active).
+  std::optional<ResizeObserverEntry> entry;
+  // The size to store in `lastReportedSize_` when this is broadcast.
+  Size observedSize{};
+  // Spec "calculate depth for node": nodes on the path from target to root.
+  size_t targetDepth{0};
+  // Whether the target was found outside the tree.
+  bool detached{false};
+};
+
+class ResizeObserver {
+ public:
+  ResizeObserver(
+      ResizeObserverObserverId resizeObserverId,
+      ShadowNodeFamily::Shared targetShadowNodeFamily,
+      ResizeObserverBoxOptions boxOptions,
+      uint64_t observationSequence);
+
+  // Computes whether the observation is active and builds a pending entry. It
+  // must not change any state that decides future deliveries: a skipped
+  // observation has to stay active for a later round.
+  ResizeObservationResult computeActiveObservation(const RootShadowNode &rootShadowNode) const;
+
+  // Applies the state the spec assigns during broadcast.
+  void markAsReported(const ResizeObservationResult &result);
+
+  // Records detachment for a pass that produced no entry. Without this, a
+  // target whose final 0x0 was suppressed as a duplicate would never be marked
+  // detached, and so would be recomputed on every later commit.
+  void updateDetachedState(bool detached)
+  {
+    detached_ = detached;
+  }
+
+  ResizeObserverObserverId getResizeObserverId() const
+  {
+    return resizeObserverId_;
+  }
+
+  ShadowNodeFamily::Shared getTargetShadowNodeFamily() const
+  {
+    return targetShadowNodeFamily_;
+  }
+
+  // Monotonic order of `observe()` registration for this observation.
+  uint64_t getObservationSequence() const
+  {
+    return observationSequence_;
+  }
+
+  // Still awaiting its first delivery (just registered, or target removed).
+  bool needsInitialDeliveryCheck() const
+  {
+    return !lastReportedSize_.has_value();
+  }
+
+  // Whether the target left the tree and its final 0x0 entry was already
+  // delivered; such observations stay quiet until reinserted (dirty path).
+  bool hasDeliveredDetachedState() const
+  {
+    return detached_ && lastReportedSize_.has_value();
+  }
+
+ private:
+  ResizeObserverObserverId resizeObserverId_;
+  ShadowNodeFamily::Shared targetShadowNodeFamily_;
+  ResizeObserverBoxOptions boxOptions_;
+  uint64_t observationSequence_;
+
+  // Last delivered observed-box size; empty until the first entry.
+  std::optional<Size> lastReportedSize_;
+
+  // True once the detached target's final 0x0 entry was delivered; cleared as
+  // soon as the target is found attached again.
+  bool detached_{false};
+};
+
+} // namespace facebook::react