react-dom 19.2.0-canary-462d08f9-20250517 → 19.2.0-canary-23884812-20250520

package/cjs/react-dom-server.bun.development.js

@@ -29,8 +29,15 @@ var React = require("react"),
   REACT_LEGACY_HIDDEN_TYPE = Symbol.for("react.legacy_hidden"),
   REACT_MEMO_CACHE_SENTINEL = Symbol.for("react.memo_cache_sentinel"),
   REACT_VIEW_TRANSITION_TYPE = Symbol.for("react.view_transition"),
-  MAYBE_ITERATOR_SYMBOL = Symbol.iterator,
-  isArrayImpl = Array.isArray,
+  MAYBE_ITERATOR_SYMBOL = Symbol.iterator;
+function getIteratorFn(maybeIterable) {
+  if (null === maybeIterable || "object" !== typeof maybeIterable) return null;
+  maybeIterable =
+    (MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL]) ||
+    maybeIterable["@@iterator"];
+  return "function" === typeof maybeIterable ? maybeIterable : null;
+}
+var isArrayImpl = Array.isArray,
   jsxPropsParents = new WeakMap(),
   jsxChildrenParents = new WeakMap();
 function objectName(object) {
@@ -1747,6 +1754,9 @@ function pushTextInstance(target, text, renderState, textEmbedded) {
   target.push(escapeTextForBrowser(text));
   return !0;
 }
+function pushSegmentFinale(target, renderState, lastPushedText, textEmbedded) {
+  lastPushedText && textEmbedded && target.push("\x3c!-- --\x3e");
+}
 var styleNameCache = new Map(),
   styleAttributeStart = ' style="',
   styleAssign = ":",
@@ -4607,6 +4617,10 @@ function hoistStyleQueueDependency(styleQueue) {
 function hoistStylesheetDependency(stylesheet) {
   this.stylesheets.add(stylesheet);
 }
+function hoistHoistables(parentState, childState) {
+  childState.styles.forEach(hoistStyleQueueDependency, parentState);
+  childState.stylesheets.forEach(hoistStylesheetDependency, parentState);
+}
 var bind = Function.prototype.bind,
   REACT_CLIENT_REFERENCE = Symbol.for("react.client.reference");
 function getComponentNameFromType(type) {
@@ -5582,6 +5596,7 @@ var CLIENT_RENDERED = 4,
   PENDING = 0,
   COMPLETED = 1,
   FLUSHED = 2,
+  ABORTED = 3,
   POSTPONED = 5,
   CLOSED = 14;
 function defaultErrorHandler(error) {
@@ -5711,6 +5726,7 @@ function createRequest(
     null,
     emptyTreeContext,
     null,
+    null,
     emptyContextObject,
     null
   );
@@ -5733,15 +5749,17 @@ function pingTask(request, task) {
 }
 function createSuspenseBoundary(
   request,
+  row,
   fallbackAbortableTasks,
   contentPreamble,
   fallbackPreamble
 ) {
-  return {
+  fallbackAbortableTasks = {
     status: PENDING,
     rootSegmentID: -1,
     parentFlushed: !1,
     pendingTasks: 0,
+    row: row,
     completedSegments: [],
     byteSize: 0,
     fallbackAbortableTasks: fallbackAbortableTasks,
@@ -5756,6 +5774,17 @@ function createSuspenseBoundary(
     errorStack: null,
     errorComponentStack: null
   };
+  null !== row &&
+    (row.pendingTasks++,
+    (contentPreamble = row.boundaries),
+    null !== contentPreamble &&
+      (request.allPendingTasks++,
+      fallbackAbortableTasks.pendingTasks++,
+      contentPreamble.push(fallbackAbortableTasks)),
+    (request = row.inheritedHoistables),
+    null !== request &&
+      hoistHoistables(fallbackAbortableTasks.contentState, request));
+  return fallbackAbortableTasks;
 }
 function createRenderTask(
   request,
@@ -5771,6 +5800,7 @@ function createRenderTask(
   formatContext,
   context,
   treeContext,
+  row,
   componentStack,
   legacyContext,
   debugTask
@@ -5779,6 +5809,7 @@ function createRenderTask(
   null === blockedBoundary
     ? request.pendingRootTasks++
     : blockedBoundary.pendingTasks++;
+  null !== row && row.pendingTasks++;
   var task = {
     replay: null,
     node: node,
@@ -5795,6 +5826,7 @@ function createRenderTask(
     formatContext: formatContext,
     context: context,
     treeContext: treeContext,
+    row: row,
     componentStack: componentStack,
     thenableState: thenableState
   };
@@ -5815,6 +5847,7 @@ function createReplayTask(
   formatContext,
   context,
   treeContext,
+  row,
   componentStack,
   legacyContext,
   debugTask
@@ -5823,6 +5856,7 @@ function createReplayTask(
   null === blockedBoundary
     ? request.pendingRootTasks++
     : blockedBoundary.pendingTasks++;
+  null !== row && row.pendingTasks++;
   replay.pendingTasks++;
   var task = {
     replay: replay,
@@ -5840,6 +5874,7 @@ function createReplayTask(
     formatContext: formatContext,
     context: context,
     treeContext: treeContext,
+    row: row,
     componentStack: componentStack,
     thenableState: thenableState
   };
@@ -6023,6 +6058,173 @@ function fatalError(request, error, errorInfo, debugTask) {
     ? ((request.status = CLOSED), closeWithError(request.destination, error))
     : ((request.status = 13), (request.fatalError = error));
 }
+function finishSuspenseListRow(request, row) {
+  unblockSuspenseListRow(request, row.next, row.hoistables);
+}
+function unblockSuspenseListRow(request, unblockedRow, inheritedHoistables) {
+  for (; null !== unblockedRow; ) {
+    null !== inheritedHoistables &&
+      (hoistHoistables(unblockedRow.hoistables, inheritedHoistables),
+      (unblockedRow.inheritedHoistables = inheritedHoistables));
+    var unblockedBoundaries = unblockedRow.boundaries;
+    if (null !== unblockedBoundaries) {
+      unblockedRow.boundaries = null;
+      for (var i = 0; i < unblockedBoundaries.length; i++) {
+        var unblockedBoundary = unblockedBoundaries[i];
+        null !== inheritedHoistables &&
+          hoistHoistables(unblockedBoundary.contentState, inheritedHoistables);
+        finishedTask(request, unblockedBoundary, null, null);
+      }
+    }
+    unblockedRow.pendingTasks--;
+    if (0 < unblockedRow.pendingTasks) break;
+    inheritedHoistables = unblockedRow.hoistables;
+    unblockedRow = unblockedRow.next;
+  }
+}
+function tryToResolveTogetherRow(request, togetherRow) {
+  var boundaries = togetherRow.boundaries;
+  if (null !== boundaries && togetherRow.pendingTasks === boundaries.length) {
+    for (var allCompleteAndInlinable = !0, i = 0; i < boundaries.length; i++) {
+      var rowBoundary = boundaries[i];
+      if (
+        1 !== rowBoundary.pendingTasks ||
+        rowBoundary.parentFlushed ||
+        500 < rowBoundary.byteSize
+      ) {
+        allCompleteAndInlinable = !1;
+        break;
+      }
+    }
+    allCompleteAndInlinable &&
+      unblockSuspenseListRow(request, togetherRow, togetherRow.hoistables);
+  }
+}
+function createSuspenseListRow(previousRow) {
+  var newRow = {
+    pendingTasks: 1,
+    boundaries: null,
+    hoistables: createHoistableState(),
+    inheritedHoistables: null,
+    together: !1,
+    next: null
+  };
+  null !== previousRow &&
+    0 < previousRow.pendingTasks &&
+    (newRow.pendingTasks++,
+    (newRow.boundaries = []),
+    (previousRow.next = newRow));
+  return newRow;
+}
+function renderSuspenseListRows(request, task, keyPath, rows, revealOrder) {
+  var prevKeyPath = task.keyPath,
+    prevTreeContext = task.treeContext,
+    prevRow = task.row,
+    previousComponentStack = task.componentStack;
+  var previousDebugTask = task.debugTask;
+  pushServerComponentStack(task, task.node.props.children._debugInfo);
+  task.keyPath = keyPath;
+  keyPath = rows.length;
+  var previousSuspenseListRow = null;
+  if (null !== task.replay) {
+    var resumeSlots = task.replay.slots;
+    if (null !== resumeSlots && "object" === typeof resumeSlots)
+      for (var n = 0; n < keyPath; n++) {
+        var i = "backwards" !== revealOrder ? n : keyPath - 1 - n,
+          node = rows[i];
+        task.row = previousSuspenseListRow = createSuspenseListRow(
+          previousSuspenseListRow
+        );
+        task.treeContext = pushTreeContext(prevTreeContext, keyPath, i);
+        var resumeSegmentID = resumeSlots[i];
+        "number" === typeof resumeSegmentID
+          ? (resumeNode(request, task, resumeSegmentID, node, i),
+            delete resumeSlots[i])
+          : renderNode(request, task, node, i);
+        0 === --previousSuspenseListRow.pendingTasks &&
+          finishSuspenseListRow(request, previousSuspenseListRow);
+      }
+    else
+      for (resumeSlots = 0; resumeSlots < keyPath; resumeSlots++)
+        (n =
+          "backwards" !== revealOrder
+            ? resumeSlots
+            : keyPath - 1 - resumeSlots),
+          (i = rows[n]),
+          warnForMissingKey(request, task, i),
+          (task.row = previousSuspenseListRow =
+            createSuspenseListRow(previousSuspenseListRow)),
+          (task.treeContext = pushTreeContext(prevTreeContext, keyPath, n)),
+          renderNode(request, task, i, n),
+          0 === --previousSuspenseListRow.pendingTasks &&
+            finishSuspenseListRow(request, previousSuspenseListRow);
+  } else if ("backwards" !== revealOrder)
+    for (revealOrder = 0; revealOrder < keyPath; revealOrder++)
+      (resumeSlots = rows[revealOrder]),
+        warnForMissingKey(request, task, resumeSlots),
+        (task.row = previousSuspenseListRow =
+          createSuspenseListRow(previousSuspenseListRow)),
+        (task.treeContext = pushTreeContext(
+          prevTreeContext,
+          keyPath,
+          revealOrder
+        )),
+        renderNode(request, task, resumeSlots, revealOrder),
+        0 === --previousSuspenseListRow.pendingTasks &&
+          finishSuspenseListRow(request, previousSuspenseListRow);
+  else {
+    revealOrder = task.blockedSegment;
+    resumeSlots = revealOrder.children.length;
+    n = revealOrder.chunks.length;
+    for (i = keyPath - 1; 0 <= i; i--) {
+      node = rows[i];
+      task.row = previousSuspenseListRow = createSuspenseListRow(
+        previousSuspenseListRow
+      );
+      task.treeContext = pushTreeContext(prevTreeContext, keyPath, i);
+      resumeSegmentID = createPendingSegment(
+        request,
+        n,
+        null,
+        task.formatContext,
+        0 === i ? revealOrder.lastPushedText : !0,
+        !0
+      );
+      revealOrder.children.splice(resumeSlots, 0, resumeSegmentID);
+      task.blockedSegment = resumeSegmentID;
+      warnForMissingKey(request, task, node);
+      try {
+        renderNode(request, task, node, i),
+          pushSegmentFinale(
+            resumeSegmentID.chunks,
+            request.renderState,
+            resumeSegmentID.lastPushedText,
+            resumeSegmentID.textEmbedded
+          ),
+          (resumeSegmentID.status = COMPLETED),
+          finishedSegment(request, task.blockedBoundary, resumeSegmentID),
+          0 === --previousSuspenseListRow.pendingTasks &&
+            finishSuspenseListRow(request, previousSuspenseListRow);
+      } catch (thrownValue) {
+        throw (
+          ((resumeSegmentID.status = 12 === request.status ? ABORTED : 4),
+          thrownValue)
+        );
+      }
+    }
+    task.blockedSegment = revealOrder;
+    revealOrder.lastPushedText = !1;
+  }
+  null !== prevRow &&
+    null !== previousSuspenseListRow &&
+    0 < previousSuspenseListRow.pendingTasks &&
+    (prevRow.pendingTasks++, (previousSuspenseListRow.next = prevRow));
+  task.treeContext = prevTreeContext;
+  task.row = prevRow;
+  task.keyPath = prevKeyPath;
+  task.componentStack = previousComponentStack;
+  task.debugTask = previousDebugTask;
+}
 function renderWithHooks(request, task, keyPath, Component, props, secondArg) {
   var prevThenableState = task.thenableState;
   task.thenableState = null;
@@ -6528,7 +6730,7 @@ function renderElement(request, task, keyPath, type, props, ref) {
       );
       segment.lastPushedText = !1;
       var _prevContext2 = task.formatContext,
-        _prevKeyPath2 = task.keyPath;
+        _prevKeyPath3 = task.keyPath;
       task.keyPath = keyPath;
       if (
         (task.formatContext = getChildFormatContext(_prevContext2, type, props))
@@ -6557,6 +6759,7 @@ function renderElement(request, task, keyPath, type, props, ref) {
           task.formatContext,
           task.context,
           task.treeContext,
+          task.row,
           task.componentStack,
           emptyContextObject,
           task.debugTask
@@ -6565,7 +6768,7 @@ function renderElement(request, task, keyPath, type, props, ref) {
         request.pingedTasks.push(preambleTask);
       } else renderNode(request, task, _children, -1);
       task.formatContext = _prevContext2;
-      task.keyPath = _prevKeyPath2;
+      task.keyPath = _prevKeyPath3;
       a: {
         var target = segment.chunks,
           resumableState = request.resumableState;
@@ -6631,19 +6834,79 @@ function renderElement(request, task, keyPath, type, props, ref) {
         } else if ("hidden" !== props.mode) {
           segment$jscomp$0.chunks.push("\x3c!--&--\x3e");
           segment$jscomp$0.lastPushedText = !1;
-          var _prevKeyPath3 = task.keyPath;
+          var _prevKeyPath4 = task.keyPath;
           task.keyPath = keyPath;
           renderNode(request, task, props.children, -1);
-          task.keyPath = _prevKeyPath3;
+          task.keyPath = _prevKeyPath4;
           segment$jscomp$0.chunks.push("\x3c!--/&--\x3e");
           segment$jscomp$0.lastPushedText = !1;
         }
         return;
       case REACT_SUSPENSE_LIST_TYPE:
-        var _prevKeyPath4 = task.keyPath;
-        task.keyPath = keyPath;
-        renderNodeDestructive(request, task, props.children, -1);
-        task.keyPath = _prevKeyPath4;
+        a: {
+          var children$jscomp$0 = props.children,
+            revealOrder = props.revealOrder;
+          if ("forwards" === revealOrder || "backwards" === revealOrder) {
+            if (isArrayImpl(children$jscomp$0)) {
+              renderSuspenseListRows(
+                request,
+                task,
+                keyPath,
+                children$jscomp$0,
+                revealOrder
+              );
+              break a;
+            }
+            var iteratorFn = getIteratorFn(children$jscomp$0);
+            if (iteratorFn) {
+              var iterator = iteratorFn.call(children$jscomp$0);
+              if (iterator) {
+                validateIterable(
+                  task,
+                  children$jscomp$0,
+                  -1,
+                  iterator,
+                  iteratorFn
+                );
+                var step = iterator.next();
+                if (!step.done) {
+                  var rows = [];
+                  do rows.push(step.value), (step = iterator.next());
+                  while (!step.done);
+                  renderSuspenseListRows(
+                    request,
+                    task,
+                    keyPath,
+                    children$jscomp$0,
+                    revealOrder
+                  );
+                }
+                break a;
+              }
+            }
+          }
+          if ("together" === revealOrder) {
+            var _prevKeyPath2 = task.keyPath,
+              prevRow = task.row,
+              newRow = (task.row = createSuspenseListRow(null));
+            newRow.boundaries = [];
+            newRow.together = !0;
+            task.keyPath = keyPath;
+            renderNodeDestructive(request, task, children$jscomp$0, -1);
+            0 === --newRow.pendingTasks &&
+              finishSuspenseListRow(request, newRow);
+            task.keyPath = _prevKeyPath2;
+            task.row = prevRow;
+            null !== prevRow &&
+              0 < newRow.pendingTasks &&
+              (prevRow.pendingTasks++, (newRow.next = prevRow));
+          } else {
+            var prevKeyPath$jscomp$3 = task.keyPath;
+            task.keyPath = keyPath;
+            renderNodeDestructive(request, task, children$jscomp$0, -1);
+            task.keyPath = prevKeyPath$jscomp$3;
+          }
+        }
         return;
       case REACT_VIEW_TRANSITION_TYPE:
       case REACT_SCOPE_TYPE:
@@ -6651,21 +6914,26 @@ function renderElement(request, task, keyPath, type, props, ref) {
       case REACT_SUSPENSE_TYPE:
         a: if (null !== task.replay) {
           var _prevKeyPath = task.keyPath,
-            _prevContext = task.formatContext;
+            _prevContext = task.formatContext,
+            _prevRow = task.row;
           task.keyPath = keyPath;
           task.formatContext = getSuspenseContentFormatContext(
             request.resumableState,
             _prevContext
           );
+          task.row = null;
           var _content = props.children;
           try {
             renderNode(request, task, _content, -1);
           } finally {
-            (task.keyPath = _prevKeyPath), (task.formatContext = _prevContext);
+            (task.keyPath = _prevKeyPath),
+              (task.formatContext = _prevContext),
+              (task.row = _prevRow);
           }
         } else {
-          var prevKeyPath$jscomp$3 = task.keyPath,
+          var prevKeyPath$jscomp$4 = task.keyPath,
             prevContext$jscomp$0 = task.formatContext,
+            prevRow$jscomp$0 = task.row,
             parentBoundary = task.blockedBoundary,
             parentPreamble = task.blockedPreamble,
             parentHoistableState = task.hoistableState,
@@ -6677,11 +6945,18 @@ function renderElement(request, task, keyPath, type, props, ref) {
             task.formatContext.insertionMode < HTML_MODE
               ? createSuspenseBoundary(
                   request,
+                  task.row,
                   fallbackAbortSet,
                   createPreambleState(),
                   createPreambleState()
                 )
-              : createSuspenseBoundary(request, fallbackAbortSet, null, null);
+              : createSuspenseBoundary(
+                  request,
+                  task.row,
+                  fallbackAbortSet,
+                  null,
+                  null
+                );
           null !== request.trackedPostpones &&
             (newBoundary.trackedContentKeyPath = keyPath);
           var boundarySegment = createPendingSegment(
@@ -6726,20 +7001,23 @@ function renderElement(request, task, keyPath, type, props, ref) {
             boundarySegment.status = 6;
             try {
               renderNode(request, task, fallback, -1),
-                boundarySegment.lastPushedText &&
-                  boundarySegment.textEmbedded &&
-                  boundarySegment.chunks.push("\x3c!-- --\x3e"),
+                pushSegmentFinale(
+                  boundarySegment.chunks,
+                  request.renderState,
+                  boundarySegment.lastPushedText,
+                  boundarySegment.textEmbedded
+                ),
                 (boundarySegment.status = COMPLETED),
                 finishedSegment(request, parentBoundary, boundarySegment);
             } catch (thrownValue) {
               throw (
-                ((boundarySegment.status = 12 === request.status ? 3 : 4),
+                ((boundarySegment.status = 12 === request.status ? ABORTED : 4),
                 thrownValue)
               );
             } finally {
               (task.blockedSegment = parentSegment),
                 (task.blockedPreamble = parentPreamble),
-                (task.keyPath = prevKeyPath$jscomp$3),
+                (task.keyPath = prevKeyPath$jscomp$4),
                 (task.formatContext = prevContext$jscomp$0);
             }
             var suspendedPrimaryTask = createRenderTask(
@@ -6759,6 +7037,7 @@ function renderElement(request, task, keyPath, type, props, ref) {
               ),
               task.context,
               task.treeContext,
+              null,
               task.componentStack,
               emptyContextObject,
               task.debugTask
@@ -6775,30 +7054,43 @@ function renderElement(request, task, keyPath, type, props, ref) {
               request.resumableState,
               prevContext$jscomp$0
             );
+            task.row = null;
             contentRootSegment.status = 6;
             try {
               if (
                 (renderNode(request, task, content, -1),
-                contentRootSegment.lastPushedText &&
-                  contentRootSegment.textEmbedded &&
-                  contentRootSegment.chunks.push("\x3c!-- --\x3e"),
+                pushSegmentFinale(
+                  contentRootSegment.chunks,
+                  request.renderState,
+                  contentRootSegment.lastPushedText,
+                  contentRootSegment.textEmbedded
+                ),
                 (contentRootSegment.status = COMPLETED),
                 finishedSegment(request, newBoundary, contentRootSegment),
                 queueCompletedSegment(newBoundary, contentRootSegment),
                 0 === newBoundary.pendingTasks &&
-                  newBoundary.status === PENDING &&
-                  ((newBoundary.status = COMPLETED),
-                  !(500 < newBoundary.byteSize)))
+                  newBoundary.status === PENDING)
               ) {
-                0 === request.pendingRootTasks &&
-                  task.blockedPreamble &&
-                  preparePreamble(request);
-                break a;
-              }
+                if (
+                  ((newBoundary.status = COMPLETED),
+                  !(500 < newBoundary.byteSize))
+                ) {
+                  null !== prevRow$jscomp$0 &&
+                    0 === --prevRow$jscomp$0.pendingTasks &&
+                    finishSuspenseListRow(request, prevRow$jscomp$0);
+                  0 === request.pendingRootTasks &&
+                    task.blockedPreamble &&
+                    preparePreamble(request);
+                  break a;
+                }
+              } else
+                null !== prevRow$jscomp$0 &&
+                  prevRow$jscomp$0.together &&
+                  tryToResolveTogetherRow(request, prevRow$jscomp$0);
             } catch (thrownValue$2) {
               newBoundary.status = CLIENT_RENDERED;
               if (12 === request.status) {
-                contentRootSegment.status = 3;
+                contentRootSegment.status = ABORTED;
                 var error = request.fatalError;
               } else (contentRootSegment.status = 4), (error = thrownValue$2);
               var thrownInfo = getThrownInfo(task.componentStack);
@@ -6821,8 +7113,9 @@ function renderElement(request, task, keyPath, type, props, ref) {
                 (task.blockedPreamble = parentPreamble),
                 (task.hoistableState = parentHoistableState),
                 (task.blockedSegment = parentSegment),
-                (task.keyPath = prevKeyPath$jscomp$3),
-                (task.formatContext = prevContext$jscomp$0);
+                (task.keyPath = prevKeyPath$jscomp$4),
+                (task.formatContext = prevContext$jscomp$0),
+                (task.row = prevRow$jscomp$0);
             }
             var suspendedFallbackTask = createRenderTask(
               request,
@@ -6841,6 +7134,7 @@ function renderElement(request, task, keyPath, type, props, ref) {
               ),
               task.context,
               task.treeContext,
+              task.row,
               task.componentStack,
               emptyContextObject,
               task.debugTask
@@ -6859,7 +7153,7 @@ function renderElement(request, task, keyPath, type, props, ref) {
             for (var key in props)
               "ref" !== key && (propsWithoutRef[key] = props[key]);
           } else propsWithoutRef = props;
-          var children$jscomp$0 = renderWithHooks(
+          var children$jscomp$1 = renderWithHooks(
             request,
             task,
             keyPath,
@@ -6871,7 +7165,7 @@ function renderElement(request, task, keyPath, type, props, ref) {
             request,
             task,
             keyPath,
-            children$jscomp$0,
+            children$jscomp$1,
             0 !== localIdCounter,
             actionStateCounter,
             actionStateMatchingIndex
@@ -6883,9 +7177,9 @@ function renderElement(request, task, keyPath, type, props, ref) {
         case REACT_PROVIDER_TYPE:
         case REACT_CONTEXT_TYPE:
           var value$jscomp$0 = props.value,
-            children$jscomp$1 = props.children;
+            children$jscomp$2 = props.children;
           var prevSnapshot = task.context;
-          var prevKeyPath$jscomp$4 = task.keyPath;
+          var prevKeyPath$jscomp$5 = task.keyPath;
           var prevValue = type._currentValue;
           type._currentValue = value$jscomp$0;
           void 0 !== type._currentRenderer &&
@@ -6906,7 +7200,7 @@ function renderElement(request, task, keyPath, type, props, ref) {
           currentActiveSnapshot = newNode;
           task.context = newNode;
           task.keyPath = keyPath;
-          renderNodeDestructive(request, task, children$jscomp$1, -1);
+          renderNodeDestructive(request, task, children$jscomp$2, -1);
           var prevSnapshot$jscomp$0 = currentActiveSnapshot;
           if (null === prevSnapshot$jscomp$0)
             throw Error(
@@ -6928,7 +7222,7 @@ function renderElement(request, task, keyPath, type, props, ref) {
           var JSCompiler_inline_result$jscomp$0 = (currentActiveSnapshot =
             prevSnapshot$jscomp$0.parent);
           task.context = JSCompiler_inline_result$jscomp$0;
-          task.keyPath = prevKeyPath$jscomp$4;
+          task.keyPath = prevKeyPath$jscomp$5;
           prevSnapshot !== task.context &&
             console.error(
               "Popping the context provider did not return back to the original snapshot. This is a bug in React."
@@ -6942,10 +7236,10 @@ function renderElement(request, task, keyPath, type, props, ref) {
               "A context consumer was rendered with multiple children, or a child that isn't a function. A context consumer expects a single child that is a function. If you did pass a function, make sure there is no trailing or leading whitespace around it."
             );
           var newChildren = render(context$jscomp$0._currentValue),
-            prevKeyPath$jscomp$5 = task.keyPath;
+            prevKeyPath$jscomp$6 = task.keyPath;
           task.keyPath = keyPath;
           renderNodeDestructive(request, task, newChildren, -1);
-          task.keyPath = prevKeyPath$jscomp$5;
+          task.keyPath = prevKeyPath$jscomp$6;
           return;
         case REACT_LAZY_TYPE:
           var Component = callLazyInitInDEV(type);
@@ -7074,6 +7368,7 @@ function replayElement(
           node = null === node[4] ? null : node[4][3];
           var prevKeyPath = task.keyPath,
             prevContext = task.formatContext,
+            prevRow = task.row,
             previousReplaySet = task.replay,
             parentBoundary = task.blockedBoundary,
             parentHoistableState = task.hoistableState,
@@ -7084,11 +7379,18 @@ function replayElement(
             task.formatContext.insertionMode < HTML_MODE
               ? createSuspenseBoundary(
                   request,
+                  task.row,
                   fallbackAbortSet,
                   createPreambleState(),
                   createPreambleState()
                 )
-              : createSuspenseBoundary(request, fallbackAbortSet, null, null);
+              : createSuspenseBoundary(
+                  request,
+                  task.row,
+                  fallbackAbortSet,
+                  null,
+                  null
+                );
           props.parentFlushed = !0;
           props.rootSegmentID = name;
           task.blockedBoundary = props;
@@ -7098,6 +7400,7 @@ function replayElement(
             request.resumableState,
             prevContext
           );
+          task.row = null;
           task.replay = { nodes: type, slots: ref, pendingTasks: 1 };
           try {
             renderNode(request, task, content, -1);
@@ -7128,7 +7431,8 @@ function replayElement(
               (task.hoistableState = parentHoistableState),
               (task.replay = previousReplaySet),
               (task.keyPath = prevKeyPath),
-              (task.formatContext = prevContext);
+              (task.formatContext = prevContext),
+              (task.row = prevRow);
           }
           props = createReplayTask(
             request,
@@ -7146,6 +7450,7 @@ function replayElement(
             ),
             task.context,
             task.treeContext,
+            task.row,
             task.componentStack,
             emptyContextObject,
             task.debugTask
@@ -7159,6 +7464,29 @@ function replayElement(
     }
   }
 }
+function validateIterable(task, iterable, childIndex, iterator, iteratorFn) {
+  if (iterator === iterable) {
+    if (
+      -1 !== childIndex ||
+      null === task.componentStack ||
+      "function" !== typeof task.componentStack.type ||
+      "[object GeneratorFunction]" !==
+        Object.prototype.toString.call(task.componentStack.type) ||
+      "[object Generator]" !== Object.prototype.toString.call(iterator)
+    )
+      didWarnAboutGenerators ||
+        console.error(
+          "Using Iterators as children is unsupported and will likely yield unexpected results because enumerating a generator mutates it. You may convert it to an array with `Array.from()` or the `[...spread]` operator before rendering. You can also use an Iterable that can iterate multiple times over the same items."
+        ),
+        (didWarnAboutGenerators = !0);
+  } else
+    iterable.entries !== iteratorFn ||
+      didWarnAboutMaps ||
+      (console.error(
+        "Using Maps as children is not supported. Use an array of keyed ReactElements instead."
+      ),
+      (didWarnAboutMaps = !0));
+}
 function renderNodeDestructive(request, task, node, childIndex) {
   null !== task.replay && "number" === typeof task.replay.slots
     ? resumeNode(request, task, task.replay.slots, node, childIndex)
@@ -7235,52 +7563,27 @@ function retryNode(request, task) {
             "Portals are not currently supported by the server renderer. Render them conditionally so that they only appear on the client render."
           );
         case REACT_LAZY_TYPE:
-          node = callLazyInitInDEV(node);
+          type = callLazyInitInDEV(node);
           if (12 === request.status) throw null;
-          renderNodeDestructive(request, task, node, childIndex);
+          renderNodeDestructive(request, task, type, childIndex);
           return;
       }
       if (isArrayImpl(node)) {
         renderChildrenArray(request, task, node, childIndex);
         return;
       }
-      null === node || "object" !== typeof node
-        ? (key = null)
-        : ((type =
-            (MAYBE_ITERATOR_SYMBOL && node[MAYBE_ITERATOR_SYMBOL]) ||
-            node["@@iterator"]),
-          (key = "function" === typeof type ? type : null));
-      if (key && (type = key.call(node))) {
-        if (type === node) {
-          if (
-            -1 !== childIndex ||
-            null === task.componentStack ||
-            "function" !== typeof task.componentStack.type ||
-            "[object GeneratorFunction]" !==
-              Object.prototype.toString.call(task.componentStack.type) ||
-            "[object Generator]" !== Object.prototype.toString.call(type)
-          )
-            didWarnAboutGenerators ||
-              console.error(
-                "Using Iterators as children is unsupported and will likely yield unexpected results because enumerating a generator mutates it. You may convert it to an array with `Array.from()` or the `[...spread]` operator before rendering. You can also use an Iterable that can iterate multiple times over the same items."
-              ),
-              (didWarnAboutGenerators = !0);
-        } else
-          node.entries !== key ||
-            didWarnAboutMaps ||
-            (console.error(
-              "Using Maps as children is not supported. Use an array of keyed ReactElements instead."
-            ),
-            (didWarnAboutMaps = !0));
-        node = type.next();
-        if (!node.done) {
-          key = [];
-          do key.push(node.value), (node = type.next());
-          while (!node.done);
-          renderChildrenArray(request, task, key, childIndex);
+      if ((key = getIteratorFn(node)))
+        if ((type = key.call(node))) {
+          validateIterable(task, node, childIndex, type, key);
+          node = type.next();
+          if (!node.done) {
+            key = [];
+            do key.push(node.value), (node = type.next());
+            while (!node.done);
+            renderChildrenArray(request, task, key, childIndex);
+          }
+          return;
         }
-        return;
-      }
       if ("function" === typeof node.then)
         return (
           (task.thenableState = null),
@@ -7334,6 +7637,67 @@ function retryNode(request, task) {
             ));
   }
 }
+function warnForMissingKey(request, task, child) {
+  if (
+    null !== child &&
+    "object" === typeof child &&
+    (child.$$typeof === REACT_ELEMENT_TYPE ||
+      child.$$typeof === REACT_PORTAL_TYPE) &&
+    child._store &&
+    ((!child._store.validated && null == child.key) ||
+      2 === child._store.validated)
+  ) {
+    if ("object" !== typeof child._store)
+      throw Error(
+        "React Component in warnForMissingKey should have a _store. This error is likely caused by a bug in React. Please file an issue."
+      );
+    child._store.validated = 1;
+    var didWarnForKey = request.didWarnForKey;
+    null == didWarnForKey &&
+      (didWarnForKey = request.didWarnForKey = new WeakSet());
+    request = task.componentStack;
+    if (null !== request && !didWarnForKey.has(request)) {
+      didWarnForKey.add(request);
+      var componentName = getComponentNameFromType(child.type);
+      didWarnForKey = child._owner;
+      var parentOwner = request.owner;
+      request = "";
+      if (parentOwner && "undefined" !== typeof parentOwner.type) {
+        var name = getComponentNameFromType(parentOwner.type);
+        name && (request = "\n\nCheck the render method of `" + name + "`.");
+      }
+      request ||
+        (componentName &&
+          (request =
+            "\n\nCheck the top-level render call using <" +
+            componentName +
+            ">."));
+      componentName = "";
+      null != didWarnForKey &&
+        parentOwner !== didWarnForKey &&
+        ((parentOwner = null),
+        "undefined" !== typeof didWarnForKey.type
+          ? (parentOwner = getComponentNameFromType(didWarnForKey.type))
+          : "string" === typeof didWarnForKey.name &&
+            (parentOwner = didWarnForKey.name),
+        parentOwner &&
+          (componentName = " It was passed a child from " + parentOwner + "."));
+      didWarnForKey = task.componentStack;
+      task.componentStack = {
+        parent: task.componentStack,
+        type: child.type,
+        owner: child._owner,
+        stack: child._debugStack
+      };
+      console.error(
+        'Each child in a list should have a unique "key" prop.%s%s See https://react.dev/link/warning-keys for more information.',
+        request,
+        componentName
+      );
+      task.componentStack = didWarnForKey;
+    }
+  }
+}
 function renderChildrenArray(request, task, children, childIndex) {
   var prevKeyPath = task.keyPath,
     previousComponentStack = task.componentStack;
@@ -7420,75 +7784,11 @@ function renderChildrenArray(request, task, children, childIndex) {
     task.debugTask = previousDebugTask;
     return;
   }
-  for (j = 0; j < replayNodes; j++) {
-    childIndex = children[j];
-    resumeSlots = request;
-    node = task;
-    error = childIndex;
-    if (
-      null !== error &&
-      "object" === typeof error &&
-      (error.$$typeof === REACT_ELEMENT_TYPE ||
-        error.$$typeof === REACT_PORTAL_TYPE) &&
-      error._store &&
-      ((!error._store.validated && null == error.key) ||
-        2 === error._store.validated)
-    ) {
-      if ("object" !== typeof error._store)
-        throw Error(
-          "React Component in warnForMissingKey should have a _store. This error is likely caused by a bug in React. Please file an issue."
-        );
-      error._store.validated = 1;
-      thrownInfo = resumeSlots.didWarnForKey;
-      null == thrownInfo &&
-        (thrownInfo = resumeSlots.didWarnForKey = new WeakSet());
-      resumeSlots = node.componentStack;
-      if (null !== resumeSlots && !thrownInfo.has(resumeSlots)) {
-        thrownInfo.add(resumeSlots);
-        var componentName = getComponentNameFromType(error.type);
-        thrownInfo = error._owner;
-        var parentOwner = resumeSlots.owner;
-        resumeSlots = "";
-        if (parentOwner && "undefined" !== typeof parentOwner.type) {
-          var name = getComponentNameFromType(parentOwner.type);
-          name &&
-            (resumeSlots = "\n\nCheck the render method of `" + name + "`.");
-        }
-        resumeSlots ||
-          (componentName &&
-            (resumeSlots =
-              "\n\nCheck the top-level render call using <" +
-              componentName +
-              ">."));
-        componentName = "";
-        null != thrownInfo &&
-          parentOwner !== thrownInfo &&
-          ((parentOwner = null),
-          "undefined" !== typeof thrownInfo.type
-            ? (parentOwner = getComponentNameFromType(thrownInfo.type))
-            : "string" === typeof thrownInfo.name &&
-              (parentOwner = thrownInfo.name),
-          parentOwner &&
-            (componentName =
-              " It was passed a child from " + parentOwner + "."));
-        thrownInfo = node.componentStack;
-        node.componentStack = {
-          parent: node.componentStack,
-          type: error.type,
-          owner: error._owner,
-          stack: error._debugStack
-        };
-        console.error(
-          'Each child in a list should have a unique "key" prop.%s%s See https://react.dev/link/warning-keys for more information.',
-          resumeSlots,
-          componentName
-        );
-        node.componentStack = thrownInfo;
-      }
-    }
-    task.treeContext = pushTreeContext(replay, replayNodes, j);
-    renderNode(request, task, childIndex, j);
-  }
+  for (j = 0; j < replayNodes; j++)
+    (childIndex = children[j]),
+      warnForMissingKey(request, task, childIndex),
+      (task.treeContext = pushTreeContext(replay, replayNodes, j)),
+      renderNode(request, task, childIndex, j);
   task.treeContext = replay;
   task.keyPath = prevKeyPath;
   task.componentStack = previousComponentStack;
@@ -7517,6 +7817,7 @@ function spawnNewSuspendedReplayTask(request, task, thenableState) {
     task.formatContext,
     task.context,
     task.treeContext,
+    task.row,
     task.componentStack,
     emptyContextObject,
     task.debugTask
@@ -7548,6 +7849,7 @@ function spawnNewSuspendedRenderTask(request, task, thenableState) {
     task.formatContext,
     task.context,
     task.treeContext,
+    task.row,
     task.componentStack,
     emptyContextObject,
     task.debugTask
@@ -7654,9 +7956,11 @@ function renderNode(request, task, node, childIndex) {
   throw node;
 }
 function abortTaskSoft(task) {
-  var boundary = task.blockedBoundary;
-  task = task.blockedSegment;
-  null !== task && ((task.status = 3), finishedTask(this, boundary, task));
+  var boundary = task.blockedBoundary,
+    segment = task.blockedSegment;
+  null !== segment &&
+    ((segment.status = ABORTED),
+    finishedTask(this, boundary, task.row, segment));
 }
 function abortRemainingReplayNodes(
   request$jscomp$0,
@@ -7690,6 +7994,7 @@ function abortRemainingReplayNodes(
         wasAborted = aborted,
         resumedBoundary = createSuspenseBoundary(
           request,
+          null,
           new Set(),
           null,
           null
@@ -7733,7 +8038,7 @@ function abortTask(task, request, error) {
     segment = task.blockedSegment;
   if (null !== segment) {
     if (6 === segment.status) return;
-    segment.status = 3;
+    segment.status = ABORTED;
   }
   segment = getThrownInfo(task.componentStack);
   if (null === boundary) {
@@ -7745,36 +8050,44 @@ function abortTask(task, request, error) {
         return;
       }
       boundary.pendingTasks--;
-      0 === boundary.pendingTasks &&
-        0 < boundary.nodes.length &&
-        ((task = logRecoverableError(request, error, segment, null)),
+      if (0 === boundary.pendingTasks && 0 < boundary.nodes.length) {
+        var errorDigest = logRecoverableError(request, error, segment, null);
         abortRemainingReplayNodes(
           request,
           null,
           boundary.nodes,
           boundary.slots,
           error,
-          task,
+          errorDigest,
           segment,
           !0
-        ));
+        );
+      }
       request.pendingRootTasks--;
       0 === request.pendingRootTasks && completeShell(request);
     }
   } else
-    boundary.pendingTasks--,
-      boundary.status !== CLIENT_RENDERED &&
-        ((boundary.status = CLIENT_RENDERED),
-        (task = logRecoverableError(request, error, segment, null)),
-        (boundary.status = CLIENT_RENDERED),
-        encodeErrorForBoundary(boundary, task, error, segment, !0),
-        untrackBoundary(request, boundary),
-        boundary.parentFlushed &&
-          request.clientRenderedBoundaries.push(boundary)),
+    boundary.status !== CLIENT_RENDERED &&
+      ((boundary.status = CLIENT_RENDERED),
+      (errorDigest = logRecoverableError(request, error, segment, null)),
+      (boundary.status = CLIENT_RENDERED),
+      encodeErrorForBoundary(boundary, errorDigest, error, segment, !0),
+      untrackBoundary(request, boundary),
+      boundary.parentFlushed &&
+        request.clientRenderedBoundaries.push(boundary)),
+      boundary.pendingTasks--,
+      (segment = boundary.row),
+      null !== segment &&
+        0 === --segment.pendingTasks &&
+        finishSuspenseListRow(request, segment),
       boundary.fallbackAbortableTasks.forEach(function (fallbackTask) {
         return abortTask(fallbackTask, request, error);
       }),
       boundary.fallbackAbortableTasks.clear();
+  task = task.row;
+  null !== task &&
+    0 === --task.pendingTasks &&
+    finishSuspenseListRow(request, task);
   request.allPendingTasks--;
   0 === request.allPendingTasks && completeAll(request);
 }
@@ -7882,7 +8195,11 @@ function finishedSegment(request, boundary, segment) {
       : (boundary.byteSize += segmentByteSize);
   }
 }
-function finishedTask(request, boundary, segment) {
+function finishedTask(request, boundary, row, segment) {
+  null !== row &&
+    (0 === --row.pendingTasks
+      ? finishSuspenseListRow(request, row)
+      : row.together && tryToResolveTogetherRow(request, row));
   request.allPendingTasks--;
   if (null === boundary) {
     if (null !== segment && segment.parentFlushed) {
@@ -7906,23 +8223,33 @@ function finishedTask(request, boundary, segment) {
             boundary.parentFlushed &&
               request.completedBoundaries.push(boundary),
             boundary.status === COMPLETED &&
-              (500 < boundary.byteSize ||
+              ((row = boundary.row),
+              null !== row &&
+                hoistHoistables(row.hoistables, boundary.contentState),
+              500 < boundary.byteSize ||
                 (boundary.fallbackAbortableTasks.forEach(
                   abortTaskSoft,
                   request
                 ),
-                boundary.fallbackAbortableTasks.clear()),
+                boundary.fallbackAbortableTasks.clear(),
+                null !== row &&
+                  0 === --row.pendingTasks &&
+                  finishSuspenseListRow(request, row)),
               0 === request.pendingRootTasks &&
                 null === request.trackedPostpones &&
                 null !== boundary.contentPreamble &&
                 preparePreamble(request)))
-          : null !== segment &&
-            segment.parentFlushed &&
-            segment.status === COMPLETED &&
-            (queueCompletedSegment(boundary, segment),
-            1 === boundary.completedSegments.length &&
-              boundary.parentFlushed &&
-              request.partialBoundaries.push(boundary)));
+          : (null !== segment &&
+              segment.parentFlushed &&
+              segment.status === COMPLETED &&
+              (queueCompletedSegment(boundary, segment),
+              1 === boundary.completedSegments.length &&
+                boundary.parentFlushed &&
+                request.partialBoundaries.push(boundary)),
+            (boundary = boundary.row),
+            null !== boundary &&
+              boundary.together &&
+              tryToResolveTogetherRow(request, boundary)));
   0 === request.allPendingTasks && completeAll(request);
 }
 function performWork(request$jscomp$2) {
@@ -7972,7 +8299,12 @@ function performWork(request$jscomp$2) {
                 );
               request.replay.pendingTasks--;
               request.abortSet.delete(request);
-              finishedTask(request$jscomp$0, request.blockedBoundary, null);
+              finishedTask(
+                request$jscomp$0,
+                request.blockedBoundary,
+                request.row,
+                null
+              );
             } catch (thrownValue) {
               resetHooksState();
               var x =
@@ -8042,9 +8374,12 @@ function performWork(request$jscomp$2) {
             chunkLength = request$jscomp$1.chunks.length;
           try {
             retryNode(request, errorDigest),
-              request$jscomp$1.lastPushedText &&
-                request$jscomp$1.textEmbedded &&
-                request$jscomp$1.chunks.push("\x3c!-- --\x3e"),
+              pushSegmentFinale(
+                request$jscomp$1.chunks,
+                request.renderState,
+                request$jscomp$1.lastPushedText,
+                request$jscomp$1.textEmbedded
+              ),
               errorDigest.abortSet.delete(errorDigest),
               (request$jscomp$1.status = COMPLETED),
               finishedSegment(
@@ -8055,6 +8390,7 @@ function performWork(request$jscomp$2) {
               finishedTask(
                 request,
                 errorDigest.blockedBoundary,
+                errorDigest.row,
                 request$jscomp$1
               );
           } catch (thrownValue) {
@@ -8083,33 +8419,44 @@ function performWork(request$jscomp$2) {
               errorDigest.abortSet.delete(errorDigest);
               request$jscomp$1.status = 4;
               var boundary$jscomp$0 = errorDigest.blockedBoundary,
+                row = errorDigest.row,
                 debugTask = errorDigest.debugTask;
+              null !== row &&
+                0 === --row.pendingTasks &&
+                finishSuspenseListRow(request, row);
+              request.allPendingTasks--;
               prevTaskInDEV = logRecoverableError(
                 request,
                 x$jscomp$0,
                 errorInfo$jscomp$1,
                 debugTask
               );
-              null === boundary$jscomp$0
-                ? fatalError(request, x$jscomp$0, errorInfo$jscomp$1, debugTask)
-                : (boundary$jscomp$0.pendingTasks--,
-                  boundary$jscomp$0.status !== CLIENT_RENDERED &&
-                    ((boundary$jscomp$0.status = CLIENT_RENDERED),
-                    encodeErrorForBoundary(
-                      boundary$jscomp$0,
-                      prevTaskInDEV,
-                      x$jscomp$0,
-                      errorInfo$jscomp$1,
-                      !1
-                    ),
-                    untrackBoundary(request, boundary$jscomp$0),
-                    boundary$jscomp$0.parentFlushed &&
-                      request.clientRenderedBoundaries.push(boundary$jscomp$0),
-                    0 === request.pendingRootTasks &&
-                      null === request.trackedPostpones &&
-                      null !== boundary$jscomp$0.contentPreamble &&
-                      preparePreamble(request)));
-              request.allPendingTasks--;
+              if (null === boundary$jscomp$0)
+                fatalError(request, x$jscomp$0, errorInfo$jscomp$1, debugTask);
+              else if (
+                (boundary$jscomp$0.pendingTasks--,
+                boundary$jscomp$0.status !== CLIENT_RENDERED)
+              ) {
+                boundary$jscomp$0.status = CLIENT_RENDERED;
+                encodeErrorForBoundary(
+                  boundary$jscomp$0,
+                  prevTaskInDEV,
+                  x$jscomp$0,
+                  errorInfo$jscomp$1,
+                  !1
+                );
+                untrackBoundary(request, boundary$jscomp$0);
+                var boundaryRow = boundary$jscomp$0.row;
+                null !== boundaryRow &&
+                  0 === --boundaryRow.pendingTasks &&
+                  finishSuspenseListRow(request, boundaryRow);
+                boundary$jscomp$0.parentFlushed &&
+                  request.clientRenderedBoundaries.push(boundary$jscomp$0);
+                0 === request.pendingRootTasks &&
+                  null === request.trackedPostpones &&
+                  null !== boundary$jscomp$0.contentPreamble &&
+                  preparePreamble(request);
+              }
               0 === request.allPendingTasks && completeAll(request);
             }
           } finally {
@@ -8258,15 +8605,19 @@ function flushSegment(request, destination, segment, hoistableState) {
     return flushSubtree(request, destination, segment, hoistableState);
   boundary.parentFlushed = !0;
   if (boundary.status === CLIENT_RENDERED) {
-    var errorDigest = boundary.errorDigest,
-      errorMessage = boundary.errorMessage,
+    var row = boundary.row;
+    null !== row &&
+      0 === --row.pendingTasks &&
+      finishSuspenseListRow(request, row);
+    row = boundary.errorDigest;
+    var errorMessage = boundary.errorMessage,
       errorStack = boundary.errorStack;
     boundary = boundary.errorComponentStack;
     destination.write(startClientRenderedSuspenseBoundary);
     writeChunk(destination, clientRenderedSuspenseBoundaryError1);
-    errorDigest &&
+    row &&
       (writeChunk(destination, clientRenderedSuspenseBoundaryError1A),
-      writeChunk(destination, escapeTextForBrowser(errorDigest)),
+      writeChunk(destination, escapeTextForBrowser(row)),
       writeChunk(
         destination,
         clientRenderedSuspenseBoundaryErrorAttrInterstitial
@@ -8304,13 +8655,7 @@ function flushSegment(request, destination, segment, hoistableState) {
         request.renderState,
         boundary.rootSegmentID
       ),
-      hoistableState &&
-        ((boundary = boundary.fallbackState),
-        boundary.styles.forEach(hoistStyleQueueDependency, hoistableState),
-        boundary.stylesheets.forEach(
-          hoistStylesheetDependency,
-          hoistableState
-        )),
+      hoistableState && hoistHoistables(hoistableState, boundary.fallbackState),
       flushSubtree(request, destination, segment, hoistableState);
   else if (
     500 < boundary.byteSize &&
@@ -8326,10 +8671,12 @@ function flushSegment(request, destination, segment, hoistableState) {
       flushSubtree(request, destination, segment, hoistableState);
   else {
     flushedByteSize += boundary.byteSize;
-    hoistableState &&
-      ((segment = boundary.contentState),
-      segment.styles.forEach(hoistStyleQueueDependency, hoistableState),
-      segment.stylesheets.forEach(hoistStylesheetDependency, hoistableState));
+    hoistableState && hoistHoistables(hoistableState, boundary.contentState);
+    segment = boundary.row;
+    null !== segment &&
+      500 < boundary.byteSize &&
+      0 === --segment.pendingTasks &&
+      finishSuspenseListRow(request, segment);
     destination.write(startCompletedSuspenseBoundary);
     segment = boundary.completedSegments;
     if (1 !== segment.length)
@@ -8364,6 +8711,11 @@ function flushCompletedBoundary(request, destination, boundary) {
       completedSegments[i]
     );
   completedSegments.length = 0;
+  completedSegments = boundary.row;
+  null !== completedSegments &&
+    500 < boundary.byteSize &&
+    0 === --completedSegments.pendingTasks &&
+    finishSuspenseListRow(request, completedSegments);
   writeHoistablesForBoundary(
     destination,
     boundary.contentState,
@@ -8696,6 +9048,17 @@ function flushCompletedQueues(request, destination) {
               break a;
             }
           completedSegments.splice(0, JSCompiler_inline_result);
+          var row = boundary$jscomp$0.row;
+          null !== row &&
+            row.together &&
+            1 === boundary$jscomp$0.pendingTasks &&
+            (1 === row.pendingTasks
+              ? unblockSuspenseListRow(
+                  clientRenderedBoundaries,
+                  row,
+                  row.hoistables
+                )
+              : row.pendingTasks--);
           JSCompiler_inline_result$jscomp$0 = writeHoistablesForBoundary(
             boundary,
             boundary$jscomp$0.contentState,
@@ -8789,15 +9152,15 @@ function abort(request, reason) {
       fatalError(request, error$4, reason, null);
   }
 }
-var isomorphicReactPackageVersion$jscomp$inline_761 = React.version;
+var isomorphicReactPackageVersion$jscomp$inline_752 = React.version;
 if (
-  "19.2.0-canary-462d08f9-20250517" !==
-  isomorphicReactPackageVersion$jscomp$inline_761
+  "19.2.0-canary-23884812-20250520" !==
+  isomorphicReactPackageVersion$jscomp$inline_752
 )
   throw Error(
     'Incompatible React versions: The "react" and "react-dom" packages must have the exact same version. Instead got:\n  - react:      ' +
-      (isomorphicReactPackageVersion$jscomp$inline_761 +
-        "\n  - react-dom:  19.2.0-canary-462d08f9-20250517\nLearn more: https://react.dev/warnings/version-mismatch")
+      (isomorphicReactPackageVersion$jscomp$inline_752 +
+        "\n  - react-dom:  19.2.0-canary-23884812-20250520\nLearn more: https://react.dev/warnings/version-mismatch")
   );
 exports.renderToReadableStream = function (children, options) {
   return new Promise(function (resolve, reject) {
@@ -8890,4 +9253,4 @@ exports.renderToReadableStream = function (children, options) {
     startWork(request$jscomp$0);
   });
 };
-exports.version = "19.2.0-canary-462d08f9-20250517";
+exports.version = "19.2.0-canary-23884812-20250520";