react-dom 19.0.0-rc-100dfd7dab-20240701 → 19.0.0-rc-3da26163a3-20240704

package/cjs/react-dom-server-legacy.browser.development.js

@@ -4139,6 +4139,9 @@
               var JSCompiler_inline_result$jscomp$0 =
                 describeNativeComponentFrame(componentStack.type, !0);
               info = JSCompiler_temp_const + JSCompiler_inline_result$jscomp$0;
+              break;
+            case 3:
+              info += describeBuiltInComponentFrame(componentStack.type);
           }
           componentStack = componentStack.parent;
         } while (componentStack);
@@ -4224,7 +4227,6 @@
         abortSet,
         null,
         rootFormatContext,
-        emptyContextObject,
         null,
         emptyTreeContext,
         null,
@@ -4297,7 +4299,6 @@
       abortSet,
       keyPath,
       formatContext,
-      legacyContext,
       context,
       treeContext,
       componentStack,
@@ -4320,7 +4321,6 @@
         abortSet: abortSet,
         keyPath: keyPath,
         formatContext: formatContext,
-        legacyContext: legacyContext,
         context: context,
         treeContext: treeContext,
         componentStack: componentStack,
@@ -4341,7 +4341,6 @@
       abortSet,
       keyPath,
       formatContext,
-      legacyContext,
       context,
       treeContext,
       componentStack,
@@ -4365,7 +4364,6 @@
         abortSet: abortSet,
         keyPath: keyPath,
         formatContext: formatContext,
-        legacyContext: legacyContext,
         context: context,
         treeContext: treeContext,
         componentStack: componentStack,
@@ -4420,8 +4418,39 @@
         stack: stack
       };
     }
-    function getThrownInfo(request, node) {
-      return node ? { componentStack: getStackByComponentStackNode(node) } : {};
+    function pushServerComponentStack(task, debugInfo) {
+      if (null != debugInfo)
+        for (var i = 0; i < debugInfo.length; i++) {
+          var componentInfo = debugInfo[i];
+          if ("string" === typeof componentInfo.name) {
+            var name = componentInfo.name,
+              env = componentInfo.env;
+            env && (name += " (" + env + ")");
+            task.componentStack = {
+              tag: 3,
+              parent: task.componentStack,
+              type: name,
+              owner: componentInfo.owner,
+              stack: componentInfo.stack
+            };
+          }
+        }
+    }
+    function getThrownInfo(node) {
+      var errorInfo = {};
+      node &&
+        Object.defineProperty(errorInfo, "componentStack", {
+          configurable: !0,
+          enumerable: !0,
+          get: function () {
+            var stack = getStackByComponentStackNode(node);
+            Object.defineProperty(errorInfo, "componentStack", {
+              value: stack
+            });
+            return stack;
+          }
+        });
+      return errorInfo;
     }
     function encodeErrorForBoundary(
       boundary,
@@ -4446,19 +4475,20 @@
       boundary.errorComponentStack = thrownInfo.componentStack;
     }
     function logRecoverableError(request, error$1, errorInfo) {
-      request = request.onError(error$1, errorInfo);
-      if (null != request && "string" !== typeof request)
+      request = request.onError;
+      error$1 = request(error$1, errorInfo);
+      if (null != error$1 && "string" !== typeof error$1)
         error$jscomp$2(
           'onError returned something with a type other than "string". onError should return a string and may return null or undefined but must not return anything else. It received something of type "%s" instead',
-          typeof request
+          typeof error$1
         );
-      else return request;
+      else return error$1;
     }
     function fatalError(request, error) {
-      var onShellError = request.onShellError;
-      onShellError(error);
-      onShellError = request.onFatalError;
+      var onShellError = request.onShellError,
+        onFatalError = request.onFatalError;
       onShellError(error);
+      onFatalError(error);
       null !== request.destination
         ? ((request.status = 2), request.destination.destroy(error))
         : ((request.status = 1), (request.fatalError = error));
@@ -5185,7 +5215,7 @@
               } catch (error$2) {
                 contentRootSegment.status = 4;
                 newBoundary.status = CLIENT_RENDERED;
-                var thrownInfo = getThrownInfo(request, task.componentStack);
+                var thrownInfo = getThrownInfo(task.componentStack);
                 var errorDigest = logRecoverableError(
                   request,
                   error$2,
@@ -5239,7 +5269,6 @@
                 fallbackAbortSet,
                 fallbackKeyPath,
                 task.formatContext,
-                task.legacyContext,
                 task.context,
                 task.treeContext,
                 suspenseComponentStack,
@@ -5442,197 +5471,194 @@
                 props = node$jscomp$0.props,
                 refProp = props.ref;
               var ref = void 0 !== refProp ? refProp : null;
-              refProp = node$jscomp$0._owner;
+              var owner = node$jscomp$0._owner;
+              refProp = task.componentStack;
+              pushServerComponentStack(task, node$jscomp$0._debugInfo);
               var name = getComponentNameFromType(type),
                 keyOrIndex =
                   null == key ? (-1 === childIndex ? 0 : childIndex) : key;
               key = [task.keyPath, name, keyOrIndex];
-              if (null !== task.replay)
-                a: {
-                  var replay = task.replay;
-                  childIndex = replay.nodes;
-                  for (
-                    node$jscomp$0 = 0;
-                    node$jscomp$0 < childIndex.length;
-                    node$jscomp$0++
-                  ) {
-                    var node = childIndex[node$jscomp$0];
-                    if (keyOrIndex === node[1]) {
-                      if (4 === node.length) {
-                        if (null !== name && name !== node[0])
+              if (null !== task.replay) {
+                var replay = task.replay;
+                node$jscomp$0 = replay.nodes;
+                for (
+                  childIndex = 0;
+                  childIndex < node$jscomp$0.length;
+                  childIndex++
+                ) {
+                  var node = node$jscomp$0[childIndex];
+                  if (keyOrIndex === node[1]) {
+                    if (4 === node.length) {
+                      if (null !== name && name !== node[0])
+                        throw Error(
+                          "Expected the resume to render <" +
+                            node[0] +
+                            "> in this slot but instead it rendered <" +
+                            name +
+                            ">. The tree doesn't match so React will fallback to client rendering."
+                        );
+                      var childNodes = node[2];
+                      name = node[3];
+                      keyOrIndex = task.node;
+                      task.replay = {
+                        nodes: childNodes,
+                        slots: name,
+                        pendingTasks: 1
+                      };
+                      try {
+                        renderElement(
+                          request,
+                          task,
+                          key,
+                          type,
+                          props,
+                          ref,
+                          owner,
+                          null
+                        );
+                        if (
+                          1 === task.replay.pendingTasks &&
+                          0 < task.replay.nodes.length
+                        )
                           throw Error(
-                            "Expected the resume to render <" +
-                              node[0] +
-                              "> in this slot but instead it rendered <" +
-                              name +
-                              ">. The tree doesn't match so React will fallback to client rendering."
+                            "Couldn't find all resumable slots by key/index during replaying. The tree doesn't match so React will fallback to client rendering."
                           );
-                        var childNodes = node[2];
+                        task.replay.pendingTasks--;
+                      } catch (x) {
+                        if (
+                          "object" === typeof x &&
+                          null !== x &&
+                          (x === SuspenseException ||
+                            "function" === typeof x.then)
+                        )
+                          throw (
+                            (task.node === keyOrIndex && (task.replay = replay),
+                            x)
+                          );
+                        task.replay.pendingTasks--;
+                        owner = getThrownInfo(task.componentStack);
+                        erroredReplay(
+                          request,
+                          task.blockedBoundary,
+                          x,
+                          owner,
+                          childNodes,
+                          name
+                        );
+                      }
+                      task.replay = replay;
+                    } else {
+                      if (type !== REACT_SUSPENSE_TYPE)
+                        throw Error(
+                          "Expected the resume to render <Suspense> in this slot but instead it rendered <" +
+                            (getComponentNameFromType(type) || "Unknown") +
+                            ">. The tree doesn't match so React will fallback to client rendering."
+                        );
+                      a: {
+                        type = void 0;
+                        ref = task;
+                        var props$jscomp$0 = props;
+                        props = node[5];
+                        replay = node[2];
                         name = node[3];
-                        node = task.node;
-                        task.replay = {
-                          nodes: childNodes,
+                        keyOrIndex = null === node[4] ? [] : node[4][2];
+                        node = null === node[4] ? null : node[4][3];
+                        var previousComponentStack = ref.componentStack;
+                        owner = ref.componentStack =
+                          createBuiltInComponentStack(
+                            ref,
+                            "Suspense",
+                            owner,
+                            null
+                          );
+                        var prevKeyPath = ref.keyPath,
+                          previousReplaySet = ref.replay,
+                          parentBoundary = ref.blockedBoundary,
+                          parentHoistableState = ref.hoistableState,
+                          content = props$jscomp$0.children;
+                        props$jscomp$0 = props$jscomp$0.fallback;
+                        var fallbackAbortSet = new Set(),
+                          resumedBoundary = createSuspenseBoundary(
+                            request,
+                            fallbackAbortSet
+                          );
+                        resumedBoundary.parentFlushed = !0;
+                        resumedBoundary.rootSegmentID = props;
+                        ref.blockedBoundary = resumedBoundary;
+                        ref.hoistableState = resumedBoundary.contentState;
+                        ref.replay = {
+                          nodes: replay,
                           slots: name,
                           pendingTasks: 1
                         };
                         try {
-                          renderElement(
-                            request,
-                            task,
-                            key,
-                            type,
-                            props,
-                            ref,
-                            refProp,
-                            null
-                          );
+                          renderNode(request, ref, content, -1);
                           if (
-                            1 === task.replay.pendingTasks &&
-                            0 < task.replay.nodes.length
+                            1 === ref.replay.pendingTasks &&
+                            0 < ref.replay.nodes.length
                           )
                             throw Error(
                               "Couldn't find all resumable slots by key/index during replaying. The tree doesn't match so React will fallback to client rendering."
                             );
-                          task.replay.pendingTasks--;
-                        } catch (x) {
+                          ref.replay.pendingTasks--;
                           if (
-                            "object" === typeof x &&
-                            null !== x &&
-                            (x === SuspenseException ||
-                              "function" === typeof x.then)
-                          )
-                            throw (
-                              (task.node === node && (task.replay = replay), x)
-                            );
-                          task.replay.pendingTasks--;
-                          refProp = getThrownInfo(request, task.componentStack);
-                          erroredReplay(
-                            request,
-                            task.blockedBoundary,
-                            x,
-                            refProp,
-                            childNodes,
-                            name
-                          );
-                        }
-                        task.replay = replay;
-                      } else {
-                        if (type !== REACT_SUSPENSE_TYPE)
-                          throw Error(
-                            "Expected the resume to render <Suspense> in this slot but instead it rendered <" +
-                              (getComponentNameFromType(type) || "Unknown") +
-                              ">. The tree doesn't match so React will fallback to client rendering."
-                          );
-                        b: {
-                          type = void 0;
-                          ref = key;
-                          var props$jscomp$0 = props;
-                          props = node[5];
-                          key = node[2];
-                          replay = node[3];
-                          name = null === node[4] ? [] : node[4][2];
-                          node = null === node[4] ? null : node[4][3];
-                          keyOrIndex = task.componentStack;
-                          refProp = task.componentStack =
-                            createBuiltInComponentStack(
-                              task,
-                              "Suspense",
-                              refProp,
-                              null
-                            );
-                          var prevKeyPath = task.keyPath,
-                            previousReplaySet = task.replay,
-                            parentBoundary = task.blockedBoundary,
-                            parentHoistableState = task.hoistableState,
-                            content = props$jscomp$0.children;
-                          props$jscomp$0 = props$jscomp$0.fallback;
-                          var fallbackAbortSet = new Set(),
-                            resumedBoundary = createSuspenseBoundary(
+                            0 === resumedBoundary.pendingTasks &&
+                            resumedBoundary.status === PENDING
+                          ) {
+                            resumedBoundary.status = COMPLETED;
+                            request.completedBoundaries.push(resumedBoundary);
+                            break a;
+                          }
+                        } catch (error$3) {
+                          (resumedBoundary.status = CLIENT_RENDERED),
+                            (childNodes = getThrownInfo(ref.componentStack)),
+                            (type = logRecoverableError(
                               request,
-                              fallbackAbortSet
+                              error$3,
+                              childNodes
+                            )),
+                            encodeErrorForBoundary(
+                              resumedBoundary,
+                              type,
+                              error$3,
+                              childNodes,
+                              !1
+                            ),
+                            ref.replay.pendingTasks--,
+                            request.clientRenderedBoundaries.push(
+                              resumedBoundary
                             );
-                          resumedBoundary.parentFlushed = !0;
-                          resumedBoundary.rootSegmentID = props;
-                          task.blockedBoundary = resumedBoundary;
-                          task.hoistableState = resumedBoundary.contentState;
-                          task.replay = {
-                            nodes: key,
-                            slots: replay,
-                            pendingTasks: 1
-                          };
-                          try {
-                            renderNode(request, task, content, -1);
-                            if (
-                              1 === task.replay.pendingTasks &&
-                              0 < task.replay.nodes.length
-                            )
-                              throw Error(
-                                "Couldn't find all resumable slots by key/index during replaying. The tree doesn't match so React will fallback to client rendering."
-                              );
-                            task.replay.pendingTasks--;
-                            if (
-                              0 === resumedBoundary.pendingTasks &&
-                              resumedBoundary.status === PENDING
-                            ) {
-                              resumedBoundary.status = COMPLETED;
-                              request.completedBoundaries.push(resumedBoundary);
-                              break b;
-                            }
-                          } catch (error$3) {
-                            (resumedBoundary.status = CLIENT_RENDERED),
-                              (childNodes = getThrownInfo(
-                                request,
-                                task.componentStack
-                              )),
-                              (type = logRecoverableError(
-                                request,
-                                error$3,
-                                childNodes
-                              )),
-                              encodeErrorForBoundary(
-                                resumedBoundary,
-                                type,
-                                error$3,
-                                childNodes,
-                                !1
-                              ),
-                              task.replay.pendingTasks--,
-                              request.clientRenderedBoundaries.push(
-                                resumedBoundary
-                              );
-                          } finally {
-                            (task.blockedBoundary = parentBoundary),
-                              (task.hoistableState = parentHoistableState),
-                              (task.replay = previousReplaySet),
-                              (task.keyPath = prevKeyPath),
-                              (task.componentStack = keyOrIndex);
-                          }
-                          childNodes = createReplayTask(
-                            request,
-                            null,
-                            { nodes: name, slots: node, pendingTasks: 0 },
-                            props$jscomp$0,
-                            -1,
-                            parentBoundary,
-                            resumedBoundary.fallbackState,
-                            fallbackAbortSet,
-                            [ref[0], "Suspense Fallback", ref[2]],
-                            task.formatContext,
-                            task.legacyContext,
-                            task.context,
-                            task.treeContext,
-                            refProp,
-                            !0
-                          );
-                          request.pingedTasks.push(childNodes);
+                        } finally {
+                          (ref.blockedBoundary = parentBoundary),
+                            (ref.hoistableState = parentHoistableState),
+                            (ref.replay = previousReplaySet),
+                            (ref.keyPath = prevKeyPath),
+                            (ref.componentStack = previousComponentStack);
                         }
+                        childNodes = createReplayTask(
+                          request,
+                          null,
+                          { nodes: keyOrIndex, slots: node, pendingTasks: 0 },
+                          props$jscomp$0,
+                          -1,
+                          parentBoundary,
+                          resumedBoundary.fallbackState,
+                          fallbackAbortSet,
+                          [key[0], "Suspense Fallback", key[2]],
+                          ref.formatContext,
+                          ref.context,
+                          ref.treeContext,
+                          owner,
+                          !0
+                        );
+                        request.pingedTasks.push(childNodes);
                       }
-                      childIndex.splice(node$jscomp$0, 1);
-                      break a;
                     }
+                    node$jscomp$0.splice(childIndex, 1);
+                    break;
                   }
                 }
-              else
+              } else
                 renderElement(
                   request,
                   task,
@@ -5640,24 +5666,27 @@
                   type,
                   props,
                   ref,
-                  refProp,
+                  owner,
                   null
                 );
+              task.componentStack = refProp;
               return;
             case REACT_PORTAL_TYPE:
               throw Error(
                 "Portals are not currently supported by the server renderer. Render them conditionally so that they only appear on the client render."
               );
             case REACT_LAZY_TYPE:
-              childNodes = task.componentStack;
-              task.componentStack = createBuiltInComponentStack(
-                task,
-                "Lazy",
-                null,
-                null
-              );
+              refProp = task.componentStack;
+              pushServerComponentStack(task, node$jscomp$0._debugInfo);
+              task.componentStack === refProp &&
+                (task.componentStack = createBuiltInComponentStack(
+                  task,
+                  "Lazy",
+                  null,
+                  null
+                ));
               node$jscomp$0 = callLazyInitInDEV(node$jscomp$0);
-              task.componentStack = childNodes;
+              task.componentStack = refProp;
               renderNodeDestructive(request, task, node$jscomp$0, childIndex);
               return;
           }
@@ -5666,22 +5695,21 @@
             return;
           }
           null === node$jscomp$0 || "object" !== typeof node$jscomp$0
-            ? (refProp = null)
-            : ((childNodes =
+            ? (childNodes = null)
+            : ((refProp =
                 (MAYBE_ITERATOR_SYMBOL &&
                   node$jscomp$0[MAYBE_ITERATOR_SYMBOL]) ||
                 node$jscomp$0["@@iterator"]),
-              (refProp = "function" === typeof childNodes ? childNodes : null));
-          if (refProp && (childNodes = refProp.call(node$jscomp$0))) {
-            if (childNodes === node$jscomp$0) {
+              (childNodes = "function" === typeof refProp ? refProp : null));
+          if (childNodes && (refProp = childNodes.call(node$jscomp$0))) {
+            if (refProp === node$jscomp$0) {
               if (
                 -1 !== childIndex ||
                 null === task.componentStack ||
                 1 !== task.componentStack.tag ||
                 "[object GeneratorFunction]" !==
                   Object.prototype.toString.call(task.componentStack.type) ||
-                "[object Generator]" !==
-                  Object.prototype.toString.call(childNodes)
+                "[object Generator]" !== Object.prototype.toString.call(refProp)
               )
                 didWarnAboutGenerators ||
                   error$jscomp$2(
@@ -5689,32 +5717,36 @@
                   ),
                   (didWarnAboutGenerators = !0);
             } else
-              node$jscomp$0.entries !== refProp ||
+              node$jscomp$0.entries !== childNodes ||
                 didWarnAboutMaps ||
                 (error$jscomp$2(
                   "Using Maps as children is not supported. Use an array of keyed ReactElements instead."
                 ),
                 (didWarnAboutMaps = !0));
-            node$jscomp$0 = childNodes.next();
+            node$jscomp$0 = refProp.next();
             if (!node$jscomp$0.done) {
-              refProp = [];
+              childNodes = [];
               do
-                refProp.push(node$jscomp$0.value),
-                  (node$jscomp$0 = childNodes.next());
+                childNodes.push(node$jscomp$0.value),
+                  (node$jscomp$0 = refProp.next());
               while (!node$jscomp$0.done);
-              renderChildrenArray(request, task, refProp, childIndex);
+              renderChildrenArray(request, task, childNodes, childIndex);
             }
             return;
           }
           if ("function" === typeof node$jscomp$0.then)
             return (
               (task.thenableState = null),
-              renderNodeDestructive(
+              (refProp = task.componentStack),
+              pushServerComponentStack(task, node$jscomp$0._debugInfo),
+              (node$jscomp$0 = renderNodeDestructive(
                 request,
                 task,
                 unwrapThenable(node$jscomp$0),
                 childIndex
-              )
+              )),
+              (task.componentStack = refProp),
+              node$jscomp$0
             );
           if (node$jscomp$0.$$typeof === REACT_CONTEXT_TYPE)
             return renderNodeDestructive(
@@ -5723,43 +5755,43 @@
               node$jscomp$0._currentValue2,
               childIndex
             );
-          childIndex = Object.prototype.toString.call(node$jscomp$0);
+          task = Object.prototype.toString.call(node$jscomp$0);
           throw Error(
             "Objects are not valid as a React child (found: " +
-              ("[object Object]" === childIndex
+              ("[object Object]" === task
                 ? "object with keys {" +
                   Object.keys(node$jscomp$0).join(", ") +
                   "}"
-                : childIndex) +
+                : task) +
               "). If you meant to render a collection of children, use an array instead."
           );
         }
         "string" === typeof node$jscomp$0
-          ? ((childIndex = task.blockedSegment),
-            null !== childIndex &&
-              (childIndex.lastPushedText = pushTextInstance(
-                childIndex.chunks,
+          ? ((task = task.blockedSegment),
+            null !== task &&
+              (task.lastPushedText = pushTextInstance(
+                task.chunks,
                 node$jscomp$0,
                 request.renderState,
-                childIndex.lastPushedText
+                task.lastPushedText
               )))
           : "number" === typeof node$jscomp$0 ||
             "bigint" === typeof node$jscomp$0
-          ? ((childIndex = task.blockedSegment),
-            null !== childIndex &&
-              (childIndex.lastPushedText = pushTextInstance(
-                childIndex.chunks,
+          ? ((task = task.blockedSegment),
+            null !== task &&
+              (task.lastPushedText = pushTextInstance(
+                task.chunks,
                 "" + node$jscomp$0,
                 request.renderState,
-                childIndex.lastPushedText
+                task.lastPushedText
               )))
           : ("function" === typeof node$jscomp$0 &&
-              ((childIndex =
+              ((task =
                 node$jscomp$0.displayName || node$jscomp$0.name || "Component"),
               error$jscomp$2(
                 "Functions are not valid as a React child. This may happen if you return %s instead of <%s /> from render. Or maybe you meant to call this function rather than return it.",
-                childIndex,
-                childIndex
+                task,
+                task
               )),
             "symbol" === typeof node$jscomp$0 &&
               error$jscomp$2(
@@ -5769,7 +5801,9 @@
       }
     }
     function renderChildrenArray(request$jscomp$0, task, children, childIndex) {
-      var prevKeyPath = task.keyPath;
+      var prevKeyPath = task.keyPath,
+        previousComponentStack = task.componentStack;
+      pushServerComponentStack(task, task.node._debugInfo);
       if (
         -1 !== childIndex &&
         ((task.keyPath = [task.keyPath, "Fragment", childIndex]),
@@ -5803,7 +5837,7 @@
               )
                 throw x;
               task.replay.pendingTasks--;
-              children = getThrownInfo(request$jscomp$0, task.componentStack);
+              children = getThrownInfo(task.componentStack);
               erroredReplay(
                 request$jscomp$0,
                 task.blockedBoundary,
@@ -5819,6 +5853,7 @@
           }
         }
         task.keyPath = prevKeyPath;
+        task.componentStack = previousComponentStack;
         return;
       }
       replay = task.treeContext;
@@ -5844,6 +5879,7 @@
         }
         task.treeContext = replay;
         task.keyPath = prevKeyPath;
+        task.componentStack = previousComponentStack;
         return;
       }
       for (j = 0; j < replayNodes; j++) {
@@ -5937,6 +5973,7 @@
       }
       task.treeContext = replay;
       task.keyPath = prevKeyPath;
+      task.componentStack = previousComponentStack;
     }
     function untrackBoundary(request, boundary) {
       request = request.trackedPostpones;
@@ -5949,7 +5986,6 @@
     }
     function renderNode(request, task, node, childIndex) {
       var previousFormatContext = task.formatContext,
-        previousLegacyContext = task.legacyContext,
         previousContext = task.context,
         previousKeyPath = task.keyPath,
         previousTreeContext = task.treeContext,
@@ -5981,7 +6017,6 @@
               task.abortSet,
               task.keyPath,
               task.formatContext,
-              task.legacyContext,
               task.context,
               task.treeContext,
               null !== task.componentStack ? task.componentStack.parent : null,
@@ -5989,7 +6024,6 @@
             ).ping;
             node.then(request, request);
             task.formatContext = previousFormatContext;
-            task.legacyContext = previousLegacyContext;
             task.context = previousContext;
             task.keyPath = previousKeyPath;
             task.treeContext = previousTreeContext;
@@ -6039,7 +6073,6 @@
               task.abortSet,
               task.keyPath,
               task.formatContext,
-              task.legacyContext,
               task.context,
               task.treeContext,
               null !== task.componentStack ? task.componentStack.parent : null,
@@ -6047,7 +6080,6 @@
             ).ping;
             node.then(request, request);
             task.formatContext = previousFormatContext;
-            task.legacyContext = previousLegacyContext;
             task.context = previousContext;
             task.keyPath = previousKeyPath;
             task.treeContext = previousTreeContext;
@@ -6058,7 +6090,6 @@
         }
       }
       task.formatContext = previousFormatContext;
-      task.legacyContext = previousLegacyContext;
       task.context = previousContext;
       task.keyPath = previousKeyPath;
       task.treeContext = previousTreeContext;
@@ -6189,7 +6220,7 @@
         boundary.pendingTasks--,
           boundary.status !== CLIENT_RENDERED &&
             ((boundary.status = CLIENT_RENDERED),
-            (task = getThrownInfo(request, task.componentStack)),
+            (task = getThrownInfo(task.componentStack)),
             (segment = logRecoverableError(request, error, task)),
             encodeErrorForBoundary(boundary, segment, error, task, !0),
             untrackBoundary(request, boundary),
@@ -6400,10 +6431,7 @@
                   } else {
                     request.replay.pendingTasks--;
                     request.abortSet.delete(request);
-                    var errorInfo = getThrownInfo(
-                      request$jscomp$0,
-                      request.componentStack
-                    );
+                    var errorInfo = getThrownInfo(request.componentStack);
                     erroredReplay(
                       request$jscomp$0,
                       request.blockedBoundary,
@@ -6473,7 +6501,6 @@
                         task$jscomp$0.componentStack.parent);
                   } else {
                     var errorInfo$jscomp$0 = getThrownInfo(
-                      request,
                       task$jscomp$0.componentStack
                     );
                     task$jscomp$0.abortSet.delete(task$jscomp$0);
@@ -8561,5 +8588,5 @@
         'The server used "renderToString" which does not support Suspense. If you intended for this Suspense boundary to render the fallback content on the server consider throwing an Error somewhere within the Suspense boundary. If you intended to have the server wait for the suspended component please switch to "renderToReadableStream" which supports Suspense on the server'
       );
     };
-    exports.version = "19.0.0-rc-100dfd7dab-20240701";
+    exports.version = "19.0.0-rc-3da26163a3-20240704";
   })();