react-markup 0.0.0-experimental-462d08f9-20250517 → 0.0.0-experimental-23884812-20250520

package/cjs/react-markup.development.js

@@ -41,6 +41,14 @@
     function scriptReplacer(match, prefix, s, suffix) {
       return "" + prefix + ("s" === s ? "\\u0073" : "\\u0053") + suffix;
     }
+    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;
+    }
     function objectName(object) {
       return Object.prototype.toString
         .call(object)
@@ -3770,6 +3778,10 @@
     function hoistStylesheetDependency(stylesheet) {
       this.stylesheets.add(stylesheet);
     }
+    function hoistHoistables(parentState, childState) {
+      childState.styles.forEach(hoistStyleQueueDependency, parentState);
+      childState.stylesheets.forEach(hoistStylesheetDependency, parentState);
+    }
     function getComponentNameFromType(type) {
       if (null == type) return null;
       if ("function" === typeof type)
@@ -4609,6 +4621,7 @@
         null,
         emptyTreeContext,
         null,
+        null,
         emptyContextObject,
         null
       );
@@ -4624,15 +4637,17 @@
     }
     function createSuspenseBoundary(
       request,
+      row,
       fallbackAbortableTasks,
       contentPreamble,
       fallbackPreamble
     ) {
-      return {
+      fallbackAbortableTasks = {
         status: 0,
         rootSegmentID: -1,
         parentFlushed: !1,
         pendingTasks: 0,
+        row: row,
         completedSegments: [],
         byteSize: 0,
         fallbackAbortableTasks: fallbackAbortableTasks,
@@ -4647,6 +4662,17 @@
         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,
@@ -4662,6 +4688,7 @@
       formatContext,
       context,
       treeContext,
+      row,
       componentStack,
       legacyContext,
       debugTask
@@ -4670,6 +4697,7 @@
       null === blockedBoundary
         ? request.pendingRootTasks++
         : blockedBoundary.pendingTasks++;
+      null !== row && row.pendingTasks++;
       var task = {
         replay: null,
         node: node,
@@ -4686,6 +4714,7 @@
         formatContext: formatContext,
         context: context,
         treeContext: treeContext,
+        row: row,
         componentStack: componentStack,
         thenableState: thenableState
       };
@@ -4706,6 +4735,7 @@
       formatContext,
       context,
       treeContext,
+      row,
       componentStack,
       legacyContext,
       debugTask
@@ -4714,6 +4744,7 @@
       null === blockedBoundary
         ? request.pendingRootTasks++
         : blockedBoundary.pendingTasks++;
+      null !== row && row.pendingTasks++;
       replay.pendingTasks++;
       var task = {
         replay: replay,
@@ -4731,6 +4762,7 @@
         formatContext: formatContext,
         context: context,
         treeContext: treeContext,
+        row: row,
         componentStack: componentStack,
         thenableState: thenableState
       };
@@ -4922,6 +4954,180 @@
         ? ((request.status = 14), request.destination.destroy(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),
+              (resumeSegmentID.status = 1),
+              0 === --previousSuspenseListRow.pendingTasks &&
+                finishSuspenseListRow(request, previousSuspenseListRow);
+          } catch (thrownValue) {
+            throw (
+              ((resumeSegmentID.status = 12 === request.status ? 3 : 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,
@@ -5485,7 +5691,7 @@
           );
           segment.lastPushedText = !1;
           var _prevContext2 = task.formatContext,
-            _prevKeyPath2 = task.keyPath;
+            _prevKeyPath3 = task.keyPath;
           task.keyPath = keyPath;
           if (
             3 ===
@@ -5518,6 +5724,7 @@
               task.formatContext,
               task.context,
               task.treeContext,
+              task.row,
               task.componentStack,
               emptyContextObject,
               task.debugTask
@@ -5526,7 +5733,7 @@
             request.pingedTasks.push(preambleTask);
           } else renderNode(request, task, _children, -1);
           task.formatContext = _prevContext2;
-          task.keyPath = _prevKeyPath2;
+          task.keyPath = _prevKeyPath3;
           a: {
             var target$jscomp$0 = segment.chunks,
               resumableState$jscomp$0 = request.resumableState;
@@ -5591,22 +5798,128 @@
               }
             } else if ("hidden" !== props.mode) {
               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.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 ("function" === typeof children$jscomp$0[ASYNC_ITERATOR]) {
+                  var _iterator = children$jscomp$0[ASYNC_ITERATOR]();
+                  if (_iterator) {
+                    validateAsyncIterable(
+                      task,
+                      children$jscomp$0,
+                      -1,
+                      _iterator
+                    );
+                    var prevThenableState = task.thenableState;
+                    task.thenableState = null;
+                    thenableIndexCounter = 0;
+                    thenableState = prevThenableState;
+                    var _rows = [],
+                      done = !1;
+                    if (_iterator === children$jscomp$0)
+                      for (
+                        var _step = readPreviousThenableFromState();
+                        void 0 !== _step;
+
+                      ) {
+                        if (_step.done) {
+                          done = !0;
+                          break;
+                        }
+                        _rows.push(_step.value);
+                        _step = readPreviousThenableFromState();
+                      }
+                    if (!done)
+                      for (
+                        var _step2 = unwrapThenable(_iterator.next());
+                        !_step2.done;
+
+                      )
+                        _rows.push(_step2.value),
+                          (_step2 = unwrapThenable(_iterator.next()));
+                    renderSuspenseListRows(
+                      request,
+                      task,
+                      keyPath,
+                      _rows,
+                      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:
             var prevContext$jscomp$0 = task.formatContext,
-              prevKeyPath$jscomp$3 = task.keyPath;
+              prevKeyPath$jscomp$4 = task.keyPath;
             var resumableState$jscomp$1 = request.resumableState;
             if (null == props.name || "auto" === props.name) {
               var treeId = getTreeId(task.treeContext);
@@ -5623,7 +5936,7 @@
               task.treeContext = prevTreeContext;
             }
             task.formatContext = prevContext$jscomp$0;
-            task.keyPath = prevKeyPath$jscomp$3;
+            task.keyPath = prevKeyPath$jscomp$4;
             return;
           case REACT_SCOPE_TYPE:
             throw Error(
@@ -5632,22 +5945,26 @@
           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.formatContext = _prevContext),
+                  (task.row = _prevRow);
               }
             } else {
-              var prevKeyPath$jscomp$4 = task.keyPath,
+              var prevKeyPath$jscomp$5 = task.keyPath,
                 prevContext$jscomp$1 = task.formatContext,
+                prevRow$jscomp$0 = task.row,
                 parentBoundary = task.blockedBoundary,
                 parentPreamble = task.blockedPreamble,
                 parentHoistableState = task.hoistableState,
@@ -5659,12 +5976,14 @@
                 2 > task.formatContext.insertionMode
                   ? createSuspenseBoundary(
                       request,
+                      task.row,
                       fallbackAbortSet,
                       createPreambleState(),
                       createPreambleState()
                     )
                   : createSuspenseBoundary(
                       request,
+                      task.row,
                       fallbackAbortSet,
                       null,
                       null
@@ -5726,7 +6045,7 @@
                 } finally {
                   (task.blockedSegment = parentSegment),
                     (task.blockedPreamble = parentPreamble),
-                    (task.keyPath = prevKeyPath$jscomp$4),
+                    (task.keyPath = prevKeyPath$jscomp$5),
                     (task.formatContext = prevContext$jscomp$1);
                 }
                 var suspendedPrimaryTask = createRenderTask(
@@ -5746,6 +6065,7 @@
                   ),
                   task.context,
                   task.treeContext,
+                  null,
                   task.componentStack,
                   emptyContextObject,
                   task.debugTask
@@ -5762,21 +6082,30 @@
                   request.resumableState,
                   prevContext$jscomp$1
                 );
+                task.row = null;
                 contentRootSegment.status = 6;
                 try {
                   if (
                     (renderNode(request, task, content, -1),
                     (contentRootSegment.status = 1),
                     queueCompletedSegment(newBoundary, contentRootSegment),
-                    0 === newBoundary.pendingTasks &&
-                      0 === newBoundary.status &&
-                      ((newBoundary.status = 1), !(500 < newBoundary.byteSize)))
+                    0 === newBoundary.pendingTasks && 0 === newBoundary.status)
                   ) {
-                    0 === request.pendingRootTasks &&
-                      task.blockedPreamble &&
-                      preparePreamble(request);
-                    break a;
-                  }
+                    if (
+                      ((newBoundary.status = 1), !(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 = 4;
                   if (12 === request.status) {
@@ -5817,8 +6146,9 @@
                     (task.blockedPreamble = parentPreamble),
                     (task.hoistableState = parentHoistableState),
                     (task.blockedSegment = parentSegment),
-                    (task.keyPath = prevKeyPath$jscomp$4),
-                    (task.formatContext = prevContext$jscomp$1);
+                    (task.keyPath = prevKeyPath$jscomp$5),
+                    (task.formatContext = prevContext$jscomp$1),
+                    (task.row = prevRow$jscomp$0);
                 }
                 var suspendedFallbackTask = createRenderTask(
                   request,
@@ -5837,6 +6167,7 @@
                   ),
                   task.context,
                   task.treeContext,
+                  task.row,
                   task.componentStack,
                   emptyContextObject,
                   task.debugTask
@@ -5855,7 +6186,7 @@
                 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,
@@ -5867,7 +6198,7 @@
                 request,
                 task,
                 keyPath,
-                children$jscomp$0,
+                children$jscomp$1,
                 0 !== localIdCounter,
                 actionStateCounter,
                 actionStateMatchingIndex
@@ -5879,9 +6210,9 @@
             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$5 = task.keyPath;
+              var prevKeyPath$jscomp$6 = task.keyPath;
               var prevValue = type._currentValue2;
               type._currentValue2 = value$jscomp$0;
               void 0 !== type._currentRenderer2 &&
@@ -5902,7 +6233,7 @@
               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(
@@ -5924,7 +6255,7 @@
               var JSCompiler_inline_result$jscomp$0 = (currentActiveSnapshot =
                 prevSnapshot$jscomp$0.parent);
               task.context = JSCompiler_inline_result$jscomp$0;
-              task.keyPath = prevKeyPath$jscomp$5;
+              task.keyPath = prevKeyPath$jscomp$6;
               prevSnapshot !== task.context &&
                 console.error(
                   "Popping the context provider did not return back to the original snapshot. This is a bug in React."
@@ -5938,10 +6269,10 @@
                   "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._currentValue2),
-                prevKeyPath$jscomp$6 = task.keyPath;
+                prevKeyPath$jscomp$7 = task.keyPath;
               task.keyPath = keyPath;
               renderNodeDestructive(request, task, newChildren, -1);
-              task.keyPath = prevKeyPath$jscomp$6;
+              task.keyPath = prevKeyPath$jscomp$7;
               return;
             case REACT_LAZY_TYPE:
               var Component = callLazyInitInDEV(type);
@@ -6066,6 +6397,7 @@
               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,
@@ -6076,12 +6408,14 @@
                 2 > task.formatContext.insertionMode
                   ? createSuspenseBoundary(
                       request,
+                      task.row,
                       fallbackAbortSet,
                       createPreambleState(),
                       createPreambleState()
                     )
                   : createSuspenseBoundary(
                       request,
+                      task.row,
                       fallbackAbortSet,
                       null,
                       null
@@ -6095,6 +6429,7 @@
                 request.resumableState,
                 prevContext
               );
+              task.row = null;
               task.replay = { nodes: ref, slots: name, pendingTasks: 1 };
               try {
                 renderNode(request, task, content, -1);
@@ -6138,7 +6473,8 @@
                   (task.hoistableState = parentHoistableState),
                   (task.replay = previousReplaySet),
                   (task.keyPath = prevKeyPath),
-                  (task.formatContext = prevContext);
+                  (task.formatContext = prevContext),
+                  (task.row = prevRow);
               }
               props = createReplayTask(
                 request,
@@ -6156,6 +6492,7 @@
                 ),
                 task.context,
                 task.treeContext,
+                task.row,
                 task.componentStack,
                 emptyContextObject,
                 task.debugTask
@@ -6169,6 +6506,50 @@
         }
       }
     }
+    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 validateAsyncIterable(task, iterable, childIndex, iterator) {
+      iterator !== iterable ||
+        (-1 === childIndex &&
+          null !== task.componentStack &&
+          "function" === typeof task.componentStack.type &&
+          "[object AsyncGeneratorFunction]" ===
+            Object.prototype.toString.call(task.componentStack.type) &&
+          "[object AsyncGenerator]" ===
+            Object.prototype.toString.call(iterator)) ||
+        (didWarnAboutGenerators ||
+          console.error(
+            "Using AsyncIterators as children is unsupported and will likely yield unexpected results because enumerating a generator mutates it. You can use an AsyncIterable that can iterate multiple times over the same items."
+          ),
+        (didWarnAboutGenerators = !0));
+    }
     function renderNodeDestructive(request, task, node, childIndex) {
       null !== task.replay && "number" === typeof task.replay.slots
         ? resumeNode(request, task, task.replay.slots, node, childIndex)
@@ -6254,60 +6635,23 @@
             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[ASYNC_ITERATOR] &&
             (type = node[ASYNC_ITERATOR]())
           ) {
-            type !== node ||
-              (-1 === childIndex &&
-                null !== task.componentStack &&
-                "function" === typeof task.componentStack.type &&
-                "[object AsyncGeneratorFunction]" ===
-                  Object.prototype.toString.call(task.componentStack.type) &&
-                "[object AsyncGenerator]" ===
-                  Object.prototype.toString.call(type)) ||
-              (didWarnAboutGenerators ||
-                console.error(
-                  "Using AsyncIterators as children is unsupported and will likely yield unexpected results because enumerating a generator mutates it. You can use an AsyncIterable that can iterate multiple times over the same items."
-                ),
-              (didWarnAboutGenerators = !0));
+            validateAsyncIterable(task, node, childIndex, type);
             key = task.thenableState;
             task.thenableState = null;
             thenableIndexCounter = 0;
@@ -6379,7 +6723,70 @@
                 ));
       }
     }
-    function renderChildrenArray(request$jscomp$0, task, children, childIndex) {
+    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;
       var previousDebugTask = task.debugTask;
@@ -6400,7 +6807,7 @@
             node = node[3];
             task.replay = { nodes: childIndex, slots: node, pendingTasks: 1 };
             try {
-              renderChildrenArray(request$jscomp$0, task, children, -1);
+              renderChildrenArray(request, task, children, -1);
               if (
                 1 === task.replay.pendingTasks &&
                 0 < task.replay.nodes.length
@@ -6419,7 +6826,7 @@
               task.replay.pendingTasks--;
               children = getThrownInfo(task.componentStack);
               erroredReplay(
-                request$jscomp$0,
+                request,
                 task.blockedBoundary,
                 x,
                 children,
@@ -6449,15 +6856,9 @@
           task.treeContext = pushTreeContext(replay, replayNodes, childIndex);
           var resumeSegmentID = j[childIndex];
           "number" === typeof resumeSegmentID
-            ? (resumeNode(
-                request$jscomp$0,
-                task,
-                resumeSegmentID,
-                node,
-                childIndex
-              ),
+            ? (resumeNode(request, task, resumeSegmentID, node, childIndex),
               delete j[childIndex])
-            : renderNode(request$jscomp$0, task, node, childIndex);
+            : renderNode(request, task, node, childIndex);
         }
         task.treeContext = replay;
         task.keyPath = prevKeyPath;
@@ -6465,75 +6866,11 @@
         task.debugTask = previousDebugTask;
         return;
       }
-      for (j = 0; j < replayNodes; j++) {
-        childIndex = children[j];
-        var request = request$jscomp$0;
-        node = task;
-        resumeSegmentID = childIndex;
-        if (
-          null !== resumeSegmentID &&
-          "object" === typeof resumeSegmentID &&
-          (resumeSegmentID.$$typeof === REACT_ELEMENT_TYPE ||
-            resumeSegmentID.$$typeof === REACT_PORTAL_TYPE) &&
-          resumeSegmentID._store &&
-          ((!resumeSegmentID._store.validated && null == resumeSegmentID.key) ||
-            2 === resumeSegmentID._store.validated)
-        ) {
-          if ("object" !== typeof resumeSegmentID._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."
-            );
-          resumeSegmentID._store.validated = 1;
-          var didWarnForKey = request.didWarnForKey;
-          null == didWarnForKey &&
-            (didWarnForKey = request.didWarnForKey = new WeakSet());
-          request = node.componentStack;
-          if (null !== request && !didWarnForKey.has(request)) {
-            didWarnForKey.add(request);
-            var componentName = getComponentNameFromType(resumeSegmentID.type);
-            didWarnForKey = resumeSegmentID._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 = node.componentStack;
-            node.componentStack = {
-              parent: node.componentStack,
-              type: resumeSegmentID.type,
-              owner: resumeSegmentID._owner,
-              stack: resumeSegmentID._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
-            );
-            node.componentStack = didWarnForKey;
-          }
-        }
-        task.treeContext = pushTreeContext(replay, replayNodes, j);
-        renderNode(request$jscomp$0, 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;
@@ -6661,6 +6998,7 @@
         task.formatContext,
         task.context,
         task.treeContext,
+        task.row,
         task.componentStack,
         emptyContextObject,
         task.debugTask
@@ -6692,6 +7030,7 @@
         task.formatContext,
         task.context,
         task.treeContext,
+        task.row,
         task.componentStack,
         emptyContextObject,
         task.debugTask
@@ -6868,9 +7207,10 @@
       );
     }
     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 = 3), finishedTask(this, boundary, task.row, segment));
     }
     function abortRemainingReplayNodes(
       request$jscomp$0,
@@ -6904,6 +7244,7 @@
             wasAborted = aborted,
             resumedBoundary = createSuspenseBoundary(
               request,
+              null,
               new Set(),
               null,
               null
@@ -6962,7 +7303,7 @@
                 null !== boundary && null !== segment
                   ? (logPostpone(request, error.message, errorInfo, null),
                     trackPostpone(request, boundary, task, segment),
-                    finishedTask(request, null, segment))
+                    finishedTask(request, null, task.row, segment))
                   : ((task = Error(
                       "The render was aborted with postpone when the shell is incomplete. Reason: " +
                         error.message
@@ -6973,7 +7314,7 @@
                 ? ((boundary = request.trackedPostpones),
                   logRecoverableError(request, error, errorInfo, null),
                   trackPostpone(request, boundary, task, segment),
-                  finishedTask(request, null, segment))
+                  finishedTask(request, null, task.row, segment))
                 : (logRecoverableError(request, error, errorInfo, null),
                   fatalError(request, error, errorInfo, null));
             return;
@@ -6985,15 +7326,20 @@
             null !== error &&
             error.$$typeof === REACT_POSTPONE_TYPE
               ? (logPostpone(request, error.message, errorInfo, null),
-                (task = "POSTPONE"))
-              : (task = logRecoverableError(request, error, errorInfo, null)),
+                (segment = "POSTPONE"))
+              : (segment = logRecoverableError(
+                  request,
+                  error,
+                  errorInfo,
+                  null
+                )),
             abortRemainingReplayNodes(
               request,
               null,
               boundary.nodes,
               boundary.slots,
               error,
-              task,
+              segment,
               errorInfo,
               !0
             ));
@@ -7001,7 +7347,6 @@
           0 === request.pendingRootTasks && completeShell(request);
         }
       } else {
-        boundary.pendingTasks--;
         var _trackedPostpones2 = request.trackedPostpones;
         if (4 !== boundary.status) {
           if (null !== _trackedPostpones2 && null !== segment)
@@ -7016,7 +7361,7 @@
                 return abortTask(fallbackTask, request, error);
               }),
               boundary.fallbackAbortableTasks.clear(),
-              finishedTask(request, boundary, segment)
+              finishedTask(request, boundary, task.row, segment)
             );
           boundary.status = 4;
           if (
@@ -7027,26 +7372,35 @@
             logPostpone(request, error.message, errorInfo, null);
             if (null !== request.trackedPostpones && null !== segment) {
               trackPostpone(request, request.trackedPostpones, task, segment);
-              finishedTask(request, task.blockedBoundary, segment);
+              finishedTask(request, task.blockedBoundary, task.row, segment);
               boundary.fallbackAbortableTasks.forEach(function (fallbackTask) {
                 return abortTask(fallbackTask, request, error);
               });
               boundary.fallbackAbortableTasks.clear();
               return;
             }
-            task = "POSTPONE";
-          } else task = logRecoverableError(request, error, errorInfo, null);
+            segment = "POSTPONE";
+          } else segment = logRecoverableError(request, error, errorInfo, null);
           boundary.status = 4;
-          encodeErrorForBoundary(boundary, task, error, errorInfo, !0);
+          encodeErrorForBoundary(boundary, segment, error, errorInfo, !0);
           untrackBoundary(request, boundary);
           boundary.parentFlushed &&
             request.clientRenderedBoundaries.push(boundary);
         }
+        boundary.pendingTasks--;
+        errorInfo = boundary.row;
+        null !== errorInfo &&
+          0 === --errorInfo.pendingTasks &&
+          finishSuspenseListRow(request, errorInfo);
         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);
     }
@@ -7148,7 +7502,11 @@
           queueCompletedSegment(boundary, childSegment);
       } else boundary.completedSegments.push(segment);
     }
-    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) {
@@ -7172,23 +7530,33 @@
                 boundary.parentFlushed &&
                   request.completedBoundaries.push(boundary),
                 1 === boundary.status &&
-                  (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 &&
-                1 === segment.status &&
-                (queueCompletedSegment(boundary, segment),
-                1 === boundary.completedSegments.length &&
-                  boundary.parentFlushed &&
-                  request.partialBoundaries.push(boundary)));
+              : (null !== segment &&
+                  segment.parentFlushed &&
+                  1 === segment.status &&
+                  (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$1) {
@@ -7236,7 +7604,12 @@
                     );
                   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 =
@@ -7296,6 +7669,7 @@
                       finishedTask(
                         request,
                         task$jscomp$0.blockedBoundary,
+                        task$jscomp$0.row,
                         segment$jscomp$0
                       );
                   } catch (thrownValue) {
@@ -7341,6 +7715,7 @@
                       finishedTask(
                         request,
                         task$jscomp$0.blockedBoundary,
+                        task$jscomp$0.row,
                         segment$jscomp$0
                       );
                     } else {
@@ -7380,6 +7755,7 @@
                           finishedTask(
                             request,
                             task$jscomp$0.blockedBoundary,
+                            task$jscomp$0.row,
                             segment$jscomp$0
                           );
                           break a;
@@ -7391,7 +7767,12 @@
                       task$jscomp$0.abortSet.delete(task$jscomp$0);
                       segment$jscomp$0.status = 4;
                       var boundary = task$jscomp$0.blockedBoundary,
+                        row = task$jscomp$0.row,
                         debugTask = task$jscomp$0.debugTask;
+                      null !== row &&
+                        0 === --row.pendingTasks &&
+                        finishSuspenseListRow(request, row);
+                      request.allPendingTasks--;
                       "object" === typeof x$jscomp$0 &&
                       null !== x$jscomp$0 &&
                       x$jscomp$0.$$typeof === REACT_POSTPONE_TYPE
@@ -7408,31 +7789,36 @@
                             errorInfo$jscomp$0,
                             debugTask
                           ));
-                      null === boundary
-                        ? fatalError(
-                            request,
-                            x$jscomp$0,
-                            errorInfo$jscomp$0,
-                            debugTask
-                          )
-                        : (boundary.pendingTasks--,
-                          4 !== boundary.status &&
-                            ((boundary.status = 4),
-                            encodeErrorForBoundary(
-                              boundary,
-                              prevTaskInDEV,
-                              x$jscomp$0,
-                              errorInfo$jscomp$0,
-                              !1
-                            ),
-                            untrackBoundary(request, boundary),
-                            boundary.parentFlushed &&
-                              request.clientRenderedBoundaries.push(boundary),
-                            0 === request.pendingRootTasks &&
-                              null === request.trackedPostpones &&
-                              null !== boundary.contentPreamble &&
-                              preparePreamble(request)));
-                      request.allPendingTasks--;
+                      if (null === boundary)
+                        fatalError(
+                          request,
+                          x$jscomp$0,
+                          errorInfo$jscomp$0,
+                          debugTask
+                        );
+                      else if (
+                        (boundary.pendingTasks--, 4 !== boundary.status)
+                      ) {
+                        boundary.status = 4;
+                        encodeErrorForBoundary(
+                          boundary,
+                          prevTaskInDEV,
+                          x$jscomp$0,
+                          errorInfo$jscomp$0,
+                          !1
+                        );
+                        untrackBoundary(request, boundary);
+                        var boundaryRow = boundary.row;
+                        null !== boundaryRow &&
+                          0 === --boundaryRow.pendingTasks &&
+                          finishSuspenseListRow(request, boundaryRow);
+                        boundary.parentFlushed &&
+                          request.clientRenderedBoundaries.push(boundary);
+                        0 === request.pendingRootTasks &&
+                          null === request.trackedPostpones &&
+                          null !== boundary.contentPreamble &&
+                          preparePreamble(request);
+                      }
                       0 === request.allPendingTasks && completeAll(request);
                     }
                   } finally {
@@ -7583,7 +7969,14 @@
         return flushSubtree(request, destination, segment, hoistableState);
       boundary.parentFlushed = !0;
       if (4 === boundary.status)
-        return flushSubtree(request, destination, segment, hoistableState), !0;
+        return (
+          (boundary = boundary.row),
+          null !== boundary &&
+            0 === --boundary.pendingTasks &&
+            finishSuspenseListRow(request, boundary),
+          flushSubtree(request, destination, segment, hoistableState),
+          !0
+        );
       if (1 !== boundary.status)
         return (
           0 === boundary.status &&
@@ -7596,12 +7989,7 @@
             boundary.rootSegmentID
           ),
           hoistableState &&
-            ((boundary = boundary.fallbackState),
-            boundary.styles.forEach(hoistStyleQueueDependency, hoistableState),
-            boundary.stylesheets.forEach(
-              hoistStylesheetDependency,
-              hoistableState
-            )),
+            hoistHoistables(hoistableState, boundary.fallbackState),
           flushSubtree(request, destination, segment, hoistableState),
           destination.push("\x3c!--/$--\x3e")
         );
@@ -7621,10 +8009,12 @@
           destination.push("\x3c!--/$--\x3e")
         );
       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);
       segment = boundary.completedSegments;
       if (1 !== segment.length)
         throw Error(
@@ -7662,6 +8052,11 @@
           completedSegments[i]
         );
       completedSegments.length = 0;
+      completedSegments = boundary.row;
+      null !== completedSegments &&
+        500 < boundary.byteSize &&
+        0 === --completedSegments.pendingTasks &&
+        finishSuspenseListRow(request, completedSegments);
       writeHoistablesForBoundary(
         destination,
         boundary.contentState,
@@ -7731,11 +8126,12 @@
         ? destination.push(")\x3c/script>")
         : destination.push('"></template>');
       request = request.bootstrapChunks;
-      for (i = 0; i < request.length - 1; i++) destination.push(request[i]);
-      i < request.length
-        ? ((i = request[i]),
+      for (boundary = 0; boundary < request.length - 1; boundary++)
+        destination.push(request[boundary]);
+      boundary < request.length
+        ? ((boundary = request[boundary]),
           (request.length = 0),
-          (destination = destination.push(i)))
+          (destination = destination.push(boundary)))
         : (destination = !0);
       return destination && completedSegments;
     }
@@ -8071,6 +8467,17 @@
                   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,
@@ -9203,5 +9610,5 @@
         });
       });
     };
-    exports.version = "19.2.0-experimental-462d08f9-20250517";
+    exports.version = "19.2.0-experimental-23884812-20250520";
   })();