react-dom 19.1.0-canary-cbbe8666-20250213 → 19.1.0-canary-e670e72f-20250214

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

@@ -5416,6 +5416,24 @@ function describeNativeComponentFrame(fn, construct) {
   "function" === typeof fn && componentFrameCache.set(fn, sampleLines);
   return sampleLines;
 }
+function formatOwnerStack(error) {
+  var prevPrepareStackTrace = Error.prepareStackTrace;
+  Error.prepareStackTrace = void 0;
+  error = error.stack;
+  Error.prepareStackTrace = prevPrepareStackTrace;
+  error.startsWith("Error: react-stack-top-frame\n") &&
+    (error = error.slice(29));
+  prevPrepareStackTrace = error.indexOf("\n");
+  -1 !== prevPrepareStackTrace &&
+    (error = error.slice(prevPrepareStackTrace + 1));
+  prevPrepareStackTrace = error.indexOf("react-stack-bottom-frame");
+  -1 !== prevPrepareStackTrace &&
+    (prevPrepareStackTrace = error.lastIndexOf("\n", prevPrepareStackTrace));
+  if (-1 !== prevPrepareStackTrace)
+    error = error.slice(0, prevPrepareStackTrace);
+  else return "";
+  return error;
+}
 function describeComponentStackByType(type) {
   if ("string" === typeof type) return describeBuiltInComponentFrame(type);
   if ("function" === typeof type)
@@ -5455,18 +5473,6 @@ function describeComponentStackByType(type) {
   }
   return "";
 }
-function getStackByComponentStackNode(componentStack) {
-  try {
-    var info = "";
-    do
-      (info += describeComponentStackByType(componentStack.type)),
-        (componentStack = componentStack.parent);
-    while (componentStack);
-    return info;
-  } catch (x) {
-    return "\nError generating stack: " + x.message + "\n" + x.stack;
-  }
-}
 var callComponent = {
     "react-stack-bottom-frame": function (Component, props, secondArg) {
       return Component(props, secondArg);
@@ -5617,7 +5623,9 @@ function createRequest(
     null,
     emptyTreeContext,
     null,
-    !1
+    !1,
+    emptyContextObject,
+    null
   );
   pushComponentStack(children);
   resumableState.pingedTasks.push(children);
@@ -5677,7 +5685,9 @@ function createRenderTask(
   context,
   treeContext,
   componentStack,
-  isFallback
+  isFallback,
+  legacyContext,
+  debugTask
 ) {
   request.allPendingTasks++;
   null === blockedBoundary
@@ -5703,6 +5713,7 @@ function createRenderTask(
     thenableState: thenableState,
     isFallback: isFallback
   };
+  task.debugTask = debugTask;
   abortSet.add(task);
   return task;
 }
@@ -5720,7 +5731,9 @@ function createReplayTask(
   context,
   treeContext,
   componentStack,
-  isFallback
+  isFallback,
+  legacyContext,
+  debugTask
 ) {
   request.allPendingTasks++;
   null === blockedBoundary
@@ -5747,6 +5760,7 @@ function createReplayTask(
     thenableState: thenableState,
     isFallback: isFallback
   };
+  task.debugTask = debugTask;
   abortSet.add(task);
   return task;
 }
@@ -5773,21 +5787,63 @@ function createPendingSegment(
   };
 }
 function getCurrentStackInDEV() {
-  return null === currentTaskInDEV || null === currentTaskInDEV.componentStack
-    ? ""
-    : getStackByComponentStackNode(currentTaskInDEV.componentStack);
+  if (null === currentTaskInDEV || null === currentTaskInDEV.componentStack)
+    return "";
+  var componentStack = currentTaskInDEV.componentStack;
+  try {
+    var info = "";
+    if ("string" === typeof componentStack.type)
+      info += describeBuiltInComponentFrame(componentStack.type);
+    else if ("function" === typeof componentStack.type) {
+      if (!componentStack.owner) {
+        var JSCompiler_temp_const = info,
+          fn = componentStack.type,
+          name = fn ? fn.displayName || fn.name : "";
+        var JSCompiler_inline_result = name
+          ? describeBuiltInComponentFrame(name)
+          : "";
+        info = JSCompiler_temp_const + JSCompiler_inline_result;
+      }
+    } else
+      componentStack.owner ||
+        (info += describeComponentStackByType(componentStack.type));
+    for (; componentStack; )
+      (JSCompiler_temp_const = null),
+        null != componentStack.debugStack
+          ? (JSCompiler_temp_const = formatOwnerStack(
+              componentStack.debugStack
+            ))
+          : ((JSCompiler_inline_result = componentStack),
+            null != JSCompiler_inline_result.stack &&
+              (JSCompiler_temp_const =
+                "string" !== typeof JSCompiler_inline_result.stack
+                  ? (JSCompiler_inline_result.stack = formatOwnerStack(
+                      JSCompiler_inline_result.stack
+                    ))
+                  : JSCompiler_inline_result.stack)),
+        (componentStack = componentStack.owner) &&
+          JSCompiler_temp_const &&
+          (info += "\n" + JSCompiler_temp_const);
+    var JSCompiler_inline_result$jscomp$0 = info;
+  } catch (x) {
+    JSCompiler_inline_result$jscomp$0 =
+      "\nError generating stack: " + x.message + "\n" + x.stack;
+  }
+  return JSCompiler_inline_result$jscomp$0;
 }
 function pushServerComponentStack(task, debugInfo) {
   if (null != debugInfo)
     for (var i = 0; i < debugInfo.length; i++) {
       var componentInfo = debugInfo[i];
       "string" === typeof componentInfo.name &&
-        (task.componentStack = {
+        void 0 !== componentInfo.debugStack &&
+        ((task.componentStack = {
           parent: task.componentStack,
           type: componentInfo,
           owner: componentInfo.owner,
-          stack: null
-        });
+          stack: componentInfo.debugStack
+        }),
+        (task.debugTask = componentInfo.debugTask));
     }
 }
 function pushComponentStack(task) {
@@ -5796,13 +5852,15 @@ function pushComponentStack(task) {
     switch (node.$$typeof) {
       case REACT_ELEMENT_TYPE:
         var type = node.type,
-          owner = node._owner;
+          owner = node._owner,
+          stack = node._debugStack;
         pushServerComponentStack(task, node._debugInfo);
+        task.debugTask = node._debugTask;
         task.componentStack = {
           parent: task.componentStack,
           type: type,
           owner: owner,
-          stack: null
+          stack: stack
         };
         break;
       case REACT_LAZY_TYPE:
@@ -5813,14 +5871,24 @@ function pushComponentStack(task) {
           pushServerComponentStack(task, node._debugInfo);
     }
 }
-function getThrownInfo(node) {
+function getThrownInfo(node$jscomp$0) {
   var errorInfo = {};
-  node &&
+  node$jscomp$0 &&
     Object.defineProperty(errorInfo, "componentStack", {
       configurable: !0,
       enumerable: !0,
       get: function () {
-        var stack = getStackByComponentStackNode(node);
+        try {
+          var info = "",
+            node = node$jscomp$0;
+          do
+            (info += describeComponentStackByType(node.type)),
+              (node = node.parent);
+          while (node);
+          var stack = info;
+        } catch (x) {
+          stack = "\nError generating stack: " + x.message + "\n" + x.stack;
+        }
         Object.defineProperty(errorInfo, "componentStack", { value: stack });
         return stack;
       }
@@ -5849,9 +5917,11 @@ function encodeErrorForBoundary(
   boundary.errorStack = null !== error ? wasAborted + error : null;
   boundary.errorComponentStack = thrownInfo.componentStack;
 }
-function logRecoverableError(request, error, errorInfo) {
+function logRecoverableError(request, error, errorInfo, debugTask) {
   request = request.onError;
-  error = request(error, errorInfo);
+  error = debugTask
+    ? debugTask.run(request.bind(null, error, errorInfo))
+    : request(error, errorInfo);
   if (null != error && "string" !== typeof error)
     console.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',
@@ -5859,11 +5929,13 @@ function logRecoverableError(request, error, errorInfo) {
     );
   else return error;
 }
-function fatalError(request, error) {
-  var onShellError = request.onShellError,
-    onFatalError = request.onFatalError;
-  onShellError(error);
-  onFatalError(error);
+function fatalError(request, error, errorInfo, debugTask) {
+  errorInfo = request.onShellError;
+  var onFatalError = request.onFatalError;
+  debugTask
+    ? (debugTask.run(errorInfo.bind(null, error)),
+      debugTask.run(onFatalError.bind(null, error)))
+    : (errorInfo(error), onFatalError(error));
   null !== request.destination
     ? ((request.status = CLOSED), closeWithError(request.destination, error))
     : ((request.status = 13), (request.fatalError = error));
@@ -6404,7 +6476,9 @@ function renderElement(request, task, keyPath, type, props, ref) {
           task.context,
           task.treeContext,
           task.componentStack,
-          task.isFallback
+          task.isFallback,
+          emptyContextObject,
+          task.debugTask
         );
         pushComponentStack(preambleTask);
         request.pingedTasks.push(preambleTask);
@@ -6578,7 +6652,9 @@ function renderElement(request, task, keyPath, type, props, ref) {
               task.context,
               task.treeContext,
               task.componentStack,
-              task.isFallback
+              task.isFallback,
+              emptyContextObject,
+              task.debugTask
             );
             pushComponentStack(suspendedPrimaryTask);
             request.pingedTasks.push(suspendedPrimaryTask);
@@ -6613,7 +6689,12 @@ function renderElement(request, task, keyPath, type, props, ref) {
                 var error = request.fatalError;
               } else (contentRootSegment.status = 4), (error = thrownValue$2);
               var thrownInfo = getThrownInfo(task.componentStack);
-              var errorDigest = logRecoverableError(request, error, thrownInfo);
+              var errorDigest = logRecoverableError(
+                request,
+                error,
+                thrownInfo,
+                task.debugTask
+              );
               encodeErrorForBoundary(
                 newBoundary,
                 errorDigest,
@@ -6644,7 +6725,9 @@ function renderElement(request, task, keyPath, type, props, ref) {
               task.context,
               task.treeContext,
               task.componentStack,
-              !0
+              !0,
+              emptyContextObject,
+              task.debugTask
             );
             pushComponentStack(suspendedFallbackTask);
             request.pingedTasks.push(suspendedFallbackTask);
@@ -6796,15 +6879,172 @@ function resumeNode(request, task, segmentId, node, childIndex) {
     (task.replay = prevReplay), (task.blockedSegment = null);
   }
 }
+function replayElement(
+  request,
+  task,
+  keyPath,
+  name,
+  keyOrIndex,
+  childIndex,
+  type,
+  props,
+  ref,
+  replay
+) {
+  childIndex = replay.nodes;
+  for (var i = 0; i < childIndex.length; i++) {
+    var node = childIndex[i];
+    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];
+        node = node[3];
+        name = task.node;
+        task.replay = { nodes: childNodes, slots: node, pendingTasks: 1 };
+        try {
+          renderElement(request, task, keyPath, type, props, ref);
+          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--;
+        } catch (x) {
+          if (
+            "object" === typeof x &&
+            null !== x &&
+            (x === SuspenseException || "function" === typeof x.then)
+          )
+            throw (task.node === name && (task.replay = replay), x);
+          task.replay.pendingTasks--;
+          type = getThrownInfo(task.componentStack);
+          props = request;
+          request = task.blockedBoundary;
+          keyPath = x;
+          ref = node;
+          node = logRecoverableError(props, keyPath, type, task.debugTask);
+          abortRemainingReplayNodes(
+            props,
+            request,
+            childNodes,
+            ref,
+            keyPath,
+            node,
+            type,
+            !1
+          );
+        }
+        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: {
+          replay = void 0;
+          type = node[5];
+          ref = node[2];
+          name = node[3];
+          keyOrIndex = null === node[4] ? [] : node[4][2];
+          node = null === node[4] ? null : node[4][3];
+          var prevKeyPath = task.keyPath,
+            previousReplaySet = task.replay,
+            parentBoundary = task.blockedBoundary,
+            parentHoistableState = task.hoistableState,
+            content = props.children,
+            fallback = props.fallback,
+            fallbackAbortSet = new Set();
+          props =
+            task.formatContext.insertionMode < HTML_MODE
+              ? createSuspenseBoundary(
+                  request,
+                  fallbackAbortSet,
+                  createPreambleState(),
+                  createPreambleState()
+                )
+              : createSuspenseBoundary(request, fallbackAbortSet, null, null);
+          props.parentFlushed = !0;
+          props.rootSegmentID = type;
+          task.blockedBoundary = props;
+          task.hoistableState = props.contentState;
+          task.keyPath = keyPath;
+          task.replay = { nodes: ref, slots: name, 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 === props.pendingTasks && props.status === PENDING) {
+              props.status = COMPLETED;
+              request.completedBoundaries.push(props);
+              break a;
+            }
+          } catch (error) {
+            (props.status = CLIENT_RENDERED),
+              (childNodes = getThrownInfo(task.componentStack)),
+              (replay = logRecoverableError(
+                request,
+                error,
+                childNodes,
+                task.debugTask
+              )),
+              encodeErrorForBoundary(props, replay, error, childNodes, !1),
+              task.replay.pendingTasks--,
+              request.clientRenderedBoundaries.push(props);
+          } finally {
+            (task.blockedBoundary = parentBoundary),
+              (task.hoistableState = parentHoistableState),
+              (task.replay = previousReplaySet),
+              (task.keyPath = prevKeyPath);
+          }
+          props = createReplayTask(
+            request,
+            null,
+            { nodes: keyOrIndex, slots: node, pendingTasks: 0 },
+            fallback,
+            -1,
+            parentBoundary,
+            props.fallbackState,
+            fallbackAbortSet,
+            [keyPath[0], "Suspense Fallback", keyPath[2]],
+            task.formatContext,
+            task.context,
+            task.treeContext,
+            task.componentStack,
+            !0,
+            emptyContextObject,
+            task.debugTask
+          );
+          pushComponentStack(props);
+          request.pingedTasks.push(props);
+        }
+      }
+      childIndex.splice(i, 1);
+      break;
+    }
+  }
+}
 function renderNodeDestructive(request, task, node, childIndex) {
   null !== task.replay && "number" === typeof task.replay.slots
     ? resumeNode(request, task, task.replay.slots, node, childIndex)
     : ((task.node = node),
       (task.childIndex = childIndex),
       (node = task.componentStack),
+      (childIndex = task.debugTask),
       pushComponentStack(task),
       retryNode(request, task),
-      (task.componentStack = node));
+      (task.componentStack = node),
+      (task.debugTask = childIndex));
 }
 function retryNode(request, task) {
   var node = task.node,
@@ -6814,175 +7054,56 @@ function retryNode(request, task) {
       switch (node.$$typeof) {
         case REACT_ELEMENT_TYPE:
           var type = node.type,
-            key = node.key,
-            props = node.props;
-          node = props.ref;
-          var ref = void 0 !== node ? node : null,
-            name = getComponentNameFromType(type),
-            keyOrIndex =
-              null == key ? (-1 === childIndex ? 0 : childIndex) : key,
-            keyPath = [task.keyPath, name, keyOrIndex];
-          if (null !== task.replay) {
-            var replay = task.replay;
-            childIndex = replay.nodes;
-            for (node = 0; node < childIndex.length; node++)
-              if (((key = childIndex[node]), keyOrIndex === key[1])) {
-                if (4 === key.length) {
-                  if (null !== name && name !== key[0])
-                    throw Error(
-                      "Expected the resume to render <" +
-                        key[0] +
-                        "> in this slot but instead it rendered <" +
-                        name +
-                        ">. The tree doesn't match so React will fallback to client rendering."
-                    );
-                  var childNodes = key[2];
-                  key = key[3];
-                  name = task.node;
-                  task.replay = {
-                    nodes: childNodes,
-                    slots: key,
-                    pendingTasks: 1
-                  };
-                  try {
-                    renderElement(request, task, keyPath, type, props, ref);
-                    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--;
-                  } catch (x) {
-                    if (
-                      "object" === typeof x &&
-                      null !== x &&
-                      (x === SuspenseException || "function" === typeof x.then)
-                    )
-                      throw (task.node === name && (task.replay = replay), x);
-                    task.replay.pendingTasks--;
-                    props = getThrownInfo(task.componentStack);
-                    erroredReplay(
-                      request,
-                      task.blockedBoundary,
-                      x,
-                      props,
-                      childNodes,
-                      key
-                    );
-                  }
-                  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 = key[5];
-                    replay = key[2];
-                    name = key[3];
-                    keyOrIndex = null === key[4] ? [] : key[4][2];
-                    key = null === key[4] ? null : key[4][3];
-                    var prevKeyPath = task.keyPath,
-                      previousReplaySet = task.replay,
-                      parentBoundary = task.blockedBoundary,
-                      parentHoistableState = task.hoistableState,
-                      content = props.children,
-                      fallback = props.fallback,
-                      fallbackAbortSet = new Set();
-                    props =
-                      task.formatContext.insertionMode < HTML_MODE
-                        ? createSuspenseBoundary(
-                            request,
-                            fallbackAbortSet,
-                            createPreambleState(),
-                            createPreambleState()
-                          )
-                        : createSuspenseBoundary(
-                            request,
-                            fallbackAbortSet,
-                            null,
-                            null
-                          );
-                    props.parentFlushed = !0;
-                    props.rootSegmentID = ref;
-                    task.blockedBoundary = props;
-                    task.hoistableState = props.contentState;
-                    task.keyPath = keyPath;
-                    task.replay = {
-                      nodes: replay,
-                      slots: name,
-                      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 === props.pendingTasks &&
-                        props.status === PENDING
-                      ) {
-                        props.status = COMPLETED;
-                        request.completedBoundaries.push(props);
-                        break a;
-                      }
-                    } catch (error) {
-                      (props.status = CLIENT_RENDERED),
-                        (childNodes = getThrownInfo(task.componentStack)),
-                        (type = logRecoverableError(
-                          request,
-                          error,
-                          childNodes
-                        )),
-                        encodeErrorForBoundary(
-                          props,
-                          type,
-                          error,
-                          childNodes,
-                          !1
-                        ),
-                        task.replay.pendingTasks--,
-                        request.clientRenderedBoundaries.push(props);
-                    } finally {
-                      (task.blockedBoundary = parentBoundary),
-                        (task.hoistableState = parentHoistableState),
-                        (task.replay = previousReplaySet),
-                        (task.keyPath = prevKeyPath);
-                    }
-                    childNodes = createReplayTask(
-                      request,
-                      null,
-                      { nodes: keyOrIndex, slots: key, pendingTasks: 0 },
-                      fallback,
-                      -1,
-                      parentBoundary,
-                      props.fallbackState,
-                      fallbackAbortSet,
-                      [keyPath[0], "Suspense Fallback", keyPath[2]],
-                      task.formatContext,
-                      task.context,
-                      task.treeContext,
-                      task.componentStack,
-                      !0
-                    );
-                    pushComponentStack(childNodes);
-                    request.pingedTasks.push(childNodes);
-                  }
-                }
-                childIndex.splice(node, 1);
-                break;
-              }
-          } else renderElement(request, task, keyPath, type, props, ref);
+            key = node.key;
+          node = node.props;
+          var refProp = node.ref;
+          refProp = void 0 !== refProp ? refProp : null;
+          var debugTask = task.debugTask,
+            name = getComponentNameFromType(type);
+          key = null == key ? (-1 === childIndex ? 0 : childIndex) : key;
+          var keyPath = [task.keyPath, name, key];
+          null !== task.replay
+            ? debugTask
+              ? debugTask.run(
+                  replayElement.bind(
+                    null,
+                    request,
+                    task,
+                    keyPath,
+                    name,
+                    key,
+                    childIndex,
+                    type,
+                    node,
+                    refProp,
+                    task.replay
+                  )
+                )
+              : replayElement(
+                  request,
+                  task,
+                  keyPath,
+                  name,
+                  key,
+                  childIndex,
+                  type,
+                  node,
+                  refProp,
+                  task.replay
+                )
+            : debugTask
+              ? debugTask.run(
+                  renderElement.bind(
+                    null,
+                    request,
+                    task,
+                    keyPath,
+                    type,
+                    node,
+                    refProp
+                  )
+                )
+              : renderElement(request, task, keyPath, type, node, refProp);
           return;
         case REACT_PORTAL_TYPE:
           throw Error(
@@ -6999,20 +7120,20 @@ function retryNode(request, task) {
         return;
       }
       null === node || "object" !== typeof node
-        ? (props = null)
-        : ((childNodes =
+        ? (key = null)
+        : ((type =
             (MAYBE_ITERATOR_SYMBOL && node[MAYBE_ITERATOR_SYMBOL]) ||
             node["@@iterator"]),
-          (props = "function" === typeof childNodes ? childNodes : null));
-      if (props && (childNodes = props.call(node))) {
-        if (childNodes === node) {
+          (key = "function" === typeof type ? type : null));
+      if (key && (type = key.call(node))) {
+        if (type === node) {
           if (
             -1 !== childIndex ||
             null === task.componentStack ||
             "function" !== typeof task.componentStack.type ||
             "[object GeneratorFunction]" !==
               Object.prototype.toString.call(task.componentStack.type) ||
-            "[object Generator]" !== Object.prototype.toString.call(childNodes)
+            "[object Generator]" !== Object.prototype.toString.call(type)
           )
             didWarnAboutGenerators ||
               console.error(
@@ -7020,18 +7141,18 @@ function retryNode(request, task) {
               ),
               (didWarnAboutGenerators = !0);
         } else
-          node.entries !== props ||
+          node.entries !== key ||
             didWarnAboutMaps ||
             (console.error(
               "Using Maps as children is not supported. Use an array of keyed ReactElements instead."
             ),
             (didWarnAboutMaps = !0));
-        node = childNodes.next();
+        node = type.next();
         if (!node.done) {
-          props = [];
-          do props.push(node.value), (node = childNodes.next());
+          key = [];
+          do key.push(node.value), (node = type.next());
           while (!node.done);
-          renderChildrenArray(request, task, props, childIndex);
+          renderChildrenArray(request, task, key, childIndex);
         }
         return;
       }
@@ -7047,39 +7168,39 @@ function retryNode(request, task) {
           node._currentValue,
           childIndex
         );
-      childIndex = Object.prototype.toString.call(node);
+      request = Object.prototype.toString.call(node);
       throw Error(
         "Objects are not valid as a React child (found: " +
-          ("[object Object]" === childIndex
+          ("[object Object]" === request
             ? "object with keys {" + Object.keys(node).join(", ") + "}"
-            : childIndex) +
+            : request) +
           "). If you meant to render a collection of children, use an array instead."
       );
     }
     "string" === typeof node
-      ? ((childIndex = task.blockedSegment),
-        null !== childIndex &&
-          (childIndex.lastPushedText = pushTextInstance(
-            childIndex.chunks,
+      ? ((task = task.blockedSegment),
+        null !== task &&
+          (task.lastPushedText = pushTextInstance(
+            task.chunks,
             node,
             request.renderState,
-            childIndex.lastPushedText
+            task.lastPushedText
           )))
       : "number" === typeof node || "bigint" === typeof node
-        ? ((childIndex = task.blockedSegment),
-          null !== childIndex &&
-            (childIndex.lastPushedText = pushTextInstance(
-              childIndex.chunks,
+        ? ((task = task.blockedSegment),
+          null !== task &&
+            (task.lastPushedText = pushTextInstance(
+              task.chunks,
               "" + node,
               request.renderState,
-              childIndex.lastPushedText
+              task.lastPushedText
             )))
         : ("function" === typeof node &&
-            ((childIndex = node.displayName || node.name || "Component"),
+            ((request = node.displayName || node.name || "Component"),
             console.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
+              request,
+              request
             )),
           "symbol" === typeof node &&
             console.error(
@@ -7088,9 +7209,10 @@ function retryNode(request, task) {
             ));
   }
 }
-function renderChildrenArray(request$jscomp$0, task, children, childIndex) {
+function renderChildrenArray(request, task, children, childIndex) {
   var prevKeyPath = task.keyPath,
     previousComponentStack = task.componentStack;
+  var previousDebugTask = task.debugTask;
   pushServerComponentStack(task, task.node._debugInfo);
   if (
     -1 !== childIndex &&
@@ -7108,7 +7230,7 @@ function renderChildrenArray(request$jscomp$0, task, children, childIndex) {
         node = node[3];
         task.replay = { nodes: childIndex, slots: node, pendingTasks: 1 };
         try {
-          renderChildrenArray(request$jscomp$0, task, children, -1);
+          renderChildrenArray(request, task, children, -1);
           if (1 === task.replay.pendingTasks && 0 < task.replay.nodes.length)
             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."
@@ -7122,14 +7244,25 @@ function renderChildrenArray(request$jscomp$0, task, children, childIndex) {
           )
             throw x;
           task.replay.pendingTasks--;
-          children = getThrownInfo(task.componentStack);
-          erroredReplay(
-            request$jscomp$0,
-            task.blockedBoundary,
-            x,
+          var thrownInfo = getThrownInfo(task.componentStack);
+          children = task.blockedBoundary;
+          var error = x,
+            resumeSlots = node;
+          node = logRecoverableError(
+            request,
+            error,
+            thrownInfo,
+            task.debugTask
+          );
+          abortRemainingReplayNodes(
+            request,
             children,
             childIndex,
-            node
+            resumeSlots,
+            error,
+            node,
+            thrownInfo,
+            !1
           );
         }
         task.replay = replay;
@@ -7139,6 +7272,7 @@ function renderChildrenArray(request$jscomp$0, task, children, childIndex) {
     }
     task.keyPath = prevKeyPath;
     task.componentStack = previousComponentStack;
+    task.debugTask = previousDebugTask;
     return;
   }
   replay = task.treeContext;
@@ -7147,97 +7281,93 @@ function renderChildrenArray(request$jscomp$0, task, children, childIndex) {
     null !== task.replay &&
     ((j = task.replay.slots), null !== j && "object" === typeof j)
   ) {
-    for (childIndex = 0; childIndex < replayNodes; childIndex++) {
-      node = children[childIndex];
-      task.treeContext = pushTreeContext(replay, replayNodes, childIndex);
-      var resumeSegmentID = j[childIndex];
-      "number" === typeof resumeSegmentID
-        ? (resumeNode(
-            request$jscomp$0,
-            task,
-            resumeSegmentID,
-            node,
-            childIndex
-          ),
-          delete j[childIndex])
-        : renderNode(request$jscomp$0, task, node, childIndex);
-    }
+    for (childIndex = 0; childIndex < replayNodes; childIndex++)
+      (node = children[childIndex]),
+        (task.treeContext = pushTreeContext(replay, replayNodes, childIndex)),
+        (error = j[childIndex]),
+        "number" === typeof error
+          ? (resumeNode(request, task, error, node, childIndex),
+            delete j[childIndex])
+          : renderNode(request, task, node, childIndex);
     task.treeContext = replay;
     task.keyPath = prevKeyPath;
     task.componentStack = previousComponentStack;
+    task.debugTask = previousDebugTask;
     return;
   }
   for (j = 0; j < replayNodes; j++) {
     childIndex = children[j];
-    var request = request$jscomp$0;
+    resumeSlots = request;
     node = task;
-    resumeSegmentID = childIndex;
+    error = childIndex;
     if (
-      null !== resumeSegmentID &&
-      "object" === typeof resumeSegmentID &&
-      (resumeSegmentID.$$typeof === REACT_ELEMENT_TYPE ||
-        resumeSegmentID.$$typeof === REACT_PORTAL_TYPE) &&
-      resumeSegmentID._store &&
-      ((!resumeSegmentID._store.validated && null == resumeSegmentID.key) ||
-        2 === resumeSegmentID._store.validated)
+      null !== error &&
+      "object" === typeof error &&
+      (error.$$typeof === REACT_ELEMENT_TYPE ||
+        error.$$typeof === REACT_PORTAL_TYPE) &&
+      error._store &&
+      ((!error._store.validated && null == error.key) ||
+        2 === error._store.validated)
     ) {
-      if ("object" !== typeof resumeSegmentID._store)
+      if ("object" !== typeof error._store)
         throw Error(
           "React Component in warnForMissingKey should have a _store. This error is likely caused by a bug in React. Please file an issue."
         );
-      resumeSegmentID._store.validated = 1;
-      var didWarnForKey = request.didWarnForKey;
-      null == didWarnForKey &&
-        (didWarnForKey = request.didWarnForKey = new WeakSet());
-      request = node.componentStack;
-      if (null !== request && !didWarnForKey.has(request)) {
-        didWarnForKey.add(request);
-        var componentName = getComponentNameFromType(resumeSegmentID.type);
-        didWarnForKey = resumeSegmentID._owner;
-        var parentOwner = request.owner;
-        request = "";
+      error._store.validated = 1;
+      thrownInfo = resumeSlots.didWarnForKey;
+      null == thrownInfo &&
+        (thrownInfo = resumeSlots.didWarnForKey = new WeakSet());
+      resumeSlots = node.componentStack;
+      if (null !== resumeSlots && !thrownInfo.has(resumeSlots)) {
+        thrownInfo.add(resumeSlots);
+        var componentName = getComponentNameFromType(error.type);
+        thrownInfo = error._owner;
+        var parentOwner = resumeSlots.owner;
+        resumeSlots = "";
         if (parentOwner && "undefined" !== typeof parentOwner.type) {
           var name = getComponentNameFromType(parentOwner.type);
-          name && (request = "\n\nCheck the render method of `" + name + "`.");
+          name &&
+            (resumeSlots = "\n\nCheck the render method of `" + name + "`.");
         }
-        request ||
+        resumeSlots ||
           (componentName &&
-            (request =
+            (resumeSlots =
               "\n\nCheck the top-level render call using <" +
               componentName +
               ">."));
         componentName = "";
-        null != didWarnForKey &&
-          parentOwner !== didWarnForKey &&
+        null != thrownInfo &&
+          parentOwner !== thrownInfo &&
           ((parentOwner = null),
-          "undefined" !== typeof didWarnForKey.type
-            ? (parentOwner = getComponentNameFromType(didWarnForKey.type))
-            : "string" === typeof didWarnForKey.name &&
-              (parentOwner = didWarnForKey.name),
+          "undefined" !== typeof thrownInfo.type
+            ? (parentOwner = getComponentNameFromType(thrownInfo.type))
+            : "string" === typeof thrownInfo.name &&
+              (parentOwner = thrownInfo.name),
           parentOwner &&
             (componentName =
               " It was passed a child from " + parentOwner + "."));
-        didWarnForKey = node.componentStack;
+        thrownInfo = node.componentStack;
         node.componentStack = {
           parent: node.componentStack,
-          type: resumeSegmentID.type,
-          owner: resumeSegmentID._owner,
-          stack: null
+          type: error.type,
+          owner: error._owner,
+          stack: error._debugStack
         };
         console.error(
           'Each child in a list should have a unique "key" prop.%s%s See https://react.dev/link/warning-keys for more information.',
-          request,
+          resumeSlots,
           componentName
         );
-        node.componentStack = didWarnForKey;
+        node.componentStack = thrownInfo;
       }
     }
     task.treeContext = pushTreeContext(replay, replayNodes, j);
-    renderNode(request$jscomp$0, task, childIndex, j);
+    renderNode(request, task, childIndex, j);
   }
   task.treeContext = replay;
   task.keyPath = prevKeyPath;
   task.componentStack = previousComponentStack;
+  task.debugTask = previousDebugTask;
 }
 function untrackBoundary(request, boundary) {
   request = request.trackedPostpones;
@@ -7263,7 +7393,9 @@ function spawnNewSuspendedReplayTask(request, task, thenableState) {
     task.context,
     task.treeContext,
     task.componentStack,
-    task.isFallback
+    task.isFallback,
+    emptyContextObject,
+    task.debugTask
   );
 }
 function spawnNewSuspendedRenderTask(request, task, thenableState) {
@@ -7293,7 +7425,9 @@ function spawnNewSuspendedRenderTask(request, task, thenableState) {
     task.context,
     task.treeContext,
     task.componentStack,
-    task.isFallback
+    task.isFallback,
+    emptyContextObject,
+    task.debugTask
   );
 }
 function renderNode(request, task, node, childIndex) {
@@ -7302,6 +7436,7 @@ function renderNode(request, task, node, childIndex) {
     previousKeyPath = task.keyPath,
     previousTreeContext = task.treeContext,
     previousComponentStack = task.componentStack,
+    previousDebugTask = task.debugTask,
     segment = task.blockedSegment;
   if (null === segment)
     try {
@@ -7324,6 +7459,7 @@ function renderNode(request, task, node, childIndex) {
           task.keyPath = previousKeyPath;
           task.treeContext = previousTreeContext;
           task.componentStack = previousComponentStack;
+          task.debugTask = previousDebugTask;
           switchContext(previousContext);
           return;
         }
@@ -7336,6 +7472,7 @@ function renderNode(request, task, node, childIndex) {
           task.keyPath = previousKeyPath;
           task.treeContext = previousTreeContext;
           task.componentStack = previousComponentStack;
+          task.debugTask = previousDebugTask;
           switchContext(previousContext);
           return;
         }
@@ -7366,6 +7503,7 @@ function renderNode(request, task, node, childIndex) {
           task.keyPath = previousKeyPath;
           task.treeContext = previousTreeContext;
           task.componentStack = previousComponentStack;
+          task.debugTask = previousDebugTask;
           switchContext(previousContext);
           return;
         }
@@ -7378,6 +7516,7 @@ function renderNode(request, task, node, childIndex) {
           task.keyPath = previousKeyPath;
           task.treeContext = previousTreeContext;
           task.componentStack = previousComponentStack;
+          task.debugTask = previousDebugTask;
           switchContext(previousContext);
           return;
         }
@@ -7391,26 +7530,6 @@ function renderNode(request, task, node, childIndex) {
   switchContext(previousContext);
   throw node;
 }
-function erroredReplay(
-  request,
-  boundary,
-  error,
-  errorInfo,
-  replayNodes,
-  resumeSlots
-) {
-  var errorDigest = logRecoverableError(request, error, errorInfo);
-  abortRemainingReplayNodes(
-    request,
-    boundary,
-    replayNodes,
-    resumeSlots,
-    error,
-    errorDigest,
-    errorInfo,
-    !1
-  );
-}
 function abortTaskSoft(task) {
   var boundary = task.blockedBoundary;
   task = task.blockedSegment;
@@ -7498,14 +7617,14 @@ function abortTask(task, request, error) {
     if (13 !== request.status && request.status !== CLOSED) {
       boundary = task.replay;
       if (null === boundary) {
-        logRecoverableError(request, error, segment);
-        fatalError(request, error);
+        logRecoverableError(request, error, segment, null);
+        fatalError(request, error, segment, null);
         return;
       }
       boundary.pendingTasks--;
       0 === boundary.pendingTasks &&
         0 < boundary.nodes.length &&
-        ((task = logRecoverableError(request, error, segment)),
+        ((task = logRecoverableError(request, error, segment, null)),
         abortRemainingReplayNodes(
           request,
           null,
@@ -7523,7 +7642,7 @@ function abortTask(task, request, error) {
     boundary.pendingTasks--,
       boundary.status !== CLIENT_RENDERED &&
         ((boundary.status = CLIENT_RENDERED),
-        (task = logRecoverableError(request, error, segment)),
+        (task = logRecoverableError(request, error, segment, null)),
         (boundary.status = CLIENT_RENDERED),
         encodeErrorForBoundary(boundary, task, error, segment, !0),
         untrackBoundary(request, boundary),
@@ -7594,7 +7713,7 @@ function safelyEmitEarlyPreloads(request, shellComplete) {
       }
     }
   } catch (error) {
-    logRecoverableError(request, error, {});
+    logRecoverableError(request, error, {}, null);
   }
 }
 function completeShell(request) {
@@ -7669,24 +7788,24 @@ function finishedTask(request, boundary, segment) {
   request.allPendingTasks--;
   0 === request.allPendingTasks && completeAll(request);
 }
-function performWork(request$jscomp$1) {
-  if (request$jscomp$1.status !== CLOSED && 13 !== request$jscomp$1.status) {
+function performWork(request$jscomp$2) {
+  if (request$jscomp$2.status !== CLOSED && 13 !== request$jscomp$2.status) {
     var prevContext = currentActiveSnapshot,
       prevDispatcher = ReactSharedInternals.H;
     ReactSharedInternals.H = HooksDispatcher;
     var prevAsyncDispatcher = ReactSharedInternals.A;
     ReactSharedInternals.A = DefaultAsyncDispatcher;
     var prevRequest = currentRequest;
-    currentRequest = request$jscomp$1;
+    currentRequest = request$jscomp$2;
     var prevGetCurrentStackImpl = ReactSharedInternals.getCurrentStack;
     ReactSharedInternals.getCurrentStack = getCurrentStackInDEV;
     var prevResumableState = currentResumableState;
-    currentResumableState = request$jscomp$1.resumableState;
+    currentResumableState = request$jscomp$2.resumableState;
     try {
-      var pingedTasks = request$jscomp$1.pingedTasks,
+      var pingedTasks = request$jscomp$2.pingedTasks,
         i;
       for (i = 0; i < pingedTasks.length; i++) {
-        var request = request$jscomp$1,
+        var request = request$jscomp$2,
           task = pingedTasks[i],
           segment = task.blockedSegment;
         if (null === segment) {
@@ -7734,16 +7853,32 @@ function performWork(request$jscomp$1) {
               } else {
                 request.replay.pendingTasks--;
                 request.abortSet.delete(request);
-                var errorInfo = getThrownInfo(request.componentStack);
-                erroredReplay(
-                  request$jscomp$0,
-                  request.blockedBoundary,
-                  12 === request$jscomp$0.status
-                    ? request$jscomp$0.fatalError
-                    : x,
-                  errorInfo,
-                  request.replay.nodes,
-                  request.replay.slots
+                var errorInfo = getThrownInfo(request.componentStack),
+                  errorDigest = void 0,
+                  request$jscomp$1 = request$jscomp$0,
+                  boundary = request.blockedBoundary,
+                  error$jscomp$0 =
+                    12 === request$jscomp$0.status
+                      ? request$jscomp$0.fatalError
+                      : x,
+                  errorInfo$jscomp$0 = errorInfo,
+                  replayNodes = request.replay.nodes,
+                  resumeSlots = request.replay.slots;
+                errorDigest = logRecoverableError(
+                  request$jscomp$1,
+                  error$jscomp$0,
+                  errorInfo$jscomp$0,
+                  request.debugTask
+                );
+                abortRemainingReplayNodes(
+                  request$jscomp$1,
+                  boundary,
+                  replayNodes,
+                  resumeSlots,
+                  error$jscomp$0,
+                  errorDigest,
+                  errorInfo$jscomp$0,
+                  !1
                 );
                 request$jscomp$0.pendingRootTasks--;
                 0 === request$jscomp$0.pendingRootTasks &&
@@ -7756,94 +7891,97 @@ function performWork(request$jscomp$1) {
               currentTaskInDEV = prevTaskInDEV;
             }
           }
-        } else {
-          request$jscomp$0 = prevTaskInDEV = void 0;
-          var task$jscomp$0 = task,
-            segment$jscomp$0 = segment;
-          if (segment$jscomp$0.status === PENDING) {
-            segment$jscomp$0.status = 6;
-            switchContext(task$jscomp$0.context);
-            request$jscomp$0 = currentTaskInDEV;
-            currentTaskInDEV = task$jscomp$0;
-            var childrenLength = segment$jscomp$0.children.length,
-              chunkLength = segment$jscomp$0.chunks.length;
-            try {
-              retryNode(request, task$jscomp$0),
-                segment$jscomp$0.lastPushedText &&
-                  segment$jscomp$0.textEmbedded &&
-                  segment$jscomp$0.chunks.push("\x3c!-- --\x3e"),
-                task$jscomp$0.abortSet.delete(task$jscomp$0),
-                (segment$jscomp$0.status = COMPLETED),
-                finishedTask(
-                  request,
-                  task$jscomp$0.blockedBoundary,
-                  segment$jscomp$0
-                );
-            } catch (thrownValue) {
-              resetHooksState();
-              segment$jscomp$0.children.length = childrenLength;
-              segment$jscomp$0.chunks.length = chunkLength;
-              var x$jscomp$0 =
-                thrownValue === SuspenseException
-                  ? getSuspendedThenable()
-                  : 12 === request.status
-                    ? request.fatalError
-                    : thrownValue;
-              if (
-                "object" === typeof x$jscomp$0 &&
-                null !== x$jscomp$0 &&
-                "function" === typeof x$jscomp$0.then
-              ) {
-                segment$jscomp$0.status = PENDING;
-                task$jscomp$0.thenableState = getThenableStateAfterSuspending();
-                var ping$jscomp$0 = task$jscomp$0.ping;
-                x$jscomp$0.then(ping$jscomp$0, ping$jscomp$0);
-              } else {
-                var errorInfo$jscomp$0 = getThrownInfo(
-                  task$jscomp$0.componentStack
-                );
-                task$jscomp$0.abortSet.delete(task$jscomp$0);
-                segment$jscomp$0.status = 4;
-                var boundary = task$jscomp$0.blockedBoundary;
-                prevTaskInDEV = logRecoverableError(
-                  request,
-                  x$jscomp$0,
-                  errorInfo$jscomp$0
-                );
-                null === boundary
-                  ? fatalError(request, x$jscomp$0)
-                  : (boundary.pendingTasks--,
-                    boundary.status !== CLIENT_RENDERED &&
-                      ((boundary.status = CLIENT_RENDERED),
-                      encodeErrorForBoundary(
-                        boundary,
-                        prevTaskInDEV,
-                        x$jscomp$0,
-                        errorInfo$jscomp$0,
-                        !1
-                      ),
-                      untrackBoundary(request, boundary),
-                      boundary.parentFlushed &&
-                        request.clientRenderedBoundaries.push(boundary),
-                      0 === request.pendingRootTasks &&
-                        null === request.trackedPostpones &&
-                        null !== boundary.contentPreamble &&
-                        preparePreamble(request)));
-                request.allPendingTasks--;
-                0 === request.allPendingTasks && completeAll(request);
-              }
-            } finally {
-              currentTaskInDEV = request$jscomp$0;
+        } else if (
+          ((request$jscomp$0 = prevTaskInDEV = void 0),
+          (errorDigest = task),
+          (request$jscomp$1 = segment),
+          request$jscomp$1.status === PENDING)
+        ) {
+          request$jscomp$1.status = 6;
+          switchContext(errorDigest.context);
+          request$jscomp$0 = currentTaskInDEV;
+          currentTaskInDEV = errorDigest;
+          var childrenLength = request$jscomp$1.children.length,
+            chunkLength = request$jscomp$1.chunks.length;
+          try {
+            retryNode(request, errorDigest),
+              request$jscomp$1.lastPushedText &&
+                request$jscomp$1.textEmbedded &&
+                request$jscomp$1.chunks.push("\x3c!-- --\x3e"),
+              errorDigest.abortSet.delete(errorDigest),
+              (request$jscomp$1.status = COMPLETED),
+              finishedTask(
+                request,
+                errorDigest.blockedBoundary,
+                request$jscomp$1
+              );
+          } catch (thrownValue) {
+            resetHooksState();
+            request$jscomp$1.children.length = childrenLength;
+            request$jscomp$1.chunks.length = chunkLength;
+            var x$jscomp$0 =
+              thrownValue === SuspenseException
+                ? getSuspendedThenable()
+                : 12 === request.status
+                  ? request.fatalError
+                  : thrownValue;
+            if (
+              "object" === typeof x$jscomp$0 &&
+              null !== x$jscomp$0 &&
+              "function" === typeof x$jscomp$0.then
+            ) {
+              request$jscomp$1.status = PENDING;
+              errorDigest.thenableState = getThenableStateAfterSuspending();
+              var ping$jscomp$0 = errorDigest.ping;
+              x$jscomp$0.then(ping$jscomp$0, ping$jscomp$0);
+            } else {
+              var errorInfo$jscomp$1 = getThrownInfo(
+                errorDigest.componentStack
+              );
+              errorDigest.abortSet.delete(errorDigest);
+              request$jscomp$1.status = 4;
+              var boundary$jscomp$0 = errorDigest.blockedBoundary,
+                debugTask = errorDigest.debugTask;
+              prevTaskInDEV = logRecoverableError(
+                request,
+                x$jscomp$0,
+                errorInfo$jscomp$1,
+                debugTask
+              );
+              null === boundary$jscomp$0
+                ? fatalError(request, x$jscomp$0, errorInfo$jscomp$1, debugTask)
+                : (boundary$jscomp$0.pendingTasks--,
+                  boundary$jscomp$0.status !== CLIENT_RENDERED &&
+                    ((boundary$jscomp$0.status = CLIENT_RENDERED),
+                    encodeErrorForBoundary(
+                      boundary$jscomp$0,
+                      prevTaskInDEV,
+                      x$jscomp$0,
+                      errorInfo$jscomp$1,
+                      !1
+                    ),
+                    untrackBoundary(request, boundary$jscomp$0),
+                    boundary$jscomp$0.parentFlushed &&
+                      request.clientRenderedBoundaries.push(boundary$jscomp$0),
+                    0 === request.pendingRootTasks &&
+                      null === request.trackedPostpones &&
+                      null !== boundary$jscomp$0.contentPreamble &&
+                      preparePreamble(request)));
+              request.allPendingTasks--;
+              0 === request.allPendingTasks && completeAll(request);
             }
+          } finally {
+            currentTaskInDEV = request$jscomp$0;
           }
         }
       }
       pingedTasks.splice(0, i);
-      null !== request$jscomp$1.destination &&
-        flushCompletedQueues(request$jscomp$1, request$jscomp$1.destination);
+      null !== request$jscomp$2.destination &&
+        flushCompletedQueues(request$jscomp$2, request$jscomp$2.destination);
     } catch (error) {
-      logRecoverableError(request$jscomp$1, error, {}),
-        fatalError(request$jscomp$1, error);
+      (pingedTasks = {}),
+        logRecoverableError(request$jscomp$2, error, pingedTasks, null),
+        fatalError(request$jscomp$2, error, pingedTasks, null);
     } finally {
       (currentResumableState = prevResumableState),
         (ReactSharedInternals.H = prevDispatcher),
@@ -8471,18 +8609,20 @@ function abort(request, reason) {
     null !== request.destination &&
       flushCompletedQueues(request, request.destination);
   } catch (error$4) {
-    logRecoverableError(request, error$4, {}), fatalError(request, error$4);
+    (reason = {}),
+      logRecoverableError(request, error$4, reason, null),
+      fatalError(request, error$4, reason, null);
   }
 }
-var isomorphicReactPackageVersion$jscomp$inline_732 = React.version;
+var isomorphicReactPackageVersion$jscomp$inline_740 = React.version;
 if (
-  "19.1.0-canary-cbbe8666-20250213" !==
-  isomorphicReactPackageVersion$jscomp$inline_732
+  "19.1.0-canary-e670e72f-20250214" !==
+  isomorphicReactPackageVersion$jscomp$inline_740
 )
   throw Error(
     'Incompatible React versions: The "react" and "react-dom" packages must have the exact same version. Instead got:\n  - react:      ' +
-      (isomorphicReactPackageVersion$jscomp$inline_732 +
-        "\n  - react-dom:  19.1.0-canary-cbbe8666-20250213\nLearn more: https://react.dev/warnings/version-mismatch")
+      (isomorphicReactPackageVersion$jscomp$inline_740 +
+        "\n  - react-dom:  19.1.0-canary-e670e72f-20250214\nLearn more: https://react.dev/warnings/version-mismatch")
   );
 exports.renderToReadableStream = function (children, options) {
   return new Promise(function (resolve, reject) {
@@ -8537,8 +8677,9 @@ exports.renderToReadableStream = function (children, options) {
                   try {
                     flushCompletedQueues(request, controller);
                   } catch (error) {
-                    logRecoverableError(request, error, {}),
-                      fatalError(request, error);
+                    (controller = {}),
+                      logRecoverableError(request, error, controller, null),
+                      fatalError(request, error, controller, null);
                   }
                 }
               },
@@ -8574,4 +8715,4 @@ exports.renderToReadableStream = function (children, options) {
     startWork(request$jscomp$0);
   });
 };
-exports.version = "19.1.0-canary-cbbe8666-20250213";
+exports.version = "19.1.0-canary-e670e72f-20250214";