react-markup 0.0.0-experimental-c4676e72-20250520 → 0.0.0-experimental-23884812-20250520

package/cjs/react-markup.production.js

@@ -2794,6 +2794,10 @@ function hoistStyleQueueDependency(styleQueue) {
 function hoistStylesheetDependency(stylesheet) {
   this.stylesheets.add(stylesheet);
 }
+function hoistHoistables(parentState, childState) {
+  childState.styles.forEach(hoistStyleQueueDependency, parentState);
+  childState.stylesheets.forEach(hoistStylesheetDependency, parentState);
+}
 var bind = Function.prototype.bind,
   REACT_CLIENT_REFERENCE = Symbol.for("react.client.reference");
 function getComponentNameFromType(type) {
@@ -3615,11 +3619,14 @@ function createSuspenseBoundary(
   };
   null !== row &&
     (row.pendingTasks++,
-    (row = row.boundaries),
-    null !== row &&
+    (contentPreamble = row.boundaries),
+    null !== contentPreamble &&
       (request.allPendingTasks++,
       fallbackAbortableTasks.pendingTasks++,
-      row.push(fallbackAbortableTasks)));
+      contentPreamble.push(fallbackAbortableTasks)),
+    (request = row.inheritedHoistables),
+    null !== request &&
+      hoistHoistables(fallbackAbortableTasks.contentState, request));
   return fallbackAbortableTasks;
 }
 function createRenderTask(
@@ -3788,20 +3795,56 @@ function fatalError(request, error) {
     : ((request.status = 13), (request.fatalError = error));
 }
 function finishSuspenseListRow(request, row) {
-  for (row = row.next; null !== row; ) {
-    var unblockedBoundaries = row.boundaries;
+  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) {
-      row.boundaries = null;
-      for (var i = 0; i < unblockedBoundaries.length; i++)
-        finishedTask(request, unblockedBoundaries[i], null, null);
+      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;
+      }
     }
-    row.pendingTasks--;
-    if (0 < row.pendingTasks) break;
-    row = row.next;
+    allCompleteAndInlinable &&
+      unblockSuspenseListRow(request, togetherRow, togetherRow.hoistables);
   }
 }
 function createSuspenseListRow(previousRow) {
-  var newRow = { pendingTasks: 1, boundaries: null, next: null };
+  var newRow = {
+    pendingTasks: 1,
+    boundaries: null,
+    hoistables: createHoistableState(),
+    inheritedHoistables: null,
+    together: !1,
+    next: null
+  };
   null !== previousRow &&
     0 < previousRow.pendingTasks &&
     (newRow.pendingTasks++,
@@ -3810,21 +3853,22 @@ function createSuspenseListRow(previousRow) {
   return newRow;
 }
 function renderSuspenseListRows(request, task, keyPath, rows, revealOrder) {
-  keyPath = task.keyPath;
-  var prevTreeContext = task.treeContext,
-    prevRow = task.row,
-    totalChildren = rows.length,
-    previousSuspenseListRow = null;
+  var prevKeyPath = task.keyPath,
+    prevTreeContext = task.treeContext,
+    prevRow = task.row;
+  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 < totalChildren; n++) {
-        var i = "backwards" !== revealOrder ? n : totalChildren - 1 - n,
+      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, totalChildren, i);
+        task.treeContext = pushTreeContext(prevTreeContext, keyPath, i);
         var resumeSegmentID = resumeSlots[i];
         "number" === typeof resumeSegmentID
           ? (resumeNode(request, task, resumeSegmentID, node, i),
@@ -3834,30 +3878,26 @@ function renderSuspenseListRows(request, task, keyPath, rows, revealOrder) {
           finishSuspenseListRow(request, previousSuspenseListRow);
       }
     else
-      for (resumeSlots = 0; resumeSlots < totalChildren; resumeSlots++)
+      for (resumeSlots = 0; resumeSlots < keyPath; resumeSlots++)
         (n =
           "backwards" !== revealOrder
             ? resumeSlots
-            : totalChildren - 1 - resumeSlots),
+            : keyPath - 1 - resumeSlots),
           (i = rows[n]),
           (task.row = previousSuspenseListRow =
             createSuspenseListRow(previousSuspenseListRow)),
-          (task.treeContext = pushTreeContext(
-            prevTreeContext,
-            totalChildren,
-            n
-          )),
+          (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 < totalChildren; revealOrder++)
+    for (revealOrder = 0; revealOrder < keyPath; revealOrder++)
       (resumeSlots = rows[revealOrder]),
         (task.row = previousSuspenseListRow =
           createSuspenseListRow(previousSuspenseListRow)),
         (task.treeContext = pushTreeContext(
           prevTreeContext,
-          totalChildren,
+          keyPath,
           revealOrder
         )),
         renderNode(request, task, resumeSlots, revealOrder),
@@ -3867,12 +3907,12 @@ function renderSuspenseListRows(request, task, keyPath, rows, revealOrder) {
     revealOrder = task.blockedSegment;
     resumeSlots = revealOrder.children.length;
     n = revealOrder.chunks.length;
-    for (i = totalChildren - 1; 0 <= i; i--) {
+    for (i = keyPath - 1; 0 <= i; i--) {
       node = rows[i];
       task.row = previousSuspenseListRow = createSuspenseListRow(
         previousSuspenseListRow
       );
-      task.treeContext = pushTreeContext(prevTreeContext, totalChildren, i);
+      task.treeContext = pushTreeContext(prevTreeContext, keyPath, i);
       resumeSegmentID = createPendingSegment(
         request,
         n,
@@ -3904,7 +3944,7 @@ function renderSuspenseListRows(request, task, keyPath, rows, revealOrder) {
     (prevRow.pendingTasks++, (previousSuspenseListRow.next = prevRow));
   task.treeContext = prevTreeContext;
   task.row = prevRow;
-  task.keyPath = keyPath;
+  task.keyPath = prevKeyPath;
 }
 function renderWithHooks(request, task, keyPath, Component, props, secondArg) {
   var prevThenableState = task.thenableState;
@@ -3973,9 +4013,9 @@ function renderElement(request, task, keyPath, type, props, ref) {
       var defaultProps = type.defaultProps;
       if (defaultProps) {
         newProps === props && (newProps = assign({}, newProps, props));
-        for (var propName$35 in defaultProps)
-          void 0 === newProps[propName$35] &&
-            (newProps[propName$35] = defaultProps[propName$35]);
+        for (var propName$36 in defaultProps)
+          void 0 === newProps[propName$36] &&
+            (newProps[propName$36] = defaultProps[propName$36]);
       }
       var JSCompiler_inline_result = newProps;
       var context = emptyContextObject,
@@ -4142,13 +4182,13 @@ function renderElement(request, task, keyPath, type, props, ref) {
         textEmbedded
       );
       segment.lastPushedText = !1;
-      var prevContext$33 = task.formatContext,
-        prevKeyPath$34 = task.keyPath;
+      var prevContext$34 = task.formatContext,
+        prevKeyPath$35 = task.keyPath;
       task.keyPath = keyPath;
       if (
         3 ===
         (task.formatContext = getChildFormatContext(
-          prevContext$33,
+          prevContext$34,
           type,
           props
         )).insertionMode
@@ -4182,8 +4222,8 @@ function renderElement(request, task, keyPath, type, props, ref) {
         pushComponentStack(preambleTask);
         request.pingedTasks.push(preambleTask);
       } else renderNode(request, task, JSCompiler_inline_result$jscomp$2, -1);
-      task.formatContext = prevContext$33;
-      task.keyPath = prevKeyPath$34;
+      task.formatContext = prevContext$34;
+      task.keyPath = prevKeyPath$35;
       a: {
         var target$jscomp$0 = segment.chunks,
           resumableState$jscomp$0 = request.resumableState;
@@ -4208,19 +4248,19 @@ function renderElement(request, task, keyPath, type, props, ref) {
           case "wbr":
             break a;
           case "body":
-            if (1 >= prevContext$33.insertionMode) {
+            if (1 >= prevContext$34.insertionMode) {
               resumableState$jscomp$0.hasBody = !0;
               break a;
             }
             break;
           case "html":
-            if (0 === prevContext$33.insertionMode) {
+            if (0 === prevContext$34.insertionMode) {
               resumableState$jscomp$0.hasHtml = !0;
               break a;
             }
             break;
           case "head":
-            if (1 >= prevContext$33.insertionMode) break a;
+            if (1 >= prevContext$34.insertionMode) break a;
         }
         target$jscomp$0.push(endChunkForTag(type));
       }
@@ -4248,10 +4288,10 @@ function renderElement(request, task, keyPath, type, props, ref) {
           }
         } else if ("hidden" !== props.mode) {
           segment$jscomp$0.lastPushedText = !1;
-          var prevKeyPath$37 = task.keyPath;
+          var prevKeyPath$38 = task.keyPath;
           task.keyPath = keyPath;
           renderNode(request, task, props.children, -1);
-          task.keyPath = prevKeyPath$37;
+          task.keyPath = prevKeyPath$38;
           segment$jscomp$0.lastPushedText = !1;
         }
         return;
@@ -4330,10 +4370,27 @@ function renderElement(request, task, keyPath, type, props, ref) {
               }
             }
           }
-          var prevKeyPath$jscomp$3 = task.keyPath;
-          task.keyPath = keyPath;
-          renderNodeDestructive(request, task, children$jscomp$0, -1);
-          task.keyPath = prevKeyPath$jscomp$3;
+          if ("together" === revealOrder) {
+            var prevKeyPath$32 = 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 = prevKeyPath$32;
+            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:
@@ -4381,7 +4438,7 @@ function renderElement(request, task, keyPath, type, props, ref) {
         } else {
           var prevKeyPath$jscomp$5 = task.keyPath,
             prevContext$jscomp$1 = task.formatContext,
-            prevRow = task.row,
+            prevRow$jscomp$0 = task.row,
             parentBoundary = task.blockedBoundary,
             parentPreamble = task.blockedPreamble,
             parentHoistableState = task.hoistableState,
@@ -4500,18 +4557,21 @@ function renderElement(request, task, keyPath, type, props, ref) {
                 (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)
               ) {
-                null !== prevRow &&
-                  0 === --prevRow.pendingTasks &&
-                  finishSuspenseListRow(request, prevRow);
-                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$20) {
               newBoundary.status = 4;
               if (12 === request.status) {
@@ -4537,7 +4597,7 @@ function renderElement(request, task, keyPath, type, props, ref) {
                 (task.blockedSegment = parentSegment),
                 (task.keyPath = prevKeyPath$jscomp$5),
                 (task.formatContext = prevContext$jscomp$1),
-                (task.row = prevRow);
+                (task.row = prevRow$jscomp$0);
             }
             var suspendedFallbackTask = createRenderTask(
               request,
@@ -5081,9 +5141,9 @@ function trackPostpone(request, trackedPostpones, task, segment) {
         addToReplayParent(segment, boundaryKeyPath[0], trackedPostpones);
         return;
       }
-      var boundaryNode$46 = trackedPostpones.workingMap.get(boundaryKeyPath);
-      void 0 === boundaryNode$46
-        ? ((boundaryNode$46 = [
+      var boundaryNode$47 = trackedPostpones.workingMap.get(boundaryKeyPath);
+      void 0 === boundaryNode$47
+        ? ((boundaryNode$47 = [
             boundaryKeyPath[1],
             boundaryKeyPath[2],
             children,
@@ -5091,13 +5151,13 @@ function trackPostpone(request, trackedPostpones, task, segment) {
             fallbackReplayNode,
             boundary.rootSegmentID
           ]),
-          trackedPostpones.workingMap.set(boundaryKeyPath, boundaryNode$46),
+          trackedPostpones.workingMap.set(boundaryKeyPath, boundaryNode$47),
           addToReplayParent(
-            boundaryNode$46,
+            boundaryNode$47,
             boundaryKeyPath[0],
             trackedPostpones
           ))
-        : ((boundaryKeyPath = boundaryNode$46),
+        : ((boundaryKeyPath = boundaryNode$47),
           (boundaryKeyPath[4] = fallbackReplayNode),
           (boundaryKeyPath[5] = boundary.rootSegmentID));
     }
@@ -5251,15 +5311,15 @@ function renderNode(request, task, node, childIndex) {
       chunkLength = segment.chunks.length;
     try {
       return renderNodeDestructive(request, task, node, childIndex);
-    } catch (thrownValue$58) {
+    } catch (thrownValue$59) {
       if (
         (resetHooksState(),
         (segment.children.length = childrenLength),
         (segment.chunks.length = chunkLength),
         (childIndex =
-          thrownValue$58 === SuspenseException
+          thrownValue$59 === SuspenseException
             ? getSuspendedThenable()
-            : thrownValue$58),
+            : thrownValue$59),
         "object" === typeof childIndex && null !== childIndex)
       ) {
         if ("function" === typeof childIndex.then) {
@@ -5412,10 +5472,6 @@ 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) {
@@ -5428,7 +5484,7 @@ function abortTask(task, request, error) {
             null !== boundary && null !== segment
               ? (logPostpone(request, error.message, errorInfo),
                 trackPostpone(request, boundary, task, segment),
-                finishedTask(request, null, row, segment))
+                finishedTask(request, null, task.row, segment))
               : ((task = Error(
                   "The render was aborted with postpone when the shell is incomplete. Reason: " +
                     error.message
@@ -5439,7 +5495,7 @@ function abortTask(task, request, error) {
             ? ((boundary = request.trackedPostpones),
               logRecoverableError(request, error, errorInfo),
               trackPostpone(request, boundary, task, segment),
-              finishedTask(request, null, row, segment))
+              finishedTask(request, null, task.row, segment))
             : (logRecoverableError(request, error, errorInfo),
               fatalError(request, error));
         return;
@@ -5465,22 +5521,21 @@ function abortTask(task, request, error) {
       0 === request.pendingRootTasks && completeShell(request);
     }
   } else {
-    boundary.pendingTasks--;
-    var trackedPostpones$61 = request.trackedPostpones;
+    var trackedPostpones$62 = request.trackedPostpones;
     if (4 !== boundary.status) {
-      if (null !== trackedPostpones$61 && null !== segment)
+      if (null !== trackedPostpones$62 && 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$61, task, segment),
+          trackPostpone(request, trackedPostpones$62, task, segment),
           boundary.fallbackAbortableTasks.forEach(function (fallbackTask) {
             return abortTask(fallbackTask, request, error);
           }),
           boundary.fallbackAbortableTasks.clear(),
-          finishedTask(request, boundary, row, segment)
+          finishedTask(request, boundary, task.row, segment)
         );
       boundary.status = 4;
       if (
@@ -5491,7 +5546,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, row, segment);
+          finishedTask(request, task.blockedBoundary, task.row, segment);
           boundary.fallbackAbortableTasks.forEach(function (fallbackTask) {
             return abortTask(fallbackTask, request, error);
           });
@@ -5505,11 +5560,20 @@ function abortTask(task, request, error) {
       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);
 }
@@ -5608,8 +5672,9 @@ function queueCompletedSegment(boundary, segment) {
 }
 function finishedTask(request, boundary, row, segment) {
   null !== row &&
-    0 === --row.pendingTasks &&
-    finishSuspenseListRow(request, row);
+    (0 === --row.pendingTasks
+      ? finishSuspenseListRow(request, row)
+      : row.together && tryToResolveTogetherRow(request, row));
   request.allPendingTasks--;
   if (null === boundary) {
     if (null !== segment && segment.parentFlushed) {
@@ -5633,13 +5698,15 @@ function finishedTask(request, boundary, row, segment) {
             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(),
-                (row = boundary.row),
                 null !== row &&
                   0 === --row.pendingTasks &&
                   finishSuspenseListRow(request, row)),
@@ -5647,13 +5714,17 @@ function finishedTask(request, boundary, row, segment) {
                 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) {
@@ -5805,13 +5876,13 @@ function performWork(request$jscomp$1) {
                       null !== request.trackedPostpones &&
                       x$jscomp$0.$$typeof === REACT_POSTPONE_TYPE
                     ) {
-                      var trackedPostpones$65 = request.trackedPostpones;
+                      var trackedPostpones$67 = request.trackedPostpones;
                       task.abortSet.delete(task);
                       var postponeInfo = getThrownInfo(task.componentStack);
                       logPostpone(request, x$jscomp$0.message, postponeInfo);
                       trackPostpone(
                         request,
-                        trackedPostpones$65,
+                        trackedPostpones$67,
                         task,
                         segment$jscomp$0
                       );
@@ -5847,19 +5918,22 @@ function performWork(request$jscomp$1) {
                         x$jscomp$0,
                         errorInfo$jscomp$0
                       ));
-                  null === boundary
-                    ? fatalError(request, x$jscomp$0)
-                    : (boundary.pendingTasks--,
-                      4 !== boundary.status &&
-                        ((boundary.status = 4),
-                        (boundary.errorDigest = request$jscomp$0),
-                        untrackBoundary(request, boundary),
-                        boundary.parentFlushed &&
-                          request.clientRenderedBoundaries.push(boundary),
-                        0 === request.pendingRootTasks &&
-                          null === request.trackedPostpones &&
-                          null !== boundary.contentPreamble &&
-                          preparePreamble(request)));
+                  if (null === boundary) fatalError(request, x$jscomp$0);
+                  else if ((boundary.pendingTasks--, 4 !== boundary.status)) {
+                    boundary.status = 4;
+                    boundary.errorDigest = request$jscomp$0;
+                    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 {
@@ -6024,13 +6098,7 @@ function flushSegment(request, destination, segment, hoistableState) {
         request.renderState,
         boundary.rootSegmentID
       ),
-      hoistableState &&
-        ((boundary = boundary.fallbackState),
-        boundary.styles.forEach(hoistStyleQueueDependency, hoistableState),
-        boundary.stylesheets.forEach(
-          hoistStylesheetDependency,
-          hoistableState
-        )),
+      hoistableState && hoistHoistables(hoistableState, boundary.fallbackState),
       flushSubtree(request, destination, segment, hoistableState),
       destination.push("\x3c!--/$--\x3e")
     );
@@ -6050,10 +6118,7 @@ function flushSegment(request, destination, segment, hoistableState) {
       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 &&
@@ -6400,12 +6465,12 @@ function flushCompletedQueues(request, destination) {
       completedBoundaries.splice(0, i);
       var partialBoundaries = request.partialBoundaries;
       for (i = 0; i < partialBoundaries.length; i++) {
-        var boundary$69 = partialBoundaries[i];
+        var boundary$71 = partialBoundaries[i];
         a: {
           clientRenderedBoundaries = request;
           boundary = destination;
-          flushedByteSize = boundary$69.byteSize;
-          var completedSegments = boundary$69.completedSegments;
+          flushedByteSize = boundary$71.byteSize;
+          var completedSegments = boundary$71.completedSegments;
           for (
             JSCompiler_inline_result = 0;
             JSCompiler_inline_result < completedSegments.length;
@@ -6415,7 +6480,7 @@ function flushCompletedQueues(request, destination) {
               !flushPartiallyCompletedSegment(
                 clientRenderedBoundaries,
                 boundary,
-                boundary$69,
+                boundary$71,
                 completedSegments[JSCompiler_inline_result]
               )
             ) {
@@ -6425,9 +6490,20 @@ function flushCompletedQueues(request, destination) {
               break a;
             }
           completedSegments.splice(0, JSCompiler_inline_result);
+          var row = boundary$71.row;
+          null !== row &&
+            row.together &&
+            1 === boundary$71.pendingTasks &&
+            (1 === row.pendingTasks
+              ? unblockSuspenseListRow(
+                  clientRenderedBoundaries,
+                  row,
+                  row.hoistables
+                )
+              : row.pendingTasks--);
           JSCompiler_inline_result$jscomp$0 = writeHoistablesForBoundary(
             boundary,
-            boundary$69.contentState,
+            boundary$71.contentState,
             clientRenderedBoundaries.renderState
           );
         }
@@ -6498,8 +6574,8 @@ function abort(request, reason) {
     }
     null !== request.destination &&
       flushCompletedQueues(request, request.destination);
-  } catch (error$71) {
-    logRecoverableError(request, error$71, {}), fatalError(request, error$71);
+  } catch (error$73) {
+    logRecoverableError(request, error$73, {}), fatalError(request, error$73);
   }
 }
 function addToReplayParent(node, parentKeyPath, trackedPostpones) {
@@ -6573,4 +6649,4 @@ exports.experimental_renderToHTML = function (children, options) {
     });
   });
 };
-exports.version = "19.2.0-experimental-c4676e72-20250520";
+exports.version = "19.2.0-experimental-23884812-20250520";