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

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

@@ -5366,6 +5366,9 @@ function getStackByComponentStackNode(componentStack) {
             !0
           );
           info = JSCompiler_temp_const + JSCompiler_inline_result$jscomp$0;
+          break;
+        case 3:
+          info += describeBuiltInComponentFrame(componentStack.type);
       }
       componentStack = componentStack.parent;
     } while (componentStack);
@@ -5470,7 +5473,6 @@ function RequestInstance(
     abortSet,
     null,
     rootFormatContext,
-    emptyContextObject,
     null,
     emptyTreeContext,
     null,
@@ -5546,7 +5548,6 @@ function createRenderTask(
   abortSet,
   keyPath,
   formatContext,
-  legacyContext,
   context,
   treeContext,
   componentStack,
@@ -5569,7 +5570,6 @@ function createRenderTask(
     abortSet: abortSet,
     keyPath: keyPath,
     formatContext: formatContext,
-    legacyContext: legacyContext,
     context: context,
     treeContext: treeContext,
     componentStack: componentStack,
@@ -5590,7 +5590,6 @@ function createReplayTask(
   abortSet,
   keyPath,
   formatContext,
-  legacyContext,
   context,
   treeContext,
   componentStack,
@@ -5614,7 +5613,6 @@ function createReplayTask(
     abortSet: abortSet,
     keyPath: keyPath,
     formatContext: formatContext,
-    legacyContext: legacyContext,
     context: context,
     treeContext: treeContext,
     componentStack: componentStack,
@@ -5668,8 +5666,37 @@ function createFunctionComponentStack(task, type, owner, stack) {
     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,
@@ -5694,19 +5721,20 @@ function encodeErrorForBoundary(
   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(
       '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), closeWithError(request.destination, error))
     : ((request.status = 1), (request.fatalError = error));
@@ -6378,7 +6406,7 @@ function renderElement(request, task, keyPath, type, props, ref, owner, stack) {
           } 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, thrownInfo);
             encodeErrorForBoundary(
               newBoundary,
@@ -6424,7 +6452,6 @@ function renderElement(request, task, keyPath, type, props, ref, owner, stack) {
             fallbackAbortSet,
             fallbackKeyPath,
             task.formatContext,
-            task.legacyContext,
             task.context,
             task.treeContext,
             suspenseComponentStack,
@@ -6627,211 +6654,208 @@ function renderNodeDestructive(request, task, node$jscomp$0, childIndex) {
             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(
-                          request,
-                          fallbackAbortSet
-                        );
-                      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);
+                        0 === resumedBoundary.pendingTasks &&
+                        resumedBoundary.status === PENDING
+                      ) {
+                        resumedBoundary.status = COMPLETED;
+                        request.completedBoundaries.push(resumedBoundary);
+                        break a;
                       }
-                      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);
+                    } catch (error$3) {
+                      (resumedBoundary.status = CLIENT_RENDERED),
+                        (childNodes = getThrownInfo(ref.componentStack)),
+                        (type = logRecoverableError(
+                          request,
+                          error$3,
+                          childNodes
+                        )),
+                        encodeErrorForBoundary(
+                          resumedBoundary,
+                          type,
+                          error$3,
+                          childNodes,
+                          !1
+                        ),
+                        ref.replay.pendingTasks--,
+                        request.clientRenderedBoundaries.push(resumedBoundary);
+                    } 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
-            renderElement(request, task, key, type, props, ref, refProp, null);
+          } else
+            renderElement(request, task, key, type, props, ref, 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;
       }
@@ -6840,20 +6864,20 @@ function renderNodeDestructive(request, task, node$jscomp$0, childIndex) {
         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(
@@ -6861,32 +6885,36 @@ function renderNodeDestructive(request, task, node$jscomp$0, childIndex) {
               ),
               (didWarnAboutGenerators = !0);
         } else
-          node$jscomp$0.entries !== refProp ||
+          node$jscomp$0.entries !== childNodes ||
             didWarnAboutMaps ||
             (error(
               "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(
@@ -6895,40 +6923,40 @@ function renderNodeDestructive(request, task, node$jscomp$0, childIndex) {
           node$jscomp$0._currentValue,
           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(
             "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(
@@ -6938,7 +6966,9 @@ function renderNodeDestructive(request, task, node$jscomp$0, childIndex) {
   }
 }
 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]),
@@ -6969,7 +6999,7 @@ function renderChildrenArray(request$jscomp$0, task, children, childIndex) {
           )
             throw x;
           task.replay.pendingTasks--;
-          children = getThrownInfo(request$jscomp$0, task.componentStack);
+          children = getThrownInfo(task.componentStack);
           erroredReplay(
             request$jscomp$0,
             task.blockedBoundary,
@@ -6985,6 +7015,7 @@ function renderChildrenArray(request$jscomp$0, task, children, childIndex) {
       }
     }
     task.keyPath = prevKeyPath;
+    task.componentStack = previousComponentStack;
     return;
   }
   replay = task.treeContext;
@@ -7010,6 +7041,7 @@ function renderChildrenArray(request$jscomp$0, task, children, childIndex) {
     }
     task.treeContext = replay;
     task.keyPath = prevKeyPath;
+    task.componentStack = previousComponentStack;
     return;
   }
   for (j = 0; j < replayNodes; j++) {
@@ -7101,6 +7133,7 @@ function renderChildrenArray(request$jscomp$0, task, children, childIndex) {
   }
   task.treeContext = replay;
   task.keyPath = prevKeyPath;
+  task.componentStack = previousComponentStack;
 }
 function untrackBoundary(request, boundary) {
   request = request.trackedPostpones;
@@ -7113,7 +7146,6 @@ function untrackBoundary(request, boundary) {
 }
 function renderNode(request, task, node, childIndex) {
   var previousFormatContext = task.formatContext,
-    previousLegacyContext = task.legacyContext,
     previousContext = task.context,
     previousKeyPath = task.keyPath,
     previousTreeContext = task.treeContext,
@@ -7145,7 +7177,6 @@ function renderNode(request, task, node, childIndex) {
           task.abortSet,
           task.keyPath,
           task.formatContext,
-          task.legacyContext,
           task.context,
           task.treeContext,
           null !== task.componentStack ? task.componentStack.parent : null,
@@ -7153,7 +7184,6 @@ function renderNode(request, task, node, childIndex) {
         ).ping;
         node.then(request, request);
         task.formatContext = previousFormatContext;
-        task.legacyContext = previousLegacyContext;
         task.context = previousContext;
         task.keyPath = previousKeyPath;
         task.treeContext = previousTreeContext;
@@ -7203,7 +7233,6 @@ function renderNode(request, task, node, childIndex) {
           task.abortSet,
           task.keyPath,
           task.formatContext,
-          task.legacyContext,
           task.context,
           task.treeContext,
           null !== task.componentStack ? task.componentStack.parent : null,
@@ -7211,7 +7240,6 @@ function renderNode(request, task, node, childIndex) {
         ).ping;
         node.then(request, request);
         task.formatContext = previousFormatContext;
-        task.legacyContext = previousLegacyContext;
         task.context = previousContext;
         task.keyPath = previousKeyPath;
         task.treeContext = previousTreeContext;
@@ -7222,7 +7250,6 @@ function renderNode(request, task, node, childIndex) {
     }
   }
   task.formatContext = previousFormatContext;
-  task.legacyContext = previousLegacyContext;
   task.context = previousContext;
   task.keyPath = previousKeyPath;
   task.treeContext = previousTreeContext;
@@ -7352,7 +7379,7 @@ function abortTask(task, request, error) {
     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),
@@ -7556,10 +7583,7 @@ function performWork(request$jscomp$1) {
               } 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,
@@ -7627,7 +7651,6 @@ function performWork(request$jscomp$1) {
                     task$jscomp$0.componentStack.parent);
               } else {
                 var errorInfo$jscomp$0 = getThrownInfo(
-                  request,
                   task$jscomp$0.componentStack
                 );
                 task$jscomp$0.abortSet.delete(task$jscomp$0);
@@ -8181,15 +8204,15 @@ function abort(request, reason) {
     logRecoverableError(request, error$8, {}), fatalError(request, error$8);
   }
 }
-var isomorphicReactPackageVersion$jscomp$inline_739 = React.version;
+var isomorphicReactPackageVersion$jscomp$inline_746 = React.version;
 if (
-  "19.0.0-rc-100dfd7dab-20240701" !==
-  isomorphicReactPackageVersion$jscomp$inline_739
+  "19.0.0-rc-3da26163a3-20240704" !==
+  isomorphicReactPackageVersion$jscomp$inline_746
 )
   throw Error(
     'Incompatible React versions: The "react" and "react-dom" packages must have the exact same version. Instead got:\n  - react:      ' +
-      (isomorphicReactPackageVersion$jscomp$inline_739 +
-        "\n  - react-dom:  19.0.0-rc-100dfd7dab-20240701\nLearn more: https://react.dev/warnings/version-mismatch")
+      (isomorphicReactPackageVersion$jscomp$inline_746 +
+        "\n  - react-dom:  19.0.0-rc-3da26163a3-20240704\nLearn more: https://react.dev/warnings/version-mismatch")
   );
 exports.renderToReadableStream = function (children, options) {
   return new Promise(function (resolve, reject) {
@@ -8278,4 +8301,4 @@ exports.renderToReadableStream = function (children, options) {
     startWork(request$jscomp$0);
   });
 };
-exports.version = "19.0.0-rc-100dfd7dab-20240701";
+exports.version = "19.0.0-rc-3da26163a3-20240704";