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

package/cjs/react-markup.react-server.production.js

@@ -6305,6 +6305,7 @@ function createRequest(
     rootFormatContext,
     null,
     emptyTreeContext,
+    null,
     null
   );
   pushComponentStack(children);
@@ -6319,15 +6320,17 @@ function pingTask(request, task) {
 }
 function createSuspenseBoundary(
   request,
+  row,
   fallbackAbortableTasks,
   contentPreamble,
   fallbackPreamble
 ) {
-  return {
+  fallbackAbortableTasks = {
     status: 0,
     rootSegmentID: -1,
     parentFlushed: !1,
     pendingTasks: 0,
+    row: row,
     completedSegments: [],
     byteSize: 0,
     fallbackAbortableTasks: fallbackAbortableTasks,
@@ -6339,6 +6342,14 @@ function createSuspenseBoundary(
     trackedContentKeyPath: null,
     trackedFallbackNode: null
   };
+  null !== row &&
+    (row.pendingTasks++,
+    (row = row.boundaries),
+    null !== row &&
+      (request.allPendingTasks++,
+      fallbackAbortableTasks.pendingTasks++,
+      row.push(fallbackAbortableTasks)));
+  return fallbackAbortableTasks;
 }
 function createRenderTask(
   request,
@@ -6354,12 +6365,14 @@ function createRenderTask(
   formatContext,
   context,
   treeContext,
+  row,
   componentStack
 ) {
   request.allPendingTasks++;
   null === blockedBoundary
     ? request.pendingRootTasks++
     : blockedBoundary.pendingTasks++;
+  null !== row && row.pendingTasks++;
   var task = {
     replay: null,
     node: node,
@@ -6376,6 +6389,7 @@ function createRenderTask(
     formatContext: formatContext,
     context: context,
     treeContext: treeContext,
+    row: row,
     componentStack: componentStack,
     thenableState: thenableState
   };
@@ -6395,12 +6409,14 @@ function createReplayTask(
   formatContext,
   context,
   treeContext,
+  row,
   componentStack
 ) {
   request.allPendingTasks++;
   null === blockedBoundary
     ? request.pendingRootTasks++
     : blockedBoundary.pendingTasks++;
+  null !== row && row.pendingTasks++;
   replay.pendingTasks++;
   var task = {
     replay: replay,
@@ -6418,6 +6434,7 @@ function createReplayTask(
     formatContext: formatContext,
     context: context,
     treeContext: treeContext,
+    row: row,
     componentStack: componentStack,
     thenableState: thenableState
   };
@@ -6499,6 +6516,125 @@ function fatalError(request, error) {
     ? ((request.status = 14), request.destination.destroy(error))
     : ((request.status = 13), (request.fatalError = error));
 }
+function finishSuspenseListRow(request, row) {
+  for (row = row.next; null !== row; ) {
+    var unblockedBoundaries = row.boundaries;
+    if (null !== unblockedBoundaries) {
+      row.boundaries = null;
+      for (var i = 0; i < unblockedBoundaries.length; i++)
+        finishedTask(request, unblockedBoundaries[i], null, null);
+    }
+    row.pendingTasks--;
+    if (0 < row.pendingTasks) break;
+    row = row.next;
+  }
+}
+function createSuspenseListRow(previousRow) {
+  var newRow = { pendingTasks: 1, boundaries: null, next: null };
+  null !== previousRow &&
+    0 < previousRow.pendingTasks &&
+    (newRow.pendingTasks++,
+    (newRow.boundaries = []),
+    (previousRow.next = newRow));
+  return newRow;
+}
+function renderSuspenseListRows(request, task, keyPath, rows, revealOrder) {
+  keyPath = task.keyPath;
+  var prevTreeContext = task.treeContext,
+    prevRow = task.row,
+    totalChildren = rows.length,
+    previousSuspenseListRow = null;
+  if (null !== task.replay) {
+    var resumeSlots = task.replay.slots;
+    if (null !== resumeSlots && "object" === typeof resumeSlots)
+      for (var n = 0; n < totalChildren; n++) {
+        var i = "backwards" !== revealOrder ? n : totalChildren - 1 - n,
+          node = rows[i];
+        task.row = previousSuspenseListRow = createSuspenseListRow(
+          previousSuspenseListRow
+        );
+        task.treeContext = pushTreeContext(prevTreeContext, totalChildren, 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 < totalChildren; resumeSlots++)
+        (n =
+          "backwards" !== revealOrder
+            ? resumeSlots
+            : totalChildren - 1 - resumeSlots),
+          (i = rows[n]),
+          (task.row = previousSuspenseListRow =
+            createSuspenseListRow(previousSuspenseListRow)),
+          (task.treeContext = pushTreeContext(
+            prevTreeContext,
+            totalChildren,
+            n
+          )),
+          renderNode(request, task, i, n),
+          0 === --previousSuspenseListRow.pendingTasks &&
+            finishSuspenseListRow(request, previousSuspenseListRow);
+  } else if ("backwards" !== revealOrder)
+    for (revealOrder = 0; revealOrder < totalChildren; revealOrder++)
+      (resumeSlots = rows[revealOrder]),
+        (task.row = previousSuspenseListRow =
+          createSuspenseListRow(previousSuspenseListRow)),
+        (task.treeContext = pushTreeContext(
+          prevTreeContext,
+          totalChildren,
+          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 = totalChildren - 1; 0 <= i; i--) {
+      node = rows[i];
+      task.row = previousSuspenseListRow = createSuspenseListRow(
+        previousSuspenseListRow
+      );
+      task.treeContext = pushTreeContext(prevTreeContext, totalChildren, i);
+      resumeSegmentID = createPendingSegment(
+        request,
+        n,
+        null,
+        task.formatContext,
+        0 === i ? revealOrder.lastPushedText : !0,
+        !0
+      );
+      revealOrder.children.splice(resumeSlots, 0, resumeSegmentID);
+      task.blockedSegment = resumeSegmentID;
+      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 = keyPath;
+}
 function renderWithHooks(request, task, keyPath, Component, props, secondArg) {
   var prevThenableState = task.thenableState;
   task.thenableState = null;
@@ -6566,9 +6702,9 @@ function renderElement(request, task, keyPath, type, props, ref) {
       var defaultProps = type.defaultProps;
       if (defaultProps) {
         newProps === props && (newProps = assign({}, newProps, props));
-        for (var propName$89 in defaultProps)
-          void 0 === newProps[propName$89] &&
-            (newProps[propName$89] = defaultProps[propName$89]);
+        for (var propName$100 in defaultProps)
+          void 0 === newProps[propName$100] &&
+            (newProps[propName$100] = defaultProps[propName$100]);
       }
       var JSCompiler_inline_result = newProps;
       var context = emptyContextObject,
@@ -6735,13 +6871,13 @@ function renderElement(request, task, keyPath, type, props, ref) {
         textEmbedded
       );
       segment.lastPushedText = !1;
-      var prevContext$87 = task.formatContext,
-        prevKeyPath$88 = task.keyPath;
+      var prevContext$98 = task.formatContext,
+        prevKeyPath$99 = task.keyPath;
       task.keyPath = keyPath;
       if (
         3 ===
         (task.formatContext = getChildFormatContext(
-          prevContext$87,
+          prevContext$98,
           type,
           props
         )).insertionMode
@@ -6769,13 +6905,14 @@ function renderElement(request, task, keyPath, type, props, ref) {
           task.formatContext,
           task.context,
           task.treeContext,
+          task.row,
           task.componentStack
         );
         pushComponentStack(preambleTask);
         request.pingedTasks.push(preambleTask);
       } else renderNode(request, task, JSCompiler_inline_result$jscomp$2, -1);
-      task.formatContext = prevContext$87;
-      task.keyPath = prevKeyPath$88;
+      task.formatContext = prevContext$98;
+      task.keyPath = prevKeyPath$99;
       a: {
         var target$jscomp$0 = segment.chunks,
           resumableState$jscomp$0 = request.resumableState;
@@ -6800,19 +6937,19 @@ function renderElement(request, task, keyPath, type, props, ref) {
           case "wbr":
             break a;
           case "body":
-            if (1 >= prevContext$87.insertionMode) {
+            if (1 >= prevContext$98.insertionMode) {
               resumableState$jscomp$0.hasBody = !0;
               break a;
             }
             break;
           case "html":
-            if (0 === prevContext$87.insertionMode) {
+            if (0 === prevContext$98.insertionMode) {
               resumableState$jscomp$0.hasHtml = !0;
               break a;
             }
             break;
           case "head":
-            if (1 >= prevContext$87.insertionMode) break a;
+            if (1 >= prevContext$98.insertionMode) break a;
         }
         target$jscomp$0.push(endChunkForTag(type));
       }
@@ -6840,22 +6977,97 @@ function renderElement(request, task, keyPath, type, props, ref) {
           }
         } else if ("hidden" !== props.mode) {
           segment$jscomp$0.lastPushedText = !1;
-          var prevKeyPath$91 = task.keyPath;
+          var prevKeyPath$102 = task.keyPath;
           task.keyPath = keyPath;
           renderNode(request, task, props.children, -1);
-          task.keyPath = prevKeyPath$91;
+          task.keyPath = prevKeyPath$102;
           segment$jscomp$0.lastPushedText = !1;
         }
         return;
       case REACT_SUSPENSE_LIST_TYPE:
-        var prevKeyPath$92 = task.keyPath;
-        task.keyPath = keyPath;
-        renderNodeDestructive(request, task, props.children, -1);
-        task.keyPath = prevKeyPath$92;
+        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) {
+                var step = iterator.next();
+                if (!step.done) {
+                  do 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$94 = children$jscomp$0[ASYNC_ITERATOR]();
+              if (iterator$94) {
+                var prevThenableState = task.thenableState;
+                task.thenableState = null;
+                thenableIndexCounter = 0;
+                thenableState = prevThenableState;
+                var rows = [],
+                  done = !1;
+                if (iterator$94 === children$jscomp$0)
+                  for (
+                    var step$95 = readPreviousThenableFromState();
+                    void 0 !== step$95;
+
+                  ) {
+                    if (step$95.done) {
+                      done = !0;
+                      break;
+                    }
+                    rows.push(step$95.value);
+                    step$95 = readPreviousThenableFromState();
+                  }
+                if (!done)
+                  for (
+                    var step$96 = unwrapThenable(iterator$94.next());
+                    !step$96.done;
+
+                  )
+                    rows.push(step$96.value),
+                      (step$96 = unwrapThenable(iterator$94.next()));
+                renderSuspenseListRows(
+                  request,
+                  task,
+                  keyPath,
+                  rows,
+                  revealOrder
+                );
+                break a;
+              }
+            }
+          }
+          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);
@@ -6872,29 +7084,33 @@ function renderElement(request, task, keyPath, type, props, ref) {
           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("ReactDOMServer does not yet support scope components.");
       case REACT_SUSPENSE_TYPE:
         a: if (null !== task.replay) {
           var prevKeyPath$81 = task.keyPath,
-            prevContext$82 = task.formatContext;
+            prevContext$82 = task.formatContext,
+            prevRow$83 = task.row;
           task.keyPath = keyPath;
           task.formatContext = getSuspenseContentFormatContext(
             request.resumableState,
             prevContext$82
           );
-          var content$83 = props.children;
+          task.row = null;
+          var content$84 = props.children;
           try {
-            renderNode(request, task, content$83, -1);
+            renderNode(request, task, content$84, -1);
           } finally {
             (task.keyPath = prevKeyPath$81),
-              (task.formatContext = prevContext$82);
+              (task.formatContext = prevContext$82),
+              (task.row = prevRow$83);
           }
         } else {
-          var prevKeyPath$jscomp$4 = task.keyPath,
+          var prevKeyPath$jscomp$5 = task.keyPath,
             prevContext$jscomp$1 = task.formatContext,
+            prevRow = task.row,
             parentBoundary = task.blockedBoundary,
             parentPreamble = task.blockedPreamble,
             parentHoistableState = task.hoistableState,
@@ -6906,11 +7122,18 @@ function renderElement(request, task, keyPath, type, props, ref) {
             2 > task.formatContext.insertionMode
               ? 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(
@@ -6964,7 +7187,7 @@ function renderElement(request, task, keyPath, type, props, ref) {
             } 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(
@@ -6984,6 +7207,7 @@ function renderElement(request, task, keyPath, type, props, ref) {
               ),
               task.context,
               task.treeContext,
+              null,
               task.componentStack
             );
             pushComponentStack(suspendedPrimaryTask);
@@ -6998,6 +7222,7 @@ function renderElement(request, task, keyPath, type, props, ref) {
               request.resumableState,
               prevContext$jscomp$1
             );
+            task.row = null;
             contentRootSegment.status = 6;
             try {
               if (
@@ -7008,17 +7233,20 @@ function renderElement(request, task, keyPath, type, props, ref) {
                   0 === newBoundary.status &&
                   ((newBoundary.status = 1), !(500 < newBoundary.byteSize)))
               ) {
+                null !== prevRow &&
+                  0 === --prevRow.pendingTasks &&
+                  finishSuspenseListRow(request, prevRow);
                 0 === request.pendingRootTasks &&
                   task.blockedPreamble &&
                   preparePreamble(request);
                 break a;
               }
-            } catch (thrownValue$84) {
+            } catch (thrownValue$85) {
               newBoundary.status = 4;
               if (12 === request.status) {
                 contentRootSegment.status = 3;
                 var error = request.fatalError;
-              } else (contentRootSegment.status = 4), (error = thrownValue$84);
+              } else (contentRootSegment.status = 4), (error = thrownValue$85);
               var thrownInfo = getThrownInfo(task.componentStack);
               if (
                 "object" === typeof error &&
@@ -7036,8 +7264,9 @@ function renderElement(request, task, keyPath, type, props, ref) {
                 (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);
             }
             var suspendedFallbackTask = createRenderTask(
               request,
@@ -7056,6 +7285,7 @@ function renderElement(request, task, keyPath, type, props, ref) {
               ),
               task.context,
               task.treeContext,
+              task.row,
               task.componentStack
             );
             pushComponentStack(suspendedFallbackTask);
@@ -7072,7 +7302,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,
@@ -7084,7 +7314,7 @@ function renderElement(request, task, keyPath, type, props, ref) {
             request,
             task,
             keyPath,
-            children$jscomp$0,
+            children$jscomp$1,
             0 !== localIdCounter,
             actionStateCounter,
             actionStateMatchingIndex
@@ -7095,8 +7325,8 @@ function renderElement(request, task, keyPath, type, props, ref) {
           return;
         case REACT_PROVIDER_TYPE:
         case REACT_CONTEXT_TYPE:
-          var children$jscomp$1 = props.children,
-            prevKeyPath$jscomp$5 = task.keyPath,
+          var children$jscomp$2 = props.children,
+            prevKeyPath$jscomp$6 = task.keyPath,
             nextValue = props.value;
           var prevValue = type._currentValue2;
           type._currentValue2 = nextValue;
@@ -7111,7 +7341,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 = currentActiveSnapshot;
           if (null === prevSnapshot)
             throw Error(
@@ -7121,15 +7351,15 @@ function renderElement(request, task, keyPath, type, props, ref) {
           var JSCompiler_inline_result$jscomp$3 = (currentActiveSnapshot =
             prevSnapshot.parent);
           task.context = JSCompiler_inline_result$jscomp$3;
-          task.keyPath = prevKeyPath$jscomp$5;
+          task.keyPath = prevKeyPath$jscomp$6;
           return;
         case REACT_CONSUMER_TYPE:
           var render = props.children,
             newChildren = render(type._context._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 init = type._init;
@@ -7272,6 +7502,7 @@ function retryNode(request, task) {
                         null === node$jscomp$0[4] ? null : node$jscomp$0[4][3];
                       var prevKeyPath = task.keyPath,
                         prevContext = task.formatContext,
+                        prevRow = task.row,
                         previousReplaySet = task.replay,
                         parentBoundary = task.blockedBoundary,
                         parentHoistableState = task.hoistableState,
@@ -7282,12 +7513,14 @@ function retryNode(request, task) {
                         2 > task.formatContext.insertionMode
                           ? createSuspenseBoundary(
                               request,
+                              task.row,
                               fallbackAbortSet,
                               createPreambleState(),
                               createPreambleState()
                             )
                           : createSuspenseBoundary(
                               request,
+                              task.row,
                               fallbackAbortSet,
                               null,
                               null
@@ -7301,6 +7534,7 @@ function retryNode(request, task) {
                         request.resumableState,
                         prevContext
                       );
+                      task.row = null;
                       task.replay = {
                         nodes: replay,
                         slots: name,
@@ -7342,7 +7576,8 @@ function retryNode(request, task) {
                           (task.hoistableState = parentHoistableState),
                           (task.replay = previousReplaySet),
                           (task.keyPath = prevKeyPath),
-                          (task.formatContext = prevContext);
+                          (task.formatContext = prevContext),
+                          (task.row = prevRow);
                       }
                       task = createReplayTask(
                         request,
@@ -7364,6 +7599,7 @@ function retryNode(request, task) {
                         ),
                         task.context,
                         task.treeContext,
+                        task.row,
                         task.componentStack
                       );
                       pushComponentStack(task);
@@ -7440,25 +7676,25 @@ function retryNode(request, task) {
           node._currentValue2,
           childIndex
         );
-      task = Object.prototype.toString.call(node);
+      childIndex = Object.prototype.toString.call(node);
       throw Error(
         "Objects are not valid as a React child (found: " +
-          ("[object Object]" === task
+          ("[object Object]" === childIndex
             ? "object with keys {" + Object.keys(node).join(", ") + "}"
-            : task) +
+            : childIndex) +
           "). If you meant to render a collection of children, use an array instead."
       );
     }
     if ("string" === typeof node)
-      (task = task.blockedSegment),
-        null !== task &&
-          (task.chunks.push(escapeTextForBrowser(node)),
-          (task.lastPushedText = !1));
+      (childIndex = task.blockedSegment),
+        null !== childIndex &&
+          (childIndex.chunks.push(escapeTextForBrowser(node)),
+          (childIndex.lastPushedText = !1));
     else if ("number" === typeof node || "bigint" === typeof node)
-      (task = task.blockedSegment),
-        null !== task &&
-          (task.chunks.push(escapeTextForBrowser("" + node)),
-          (task.lastPushedText = !1));
+      (childIndex = task.blockedSegment),
+        null !== childIndex &&
+          (childIndex.chunks.push(escapeTextForBrowser("" + node)),
+          (childIndex.lastPushedText = !1));
   }
 }
 function renderChildrenArray(request, task, children, childIndex) {
@@ -7574,9 +7810,9 @@ function trackPostpone(request, trackedPostpones, task, segment) {
         addToReplayParent(segment, boundaryKeyPath[0], trackedPostpones);
         return;
       }
-      var boundaryNode$101 = trackedPostpones.workingMap.get(boundaryKeyPath);
-      void 0 === boundaryNode$101
-        ? ((boundaryNode$101 = [
+      var boundaryNode$111 = trackedPostpones.workingMap.get(boundaryKeyPath);
+      void 0 === boundaryNode$111
+        ? ((boundaryNode$111 = [
             boundaryKeyPath[1],
             boundaryKeyPath[2],
             children,
@@ -7584,13 +7820,13 @@ function trackPostpone(request, trackedPostpones, task, segment) {
             fallbackReplayNode,
             boundary.rootSegmentID
           ]),
-          trackedPostpones.workingMap.set(boundaryKeyPath, boundaryNode$101),
+          trackedPostpones.workingMap.set(boundaryKeyPath, boundaryNode$111),
           addToReplayParent(
-            boundaryNode$101,
+            boundaryNode$111,
             boundaryKeyPath[0],
             trackedPostpones
           ))
-        : ((boundaryKeyPath = boundaryNode$101),
+        : ((boundaryKeyPath = boundaryNode$111),
           (boundaryKeyPath[4] = fallbackReplayNode),
           (boundaryKeyPath[5] = boundary.rootSegmentID));
     }
@@ -7659,6 +7895,7 @@ function spawnNewSuspendedReplayTask(request, task, thenableState) {
     task.formatContext,
     task.context,
     task.treeContext,
+    task.row,
     task.componentStack
   );
 }
@@ -7688,6 +7925,7 @@ function spawnNewSuspendedRenderTask(request, task, thenableState) {
     task.formatContext,
     task.context,
     task.treeContext,
+    task.row,
     task.componentStack
   );
 }
@@ -7742,15 +7980,15 @@ function renderNode(request, task, node, childIndex) {
       chunkLength = segment.chunks.length;
     try {
       return renderNodeDestructive(request, task, node, childIndex);
-    } catch (thrownValue$113) {
+    } catch (thrownValue$123) {
       if (
         (resetHooksState(),
         (segment.children.length = childrenLength),
         (segment.chunks.length = chunkLength),
         (childIndex =
-          thrownValue$113 === SuspenseException
+          thrownValue$123 === SuspenseException
             ? getSuspendedThenable()
-            : thrownValue$113),
+            : thrownValue$123),
         "object" === typeof childIndex && null !== childIndex)
       ) {
         if ("function" === typeof childIndex.then) {
@@ -7839,9 +8077,10 @@ function erroredReplay(
   );
 }
 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,
@@ -7868,6 +8107,7 @@ function abortRemainingReplayNodes(
         errorDigest = errorDigest$jscomp$0,
         resumedBoundary = createSuspenseBoundary(
           request,
+          null,
           new Set(),
           null,
           null
@@ -7901,6 +8141,10 @@ function abortTask(task, request, error) {
     if (6 === segment.status) return;
     segment.status = 3;
   }
+  var row = task.row;
+  null !== row &&
+    0 === --row.pendingTasks &&
+    finishSuspenseListRow(request, row);
   var errorInfo = getThrownInfo(task.componentStack);
   if (null === boundary) {
     if (13 !== request.status && 14 !== request.status) {
@@ -7913,7 +8157,7 @@ function abortTask(task, request, error) {
             null !== boundary && null !== segment
               ? (logPostpone(request, error.message, errorInfo),
                 trackPostpone(request, boundary, task, segment),
-                finishedTask(request, null, segment))
+                finishedTask(request, null, row, segment))
               : ((task = Error(
                   "The render was aborted with postpone when the shell is incomplete. Reason: " +
                     error.message
@@ -7924,7 +8168,7 @@ function abortTask(task, request, error) {
             ? ((boundary = request.trackedPostpones),
               logRecoverableError(request, error, errorInfo),
               trackPostpone(request, boundary, task, segment),
-              finishedTask(request, null, segment))
+              finishedTask(request, null, row, segment))
             : (logRecoverableError(request, error, errorInfo),
               fatalError(request, error));
         return;
@@ -7951,21 +8195,21 @@ function abortTask(task, request, error) {
     }
   } else {
     boundary.pendingTasks--;
-    var trackedPostpones$116 = request.trackedPostpones;
+    var trackedPostpones$126 = request.trackedPostpones;
     if (4 !== boundary.status) {
-      if (null !== trackedPostpones$116 && null !== segment)
+      if (null !== trackedPostpones$126 && null !== segment)
         return (
           "object" === typeof error &&
           null !== error &&
           error.$$typeof === REACT_POSTPONE_TYPE
             ? logPostpone(request, error.message, errorInfo)
             : logRecoverableError(request, error, errorInfo),
-          trackPostpone(request, trackedPostpones$116, task, segment),
+          trackPostpone(request, trackedPostpones$126, task, segment),
           boundary.fallbackAbortableTasks.forEach(function (fallbackTask) {
             return abortTask(fallbackTask, request, error);
           }),
           boundary.fallbackAbortableTasks.clear(),
-          finishedTask(request, boundary, segment)
+          finishedTask(request, boundary, row, segment)
         );
       boundary.status = 4;
       if (
@@ -7976,7 +8220,7 @@ function abortTask(task, request, error) {
         logPostpone(request, error.message, errorInfo);
         if (null !== request.trackedPostpones && null !== segment) {
           trackPostpone(request, request.trackedPostpones, task, segment);
-          finishedTask(request, task.blockedBoundary, segment);
+          finishedTask(request, task.blockedBoundary, row, segment);
           boundary.fallbackAbortableTasks.forEach(function (fallbackTask) {
             return abortTask(fallbackTask, request, error);
           });
@@ -8091,7 +8335,10 @@ function queueCompletedSegment(boundary, segment) {
     1 === childSegment.status && 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);
   request.allPendingTasks--;
   if (null === boundary) {
     if (null !== segment && segment.parentFlushed) {
@@ -8120,7 +8367,11 @@ function finishedTask(request, boundary, segment) {
                   abortTaskSoft,
                   request
                 ),
-                boundary.fallbackAbortableTasks.clear()),
+                boundary.fallbackAbortableTasks.clear(),
+                (row = boundary.row),
+                null !== row &&
+                  0 === --row.pendingTasks &&
+                  finishSuspenseListRow(request, row)),
               0 === request.pendingRootTasks &&
                 null === request.trackedPostpones &&
                 null !== boundary.contentPreamble &&
@@ -8173,7 +8424,12 @@ function performWork(request$jscomp$1) {
                 );
               task.replay.pendingTasks--;
               task.abortSet.delete(task);
-              finishedTask(request$jscomp$0, task.blockedBoundary, null);
+              finishedTask(
+                request$jscomp$0,
+                task.blockedBoundary,
+                task.row,
+                null
+              );
             } catch (thrownValue) {
               resetHooksState();
               var x =
@@ -8225,7 +8481,12 @@ function performWork(request$jscomp$1) {
                 retryNode(request, task),
                   task.abortSet.delete(task),
                   (segment$jscomp$0.status = 1),
-                  finishedTask(request, task.blockedBoundary, segment$jscomp$0);
+                  finishedTask(
+                    request,
+                    task.blockedBoundary,
+                    task.row,
+                    segment$jscomp$0
+                  );
               } catch (thrownValue) {
                 resetHooksState();
                 segment$jscomp$0.children.length = childrenLength;
@@ -8254,7 +8515,12 @@ function performWork(request$jscomp$1) {
                     task,
                     segment$jscomp$0
                   );
-                  finishedTask(request, task.blockedBoundary, segment$jscomp$0);
+                  finishedTask(
+                    request,
+                    task.blockedBoundary,
+                    task.row,
+                    segment$jscomp$0
+                  );
                 } else {
                   if ("object" === typeof x$jscomp$0 && null !== x$jscomp$0) {
                     if ("function" === typeof x$jscomp$0.then) {
@@ -8268,19 +8534,20 @@ function performWork(request$jscomp$1) {
                       null !== request.trackedPostpones &&
                       x$jscomp$0.$$typeof === REACT_POSTPONE_TYPE
                     ) {
-                      var trackedPostpones$120 = request.trackedPostpones;
+                      var trackedPostpones$130 = request.trackedPostpones;
                       task.abortSet.delete(task);
                       var postponeInfo = getThrownInfo(task.componentStack);
                       logPostpone(request, x$jscomp$0.message, postponeInfo);
                       trackPostpone(
                         request,
-                        trackedPostpones$120,
+                        trackedPostpones$130,
                         task,
                         segment$jscomp$0
                       );
                       finishedTask(
                         request,
                         task.blockedBoundary,
+                        task.row,
                         segment$jscomp$0
                       );
                       break a;
@@ -8289,7 +8556,12 @@ function performWork(request$jscomp$1) {
                   var errorInfo$jscomp$0 = getThrownInfo(task.componentStack);
                   task.abortSet.delete(task);
                   segment$jscomp$0.status = 4;
-                  var boundary = task.blockedBoundary;
+                  var boundary = task.blockedBoundary,
+                    row = task.row;
+                  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
@@ -8317,7 +8589,6 @@ function performWork(request$jscomp$1) {
                           null === request.trackedPostpones &&
                           null !== boundary.contentPreamble &&
                           preparePreamble(request)));
-                  request.allPendingTasks--;
                   0 === request.allPendingTasks && completeAll(request);
                 }
               } finally {
@@ -8463,7 +8734,14 @@ function flushSegment(request, destination, segment, hoistableState) {
     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 &&
@@ -8505,6 +8783,11 @@ function flushSegment(request, destination, segment, hoistableState) {
     ((segment = boundary.contentState),
     segment.styles.forEach(hoistStyleQueueDependency, hoistableState),
     segment.stylesheets.forEach(hoistStylesheetDependency, hoistableState));
+  segment = boundary.row;
+  null !== segment &&
+    500 < boundary.byteSize &&
+    0 === --segment.pendingTasks &&
+    finishSuspenseListRow(request, segment);
   segment = boundary.completedSegments;
   if (1 !== segment.length)
     throw Error(
@@ -8537,6 +8820,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,
@@ -8608,11 +8896,12 @@ function flushCompletedBoundary(request, destination, boundary) {
     ? 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;
 }
@@ -8840,12 +9129,12 @@ function flushCompletedQueues(request, destination) {
       completedBoundaries.splice(0, i);
       var partialBoundaries = request.partialBoundaries;
       for (i = 0; i < partialBoundaries.length; i++) {
-        var boundary$123 = partialBoundaries[i];
+        var boundary$134 = partialBoundaries[i];
         a: {
           clientRenderedBoundaries = request;
           boundary = destination;
-          flushedByteSize = boundary$123.byteSize;
-          var completedSegments = boundary$123.completedSegments;
+          flushedByteSize = boundary$134.byteSize;
+          var completedSegments = boundary$134.completedSegments;
           for (
             JSCompiler_inline_result = 0;
             JSCompiler_inline_result < completedSegments.length;
@@ -8855,7 +9144,7 @@ function flushCompletedQueues(request, destination) {
               !flushPartiallyCompletedSegment(
                 clientRenderedBoundaries,
                 boundary,
-                boundary$123,
+                boundary$134,
                 completedSegments[JSCompiler_inline_result]
               )
             ) {
@@ -8867,7 +9156,7 @@ function flushCompletedQueues(request, destination) {
           completedSegments.splice(0, JSCompiler_inline_result);
           JSCompiler_inline_result$jscomp$0 = writeHoistablesForBoundary(
             boundary,
-            boundary$123.contentState,
+            boundary$134.contentState,
             clientRenderedBoundaries.renderState
           );
         }
@@ -8938,8 +9227,8 @@ function abort(request, reason) {
     }
     null !== request.destination &&
       flushCompletedQueues(request, request.destination);
-  } catch (error$125) {
-    logRecoverableError(request, error$125, {}), fatalError(request, error$125);
+  } catch (error$136) {
+    logRecoverableError(request, error$136, {}), fatalError(request, error$136);
   }
 }
 function addToReplayParent(node, parentKeyPath, trackedPostpones) {
@@ -9250,4 +9539,4 @@ exports.experimental_renderToHTML = function (children, options) {
     });
   });
 };
-exports.version = "19.2.0-experimental-462d08f9-20250517";
+exports.version = "19.2.0-experimental-c4676e72-20250520";