@vitejs/plugin-rsc 0.4.34 → 0.5.1

package/dist/vendor/react-server-dom/cjs/react-server-dom-webpack-client.browser.development.js

@@ -11,27 +11,6 @@
 "use strict";
 "production" !== process.env.NODE_ENV &&
   (function () {
-    function _defineProperty(obj, key, value) {
-      a: if ("object" == typeof key && key) {
-        var e = key[Symbol.toPrimitive];
-        if (void 0 !== e) {
-          key = e.call(key, "string");
-          if ("object" != typeof key) break a;
-          throw new TypeError("@@toPrimitive must return a primitive value.");
-        }
-        key = String(key);
-      }
-      key = "symbol" == typeof key ? key : key + "";
-      key in obj
-        ? Object.defineProperty(obj, key, {
-            value: value,
-            enumerable: !0,
-            configurable: !0,
-            writable: !0
-          })
-        : (obj[key] = value);
-      return obj;
-    }
     function resolveClientReference(bundlerConfig, metadata) {
       if (bundlerConfig) {
         var moduleExports = bundlerConfig[metadata[0]];
@@ -172,11 +151,8 @@
       return !0;
     }
     function objectName(object) {
-      return Object.prototype.toString
-        .call(object)
-        .replace(/^\[object (.*)\]$/, function (m, p0) {
-          return p0;
-        });
+      object = Object.prototype.toString.call(object);
+      return object.slice(8, object.length - 1);
     }
     function describeKeyForErrorMessage(key) {
       var encodedKey = JSON.stringify(key);
@@ -785,10 +761,10 @@
       filename.startsWith("/") && (filename = "file://" + filename);
       sourceMap
         ? ((col +=
-            "\n//# sourceURL=rsc://React/" +
+            "\n//# sourceURL=about://React/" +
             encodeURIComponent(environmentName) +
             "/" +
-            filename +
+            encodeURI(filename) +
             "?s" +
             fakeServerFunctionIdx++),
           (col += "\n//# sourceMappingURL=" + sourceMap))
@@ -910,7 +886,7 @@
           case REACT_PORTAL_TYPE:
             return "Portal";
           case REACT_CONTEXT_TYPE:
-            return (type.displayName || "Context") + ".Provider";
+            return type.displayName || "Context";
           case REACT_CONSUMER_TYPE:
             return (type._context.displayName || "Context") + ".Consumer";
           case REACT_FORWARD_REF_TYPE:
@@ -936,12 +912,487 @@
         }
       return null;
     }
-    function ReactPromise(status, value, reason, response) {
+    function getArrayKind(array) {
+      for (var kind = 0, i = 0; i < array.length; i++) {
+        var value = array[i];
+        if ("object" === typeof value && null !== value)
+          if (
+            isArrayImpl(value) &&
+            2 === value.length &&
+            "string" === typeof value[0]
+          ) {
+            if (0 !== kind && 3 !== kind) return 1;
+            kind = 3;
+          } else return 1;
+        else {
+          if (
+            "function" === typeof value ||
+            ("string" === typeof value && 50 < value.length) ||
+            (0 !== kind && 2 !== kind)
+          )
+            return 1;
+          kind = 2;
+        }
+      }
+      return kind;
+    }
+    function addObjectToProperties(object, properties, indent, prefix) {
+      for (var key in object)
+        hasOwnProperty.call(object, key) &&
+          "_" !== key[0] &&
+          addValueToProperties(key, object[key], properties, indent, prefix);
+    }
+    function addValueToProperties(
+      propertyName,
+      value,
+      properties,
+      indent,
+      prefix
+    ) {
+      switch (typeof value) {
+        case "object":
+          if (null === value) {
+            value = "null";
+            break;
+          } else {
+            if (value.$$typeof === REACT_ELEMENT_TYPE) {
+              var typeName = getComponentNameFromType(value.type) || "\u2026",
+                key = value.key;
+              value = value.props;
+              var propsKeys = Object.keys(value),
+                propsLength = propsKeys.length;
+              if (null == key && 0 === propsLength) {
+                value = "<" + typeName + " />";
+                break;
+              }
+              if (
+                3 > indent ||
+                (1 === propsLength &&
+                  "children" === propsKeys[0] &&
+                  null == key)
+              ) {
+                value = "<" + typeName + " \u2026 />";
+                break;
+              }
+              properties.push([
+                prefix + "\u00a0\u00a0".repeat(indent) + propertyName,
+                "<" + typeName
+              ]);
+              null !== key &&
+                addValueToProperties(
+                  "key",
+                  key,
+                  properties,
+                  indent + 1,
+                  prefix
+                );
+              propertyName = !1;
+              for (var propKey in value)
+                "children" === propKey
+                  ? null != value.children &&
+                    (!isArrayImpl(value.children) ||
+                      0 < value.children.length) &&
+                    (propertyName = !0)
+                  : hasOwnProperty.call(value, propKey) &&
+                    "_" !== propKey[0] &&
+                    addValueToProperties(
+                      propKey,
+                      value[propKey],
+                      properties,
+                      indent + 1,
+                      prefix
+                    );
+              properties.push([
+                "",
+                propertyName ? ">\u2026</" + typeName + ">" : "/>"
+              ]);
+              return;
+            }
+            typeName = Object.prototype.toString.call(value);
+            typeName = typeName.slice(8, typeName.length - 1);
+            if ("Array" === typeName)
+              if (
+                ((propKey = getArrayKind(value)),
+                2 === propKey || 0 === propKey)
+              ) {
+                value = JSON.stringify(value);
+                break;
+              } else if (3 === propKey) {
+                properties.push([
+                  prefix + "\u00a0\u00a0".repeat(indent) + propertyName,
+                  ""
+                ]);
+                for (
+                  propertyName = 0;
+                  propertyName < value.length;
+                  propertyName++
+                )
+                  (typeName = value[propertyName]),
+                    addValueToProperties(
+                      typeName[0],
+                      typeName[1],
+                      properties,
+                      indent + 1,
+                      prefix
+                    );
+                return;
+              }
+            if ("Promise" === typeName) {
+              if ("fulfilled" === value.status) {
+                if (
+                  ((typeName = properties.length),
+                  addValueToProperties(
+                    propertyName,
+                    value.value,
+                    properties,
+                    indent,
+                    prefix
+                  ),
+                  properties.length > typeName)
+                ) {
+                  properties = properties[typeName];
+                  properties[1] =
+                    "Promise<" + (properties[1] || "Object") + ">";
+                  return;
+                }
+              } else if (
+                "rejected" === value.status &&
+                ((typeName = properties.length),
+                addValueToProperties(
+                  propertyName,
+                  value.reason,
+                  properties,
+                  indent,
+                  prefix
+                ),
+                properties.length > typeName)
+              ) {
+                properties = properties[typeName];
+                properties[1] = "Rejected Promise<" + properties[1] + ">";
+                return;
+              }
+              properties.push([
+                "\u00a0\u00a0".repeat(indent) + propertyName,
+                "Promise"
+              ]);
+              return;
+            }
+            "Object" === typeName &&
+              (propKey = Object.getPrototypeOf(value)) &&
+              "function" === typeof propKey.constructor &&
+              (typeName = propKey.constructor.name);
+            properties.push([
+              prefix + "\u00a0\u00a0".repeat(indent) + propertyName,
+              "Object" === typeName ? (3 > indent ? "" : "\u2026") : typeName
+            ]);
+            3 > indent &&
+              addObjectToProperties(value, properties, indent + 1, prefix);
+            return;
+          }
+        case "function":
+          value = "" === value.name ? "() => {}" : value.name + "() {}";
+          break;
+        case "string":
+          value =
+            "This object has been omitted by React in the console log to avoid sending too much data from the server. Try logging smaller or more specific objects." ===
+            value
+              ? "\u2026"
+              : JSON.stringify(value);
+          break;
+        case "undefined":
+          value = "undefined";
+          break;
+        case "boolean":
+          value = value ? "true" : "false";
+          break;
+        default:
+          value = String(value);
+      }
+      properties.push([
+        prefix + "\u00a0\u00a0".repeat(indent) + propertyName,
+        value
+      ]);
+    }
+    function getIODescription(value) {
+      try {
+        switch (typeof value) {
+          case "object":
+            if (null === value) return "";
+            if (value instanceof Error) return String(value.message);
+            if ("string" === typeof value.url) return value.url;
+            if ("string" === typeof value.href) return value.href;
+            if ("string" === typeof value.src) return value.src;
+            if ("string" === typeof value.currentSrc) return value.currentSrc;
+            if ("string" === typeof value.command) return value.command;
+            if (
+              "object" === typeof value.request &&
+              null !== value.request &&
+              "string" === typeof value.request.url
+            )
+              return value.request.url;
+            if (
+              "object" === typeof value.response &&
+              null !== value.response &&
+              "string" === typeof value.response.url
+            )
+              return value.response.url;
+            if (
+              "string" === typeof value.id ||
+              "number" === typeof value.id ||
+              "bigint" === typeof value.id
+            )
+              return String(value.id);
+            if ("string" === typeof value.name) return value.name;
+            var str = value.toString();
+            return str.startsWith("[object ") ||
+              5 > str.length ||
+              500 < str.length
+              ? ""
+              : str;
+          case "string":
+            return 5 > value.length || 500 < value.length ? "" : value;
+          case "number":
+          case "bigint":
+            return String(value);
+          default:
+            return "";
+        }
+      } catch (x) {
+        return "";
+      }
+    }
+    function markAllTracksInOrder() {
+      supportsUserTiming &&
+        (console.timeStamp(
+          "Server Requests Track",
+          0.001,
+          0.001,
+          "Server Requests \u269b",
+          void 0,
+          "primary-light"
+        ),
+        console.timeStamp(
+          "Server Components Track",
+          0.001,
+          0.001,
+          "Primary",
+          "Server Components \u269b",
+          "primary-light"
+        ));
+    }
+    function getIOColor(functionName) {
+      switch (functionName.charCodeAt(0) % 3) {
+        case 0:
+          return "tertiary-light";
+        case 1:
+          return "tertiary";
+        default:
+          return "tertiary-dark";
+      }
+    }
+    function getIOLongName(ioInfo, description, env, rootEnv) {
+      ioInfo = ioInfo.name;
+      description =
+        "" === description ? ioInfo : ioInfo + " (" + description + ")";
+      return env === rootEnv || void 0 === env
+        ? description
+        : description + " [" + env + "]";
+    }
+    function getIOShortName(ioInfo, description, env, rootEnv) {
+      ioInfo = ioInfo.name;
+      env = env === rootEnv || void 0 === env ? "" : " [" + env + "]";
+      var desc = "";
+      rootEnv = 30 - ioInfo.length - env.length;
+      if (1 < rootEnv) {
+        var l = description.length;
+        if (0 < l && l <= rootEnv) desc = " (" + description + ")";
+        else if (
+          description.startsWith("http://") ||
+          description.startsWith("https://") ||
+          description.startsWith("/")
+        ) {
+          var queryIdx = description.indexOf("?");
+          -1 === queryIdx && (queryIdx = description.length);
+          47 === description.charCodeAt(queryIdx - 1) && queryIdx--;
+          desc = description.lastIndexOf("/", queryIdx - 1);
+          queryIdx - desc < rootEnv
+            ? (desc = " (\u2026" + description.slice(desc, queryIdx) + ")")
+            : ((l = description.slice(desc, desc + rootEnv / 2)),
+              (description = description.slice(
+                queryIdx - rootEnv / 2,
+                queryIdx
+              )),
+              (desc =
+                " (" +
+                (0 < desc ? "\u2026" : "") +
+                l +
+                "\u2026" +
+                description +
+                ")"));
+        }
+      }
+      return ioInfo + desc + env;
+    }
+    function logComponentAwait(
+      asyncInfo,
+      trackIdx,
+      startTime,
+      endTime,
+      rootEnv,
+      value
+    ) {
+      if (supportsUserTiming && 0 < endTime) {
+        var description = getIODescription(value),
+          name = getIOShortName(
+            asyncInfo.awaited,
+            description,
+            asyncInfo.env,
+            rootEnv
+          ),
+          entryName = "await " + name;
+        name = getIOColor(name);
+        var debugTask = asyncInfo.debugTask || asyncInfo.awaited.debugTask;
+        if (debugTask) {
+          var properties = [];
+          "object" === typeof value && null !== value
+            ? addObjectToProperties(value, properties, 0, "")
+            : void 0 !== value &&
+              addValueToProperties("awaited value", value, properties, 0, "");
+          asyncInfo = getIOLongName(
+            asyncInfo.awaited,
+            description,
+            asyncInfo.env,
+            rootEnv
+          );
+          debugTask.run(
+            performance.measure.bind(performance, entryName, {
+              start: 0 > startTime ? 0 : startTime,
+              end: endTime,
+              detail: {
+                devtools: {
+                  color: name,
+                  track: trackNames[trackIdx],
+                  trackGroup: "Server Components \u269b",
+                  properties: properties,
+                  tooltipText: asyncInfo
+                }
+              }
+            })
+          );
+        } else
+          console.timeStamp(
+            entryName,
+            0 > startTime ? 0 : startTime,
+            endTime,
+            trackNames[trackIdx],
+            "Server Components \u269b",
+            name
+          );
+      }
+    }
+    function logIOInfoErrored(ioInfo, rootEnv, error) {
+      var startTime = ioInfo.start,
+        endTime = ioInfo.end;
+      if (supportsUserTiming && 0 <= endTime) {
+        var description = getIODescription(error),
+          entryName = getIOShortName(ioInfo, description, ioInfo.env, rootEnv),
+          debugTask = ioInfo.debugTask;
+        debugTask
+          ? ((error = [
+              [
+                "rejected with",
+                "object" === typeof error &&
+                null !== error &&
+                "string" === typeof error.message
+                  ? String(error.message)
+                  : String(error)
+              ]
+            ]),
+            (ioInfo =
+              getIOLongName(ioInfo, description, ioInfo.env, rootEnv) +
+              " Rejected"),
+            debugTask.run(
+              performance.measure.bind(performance, "\u200b" + entryName, {
+                start: 0 > startTime ? 0 : startTime,
+                end: endTime,
+                detail: {
+                  devtools: {
+                    color: "error",
+                    track: "Server Requests \u269b",
+                    properties: error,
+                    tooltipText: ioInfo
+                  }
+                }
+              })
+            ))
+          : console.timeStamp(
+              entryName,
+              0 > startTime ? 0 : startTime,
+              endTime,
+              "Server Requests \u269b",
+              void 0,
+              "error"
+            );
+      }
+    }
+    function logIOInfo(ioInfo, rootEnv, value) {
+      var startTime = ioInfo.start,
+        endTime = ioInfo.end;
+      if (supportsUserTiming && 0 <= endTime) {
+        var description = getIODescription(value),
+          entryName = getIOShortName(ioInfo, description, ioInfo.env, rootEnv),
+          color = getIOColor(entryName),
+          debugTask = ioInfo.debugTask;
+        if (debugTask) {
+          var properties = [];
+          "object" === typeof value && null !== value
+            ? addObjectToProperties(value, properties, 0, "")
+            : void 0 !== value &&
+              addValueToProperties("Resolved", value, properties, 0, "");
+          ioInfo = getIOLongName(ioInfo, description, ioInfo.env, rootEnv);
+          debugTask.run(
+            performance.measure.bind(performance, "\u200b" + entryName, {
+              start: 0 > startTime ? 0 : startTime,
+              end: endTime,
+              detail: {
+                devtools: {
+                  color: color,
+                  track: "Server Requests \u269b",
+                  properties: properties,
+                  tooltipText: ioInfo
+                }
+              }
+            })
+          );
+        } else
+          console.timeStamp(
+            entryName,
+            0 > startTime ? 0 : startTime,
+            endTime,
+            "Server Requests \u269b",
+            void 0,
+            color
+          );
+      }
+    }
+    function ReactPromise(status, value, reason) {
       this.status = status;
       this.value = value;
       this.reason = reason;
-      this._response = response;
-      this._debugInfo = null;
+      this._children = [];
+      this._debugChunk = null;
+      this._debugInfo = [];
+    }
+    function unwrapWeakResponse(weakResponse) {
+      weakResponse = weakResponse.weak.deref();
+      if (void 0 === weakResponse)
+        throw Error(
+          "We did not expect to receive new data after GC:ing the response."
+        );
+      return weakResponse;
+    }
+    function closeDebugChannel(debugChannel) {
+      debugChannel.callback && debugChannel.callback("");
     }
     function readChunk(chunk) {
       switch (chunk.status) {
@@ -956,26 +1407,111 @@
           return chunk.value;
         case "pending":
         case "blocked":
+        case "halted":
           throw chunk;
         default:
           throw chunk.reason;
       }
     }
+    function getRoot(weakResponse) {
+      weakResponse = unwrapWeakResponse(weakResponse);
+      return getChunk(weakResponse, 0);
+    }
     function createPendingChunk(response) {
-      return new ReactPromise("pending", null, null, response);
+      0 === response._pendingChunks++ &&
+        ((response._weakResponse.response = response),
+        null !== response._pendingInitialRender &&
+          (clearTimeout(response._pendingInitialRender),
+          (response._pendingInitialRender = null)));
+      return new ReactPromise("pending", null, null);
+    }
+    function releasePendingChunk(response, chunk) {
+      "pending" === chunk.status &&
+        0 === --response._pendingChunks &&
+        ((response._weakResponse.response = null),
+        (response._pendingInitialRender = setTimeout(
+          flushInitialRenderPerformance.bind(null, response),
+          100
+        )));
+    }
+    function moveDebugInfoFromChunkToInnerValue(chunk, value) {
+      value = resolveLazy(value);
+      "object" !== typeof value ||
+        null === value ||
+        (!isArrayImpl(value) &&
+          "function" !== typeof value[ASYNC_ITERATOR] &&
+          value.$$typeof !== REACT_ELEMENT_TYPE &&
+          value.$$typeof !== REACT_LAZY_TYPE) ||
+        ((chunk = chunk._debugInfo.splice(0)),
+        isArrayImpl(value._debugInfo)
+          ? value._debugInfo.unshift.apply(value._debugInfo, chunk)
+          : Object.defineProperty(value, "_debugInfo", {
+              configurable: !1,
+              enumerable: !1,
+              writable: !0,
+              value: chunk
+            }));
+    }
+    function wakeChunk(listeners, value, chunk) {
+      for (var i = 0; i < listeners.length; i++) {
+        var listener = listeners[i];
+        "function" === typeof listener
+          ? listener(value)
+          : fulfillReference(listener, value, chunk);
+      }
+      moveDebugInfoFromChunkToInnerValue(chunk, value);
+    }
+    function rejectChunk(listeners, error) {
+      for (var i = 0; i < listeners.length; i++) {
+        var listener = listeners[i];
+        "function" === typeof listener
+          ? listener(error)
+          : rejectReference(listener, error);
+      }
     }
-    function wakeChunk(listeners, value) {
-      for (var i = 0; i < listeners.length; i++) (0, listeners[i])(value);
+    function resolveBlockedCycle(resolvedChunk, reference) {
+      var referencedChunk = reference.handler.chunk;
+      if (null === referencedChunk) return null;
+      if (referencedChunk === resolvedChunk) return reference.handler;
+      reference = referencedChunk.value;
+      if (null !== reference)
+        for (
+          referencedChunk = 0;
+          referencedChunk < reference.length;
+          referencedChunk++
+        ) {
+          var listener = reference[referencedChunk];
+          if (
+            "function" !== typeof listener &&
+            ((listener = resolveBlockedCycle(resolvedChunk, listener)),
+            null !== listener)
+          )
+            return listener;
+        }
+      return null;
     }
     function wakeChunkIfInitialized(chunk, resolveListeners, rejectListeners) {
       switch (chunk.status) {
         case "fulfilled":
-          wakeChunk(resolveListeners, chunk.value);
+          wakeChunk(resolveListeners, chunk.value, chunk);
           break;
-        case "pending":
         case "blocked":
+          for (var i = 0; i < resolveListeners.length; i++) {
+            var listener = resolveListeners[i];
+            if ("function" !== typeof listener) {
+              var cyclicHandler = resolveBlockedCycle(chunk, listener);
+              null !== cyclicHandler &&
+                (fulfillReference(listener, cyclicHandler.value, chunk),
+                resolveListeners.splice(i, 1),
+                i--,
+                null !== rejectListeners &&
+                  ((listener = rejectListeners.indexOf(listener)),
+                  -1 !== listener && rejectListeners.splice(listener, 1)));
+            }
+          }
+        case "pending":
           if (chunk.value)
-            for (var i = 0; i < resolveListeners.length; i++)
+            for (i = 0; i < resolveListeners.length; i++)
               chunk.value.push(resolveListeners[i]);
           else chunk.value = resolveListeners;
           if (chunk.reason) {
@@ -989,76 +1525,228 @@
           } else chunk.reason = rejectListeners;
           break;
         case "rejected":
-          rejectListeners && wakeChunk(rejectListeners, chunk.reason);
+          rejectListeners && rejectChunk(rejectListeners, chunk.reason);
       }
     }
-    function triggerErrorOnChunk(chunk, error) {
+    function triggerErrorOnChunk(response, chunk, error) {
       if ("pending" !== chunk.status && "blocked" !== chunk.status)
         chunk.reason.error(error);
       else {
+        releasePendingChunk(response, chunk);
         var listeners = chunk.reason;
+        if ("pending" === chunk.status && null != chunk._debugChunk) {
+          var prevHandler = initializingHandler,
+            prevChunk = initializingChunk;
+          initializingHandler = null;
+          chunk.status = "blocked";
+          chunk.value = null;
+          chunk.reason = null;
+          initializingChunk = chunk;
+          try {
+            initializeDebugChunk(response, chunk);
+          } finally {
+            (initializingHandler = prevHandler),
+              (initializingChunk = prevChunk);
+          }
+        }
         chunk.status = "rejected";
         chunk.reason = error;
-        null !== listeners && wakeChunk(listeners, error);
+        null !== listeners && rejectChunk(listeners, error);
       }
     }
+    function createResolvedModelChunk(response, value) {
+      return new ReactPromise("resolved_model", value, response);
+    }
     function createResolvedIteratorResultChunk(response, value, done) {
       return new ReactPromise(
         "resolved_model",
         (done ? '{"done":true,"value":' : '{"done":false,"value":') +
           value +
           "}",
-        null,
         response
       );
     }
-    function resolveIteratorResultChunk(chunk, value, done) {
+    function resolveIteratorResultChunk(response, chunk, value, done) {
       resolveModelChunk(
+        response,
         chunk,
         (done ? '{"done":true,"value":' : '{"done":false,"value":') +
           value +
           "}"
       );
     }
-    function resolveModelChunk(chunk, value) {
+    function resolveModelChunk(response, chunk, value) {
       if ("pending" !== chunk.status) chunk.reason.enqueueModel(value);
       else {
+        releasePendingChunk(response, chunk);
         var resolveListeners = chunk.value,
           rejectListeners = chunk.reason;
         chunk.status = "resolved_model";
         chunk.value = value;
+        chunk.reason = response;
         null !== resolveListeners &&
           (initializeModelChunk(chunk),
           wakeChunkIfInitialized(chunk, resolveListeners, rejectListeners));
       }
     }
-    function resolveModuleChunk(chunk, value) {
+    function resolveModuleChunk(response, chunk, value) {
       if ("pending" === chunk.status || "blocked" === chunk.status) {
-        var resolveListeners = chunk.value,
-          rejectListeners = chunk.reason;
+        releasePendingChunk(response, chunk);
+        response = chunk.value;
+        var rejectListeners = chunk.reason;
         chunk.status = "resolved_module";
         chunk.value = value;
-        null !== resolveListeners &&
+        value = value[1];
+        for (var debugInfo = [], i = 0; i < value.length; ) {
+          var chunkId = value[i++];
+          value[i++];
+          var href = void 0,
+            target = debugInfo,
+            ioInfo = chunkIOInfoCache.get(chunkId);
+          if (void 0 === ioInfo) {
+            var scriptFilename = __webpack_get_script_filename__(chunkId);
+            try {
+              href = new URL(scriptFilename, document.baseURI).href;
+            } catch (_) {
+              href = scriptFilename;
+            }
+            var end = (ioInfo = -1);
+            scriptFilename = 0;
+            if ("function" === typeof performance.getEntriesByType)
+              for (
+                var resourceEntries = performance.getEntriesByType("resource"),
+                  i$jscomp$0 = 0;
+                i$jscomp$0 < resourceEntries.length;
+                i$jscomp$0++
+              ) {
+                var resourceEntry = resourceEntries[i$jscomp$0];
+                resourceEntry.name === href &&
+                  ((ioInfo = resourceEntry.startTime),
+                  (end = ioInfo + resourceEntry.duration),
+                  (scriptFilename = resourceEntry.transferSize || 0));
+              }
+            resourceEntries = Promise.resolve(href);
+            resourceEntries.status = "fulfilled";
+            resourceEntries.value = { chunkId: chunkId, href: href };
+            i$jscomp$0 = Error("react-stack-top-frame");
+            i$jscomp$0.stack.startsWith("Error: react-stack-top-frame")
+              ? (i$jscomp$0.stack =
+                  "Error: react-stack-top-frame\n    at Client Component Bundle (" +
+                  href +
+                  ":1:1)\n    at Client Component Bundle (" +
+                  href +
+                  ":1:1)")
+              : (i$jscomp$0.stack =
+                  "Client Component Bundle@" +
+                  href +
+                  ":1:1\nClient Component Bundle@" +
+                  href +
+                  ":1:1");
+            ioInfo = {
+              name: "script",
+              start: ioInfo,
+              end: end,
+              value: resourceEntries,
+              debugStack: i$jscomp$0
+            };
+            0 < scriptFilename && (ioInfo.byteSize = scriptFilename);
+            chunkIOInfoCache.set(chunkId, ioInfo);
+          }
+          target.push({ awaited: ioInfo });
+        }
+        null !== debugInfo &&
+          chunk._debugInfo.push.apply(chunk._debugInfo, debugInfo);
+        null !== response &&
           (initializeModuleChunk(chunk),
-          wakeChunkIfInitialized(chunk, resolveListeners, rejectListeners));
+          wakeChunkIfInitialized(chunk, response, rejectListeners));
+      }
+    }
+    function initializeDebugChunk(response, chunk) {
+      var debugChunk = chunk._debugChunk;
+      if (null !== debugChunk) {
+        var debugInfo = chunk._debugInfo;
+        try {
+          if ("resolved_model" === debugChunk.status) {
+            for (
+              var idx = debugInfo.length, c = debugChunk._debugChunk;
+              null !== c;
+
+            )
+              "fulfilled" !== c.status && idx++, (c = c._debugChunk);
+            initializeModelChunk(debugChunk);
+            switch (debugChunk.status) {
+              case "fulfilled":
+                debugInfo[idx] = initializeDebugInfo(
+                  response,
+                  debugChunk.value
+                );
+                break;
+              case "blocked":
+              case "pending":
+                waitForReference(
+                  debugChunk,
+                  debugInfo,
+                  "" + idx,
+                  response,
+                  initializeDebugInfo,
+                  [""],
+                  !0
+                );
+                break;
+              default:
+                throw debugChunk.reason;
+            }
+          } else
+            switch (debugChunk.status) {
+              case "fulfilled":
+                break;
+              case "blocked":
+              case "pending":
+                waitForReference(
+                  debugChunk,
+                  {},
+                  "debug",
+                  response,
+                  initializeDebugInfo,
+                  [""],
+                  !0
+                );
+                break;
+              default:
+                throw debugChunk.reason;
+            }
+        } catch (error) {
+          triggerErrorOnChunk(response, chunk, error);
+        }
       }
     }
     function initializeModelChunk(chunk) {
-      var prevHandler = initializingHandler;
+      var prevHandler = initializingHandler,
+        prevChunk = initializingChunk;
       initializingHandler = null;
-      var resolvedModel = chunk.value;
+      var resolvedModel = chunk.value,
+        response = chunk.reason;
       chunk.status = "blocked";
       chunk.value = null;
       chunk.reason = null;
+      initializingChunk = chunk;
+      initializeDebugChunk(response, chunk);
       try {
-        var value = JSON.parse(resolvedModel, chunk._response._fromJSON),
+        var value = JSON.parse(resolvedModel, response._fromJSON),
           resolveListeners = chunk.value;
-        null !== resolveListeners &&
-          ((chunk.value = null),
-          (chunk.reason = null),
-          wakeChunk(resolveListeners, value));
+        if (null !== resolveListeners)
+          for (
+            chunk.value = null, chunk.reason = null, resolvedModel = 0;
+            resolvedModel < resolveListeners.length;
+            resolvedModel++
+          ) {
+            var listener = resolveListeners[resolvedModel];
+            "function" === typeof listener
+              ? listener(value)
+              : fulfillReference(listener, value, chunk);
+          }
         if (null !== initializingHandler) {
-          if (initializingHandler.errored) throw initializingHandler.value;
+          if (initializingHandler.errored) throw initializingHandler.reason;
           if (0 < initializingHandler.deps) {
             initializingHandler.value = value;
             initializingHandler.chunk = chunk;
@@ -1067,10 +1755,11 @@
         }
         chunk.status = "fulfilled";
         chunk.value = value;
+        moveDebugInfoFromChunkToInnerValue(chunk, value);
       } catch (error) {
         (chunk.status = "rejected"), (chunk.reason = error);
       } finally {
-        initializingHandler = prevHandler;
+        (initializingHandler = prevHandler), (initializingChunk = prevChunk);
       }
     }
     function initializeModuleChunk(chunk) {
@@ -1082,12 +1771,22 @@
         (chunk.status = "rejected"), (chunk.reason = error);
       }
     }
-    function reportGlobalError(response, error) {
-      response._closed = !0;
-      response._closedReason = error;
-      response._chunks.forEach(function (chunk) {
-        "pending" === chunk.status && triggerErrorOnChunk(chunk, error);
-      });
+    function reportGlobalError(weakResponse, error) {
+      if (void 0 !== weakResponse.weak.deref()) {
+        var response = unwrapWeakResponse(weakResponse);
+        response._closed = !0;
+        response._closedReason = error;
+        response._chunks.forEach(function (chunk) {
+          "pending" === chunk.status &&
+            triggerErrorOnChunk(response, chunk, error);
+        });
+        weakResponse = response._debugChannel;
+        void 0 !== weakResponse &&
+          (closeDebugChannel(weakResponse),
+          (response._debugChannel = void 0),
+          null !== debugChannelRegistry &&
+            debugChannelRegistry.unregister(response));
+      }
     }
     function nullRefGetter() {
       return null;
@@ -1108,14 +1807,69 @@
         return "<...>";
       }
     }
-    function createLazyChunkWrapper(chunk) {
+    function initializeElement(response, element, lazyNode) {
+      var stack = element._debugStack,
+        owner = element._owner;
+      null === owner && (element._owner = response._debugRootOwner);
+      var env = response._rootEnvironmentName;
+      null !== owner && null != owner.env && (env = owner.env);
+      var normalizedStackTrace = null;
+      null === owner && null != response._debugRootStack
+        ? (normalizedStackTrace = response._debugRootStack)
+        : null !== stack &&
+          (normalizedStackTrace = createFakeJSXCallStackInDEV(
+            response,
+            stack,
+            env
+          ));
+      element._debugStack = normalizedStackTrace;
+      normalizedStackTrace = null;
+      supportsCreateTask &&
+        null !== stack &&
+        ((normalizedStackTrace = console.createTask.bind(
+          console,
+          getTaskName(element.type)
+        )),
+        (stack = buildFakeCallStack(
+          response,
+          stack,
+          env,
+          !1,
+          normalizedStackTrace
+        )),
+        (env = null === owner ? null : initializeFakeTask(response, owner)),
+        null === env
+          ? ((env = response._debugRootTask),
+            (normalizedStackTrace = null != env ? env.run(stack) : stack()))
+          : (normalizedStackTrace = env.run(stack)));
+      element._debugTask = normalizedStackTrace;
+      null !== owner && initializeFakeStack(response, owner);
+      null !== lazyNode &&
+        (lazyNode._store &&
+          lazyNode._store.validated &&
+          !element._store.validated &&
+          (element._store.validated = lazyNode._store.validated),
+        "fulfilled" === lazyNode._payload.status &&
+          lazyNode._debugInfo &&
+          ((response = lazyNode._debugInfo.splice(0)),
+          element._debugInfo
+            ? element._debugInfo.unshift.apply(element._debugInfo, response)
+            : Object.defineProperty(element, "_debugInfo", {
+                configurable: !1,
+                enumerable: !1,
+                writable: !0,
+                value: response
+              })));
+      Object.freeze(element.props);
+    }
+    function createLazyChunkWrapper(chunk, validated) {
       var lazyType = {
         $$typeof: REACT_LAZY_TYPE,
         _payload: chunk,
         _init: readChunk
       };
-      chunk = chunk._debugInfo || (chunk._debugInfo = []);
-      lazyType._debugInfo = chunk;
+      lazyType._debugInfo = chunk._debugInfo;
+      lazyType._store = { validated: validated };
       return lazyType;
     }
     function getChunk(response, id) {
@@ -1123,85 +1877,176 @@
         chunk = chunks.get(id);
       chunk ||
         ((chunk = response._closed
-          ? new ReactPromise("rejected", null, response._closedReason, response)
+          ? new ReactPromise("rejected", null, response._closedReason)
           : createPendingChunk(response)),
         chunks.set(id, chunk));
       return chunk;
     }
+    function fulfillReference(reference, value, fulfilledChunk) {
+      for (
+        var response = reference.response,
+          handler = reference.handler,
+          parentObject = reference.parentObject,
+          key = reference.key,
+          map = reference.map,
+          path = reference.path,
+          i = 1;
+        i < path.length;
+        i++
+      ) {
+        for (
+          ;
+          "object" === typeof value &&
+          null !== value &&
+          value.$$typeof === REACT_LAZY_TYPE;
+
+        )
+          if (((value = value._payload), value === handler.chunk))
+            value = handler.value;
+          else {
+            switch (value.status) {
+              case "resolved_model":
+                initializeModelChunk(value);
+                break;
+              case "resolved_module":
+                initializeModuleChunk(value);
+            }
+            switch (value.status) {
+              case "fulfilled":
+                value = value.value;
+                continue;
+              case "blocked":
+                var cyclicHandler = resolveBlockedCycle(value, reference);
+                if (null !== cyclicHandler) {
+                  value = cyclicHandler.value;
+                  continue;
+                }
+              case "pending":
+                path.splice(0, i - 1);
+                null === value.value
+                  ? (value.value = [reference])
+                  : value.value.push(reference);
+                null === value.reason
+                  ? (value.reason = [reference])
+                  : value.reason.push(reference);
+                return;
+              case "halted":
+                return;
+              default:
+                rejectReference(reference, value.reason);
+                return;
+            }
+          }
+        value = value[path[i]];
+      }
+      for (
+        ;
+        "object" === typeof value &&
+        null !== value &&
+        value.$$typeof === REACT_LAZY_TYPE;
+
+      )
+        if (((path = value._payload), path === handler.chunk))
+          value = handler.value;
+        else {
+          switch (path.status) {
+            case "resolved_model":
+              initializeModelChunk(path);
+              break;
+            case "resolved_module":
+              initializeModuleChunk(path);
+          }
+          switch (path.status) {
+            case "fulfilled":
+              value = path.value;
+              continue;
+          }
+          break;
+        }
+      response = map(response, value, parentObject, key);
+      parentObject[key] = response;
+      "" === key && null === handler.value && (handler.value = response);
+      if (
+        parentObject[0] === REACT_ELEMENT_TYPE &&
+        "object" === typeof handler.value &&
+        null !== handler.value &&
+        handler.value.$$typeof === REACT_ELEMENT_TYPE
+      )
+        switch (((reference = handler.value), key)) {
+          case "3":
+            transferReferencedDebugInfo(handler.chunk, fulfilledChunk);
+            reference.props = response;
+            break;
+          case "4":
+            reference._owner = response;
+            break;
+          case "5":
+            reference._debugStack = response;
+            break;
+          default:
+            transferReferencedDebugInfo(handler.chunk, fulfilledChunk);
+        }
+      else
+        reference.isDebug ||
+          transferReferencedDebugInfo(handler.chunk, fulfilledChunk);
+      handler.deps--;
+      0 === handler.deps &&
+        ((fulfilledChunk = handler.chunk),
+        null !== fulfilledChunk &&
+          "blocked" === fulfilledChunk.status &&
+          ((key = fulfilledChunk.value),
+          (fulfilledChunk.status = "fulfilled"),
+          (fulfilledChunk.value = handler.value),
+          (fulfilledChunk.reason = handler.reason),
+          null !== key && wakeChunk(key, handler.value, fulfilledChunk)));
+    }
+    function rejectReference(reference, error) {
+      var handler = reference.handler;
+      reference = reference.response;
+      if (!handler.errored) {
+        var blockedValue = handler.value;
+        handler.errored = !0;
+        handler.value = null;
+        handler.reason = error;
+        handler = handler.chunk;
+        if (null !== handler && "blocked" === handler.status) {
+          if (
+            "object" === typeof blockedValue &&
+            null !== blockedValue &&
+            blockedValue.$$typeof === REACT_ELEMENT_TYPE
+          ) {
+            var erroredComponent = {
+              name: getComponentNameFromType(blockedValue.type) || "",
+              owner: blockedValue._owner
+            };
+            erroredComponent.debugStack = blockedValue._debugStack;
+            supportsCreateTask &&
+              (erroredComponent.debugTask = blockedValue._debugTask);
+            handler._debugInfo.push(erroredComponent);
+          }
+          triggerErrorOnChunk(reference, handler, error);
+        }
+      }
+    }
     function waitForReference(
       referencedChunk,
       parentObject,
       key,
       response,
       map,
-      path
+      path,
+      isAwaitingDebugInfo
     ) {
-      function fulfill(value) {
-        for (var i = 1; i < path.length; i++) {
-          for (; value.$$typeof === REACT_LAZY_TYPE; )
-            if (((value = value._payload), value === handler.chunk))
-              value = handler.value;
-            else if ("fulfilled" === value.status) value = value.value;
-            else {
-              path.splice(0, i - 1);
-              value.then(fulfill, reject);
-              return;
-            }
-          value = value[path[i]];
-        }
-        i = map(response, value, parentObject, key);
-        parentObject[key] = i;
-        "" === key && null === handler.value && (handler.value = i);
-        if (
-          parentObject[0] === REACT_ELEMENT_TYPE &&
-          "object" === typeof handler.value &&
-          null !== handler.value &&
-          handler.value.$$typeof === REACT_ELEMENT_TYPE
+      if (
+        !(
+          (void 0 !== response._debugChannel &&
+            response._debugChannel.hasReadable) ||
+          "pending" !== referencedChunk.status ||
+          parentObject[0] !== REACT_ELEMENT_TYPE ||
+          ("4" !== key && "5" !== key)
         )
-          switch (((value = handler.value), key)) {
-            case "3":
-              value.props = i;
-              break;
-            case "4":
-              value._owner = i;
-          }
-        handler.deps--;
-        0 === handler.deps &&
-          ((i = handler.chunk),
-          null !== i &&
-            "blocked" === i.status &&
-            ((value = i.value),
-            (i.status = "fulfilled"),
-            (i.value = handler.value),
-            null !== value && wakeChunk(value, handler.value)));
-      }
-      function reject(error) {
-        if (!handler.errored) {
-          var blockedValue = handler.value;
-          handler.errored = !0;
-          handler.value = error;
-          var chunk = handler.chunk;
-          if (null !== chunk && "blocked" === chunk.status) {
-            if (
-              "object" === typeof blockedValue &&
-              null !== blockedValue &&
-              blockedValue.$$typeof === REACT_ELEMENT_TYPE
-            ) {
-              var erroredComponent = {
-                name: getComponentNameFromType(blockedValue.type) || "",
-                owner: blockedValue._owner
-              };
-              erroredComponent.debugStack = blockedValue._debugStack;
-              supportsCreateTask &&
-                (erroredComponent.debugTask = blockedValue._debugTask);
-              (chunk._debugInfo || (chunk._debugInfo = [])).push(
-                erroredComponent
-              );
-            }
-            triggerErrorOnChunk(chunk, error);
-          }
-        }
-      }
+      )
+        return null;
       if (initializingHandler) {
         var handler = initializingHandler;
         handler.deps++;
@@ -1210,10 +2055,25 @@
           parent: null,
           chunk: null,
           value: null,
+          reason: null,
           deps: 1,
           errored: !1
         };
-      referencedChunk.then(fulfill, reject);
+      parentObject = {
+        response: response,
+        handler: handler,
+        parentObject: parentObject,
+        key: key,
+        map: map,
+        path: path
+      };
+      parentObject.isDebug = isAwaitingDebugInfo;
+      null === referencedChunk.value
+        ? (referencedChunk.value = [parentObject])
+        : referencedChunk.value.push(parentObject);
+      null === referencedChunk.reason
+        ? (referencedChunk.reason = [parentObject])
+        : referencedChunk.reason.push(parentObject);
       return null;
     }
     function loadServerReference(response, metaData, parentObject, key) {
@@ -1225,17 +2085,18 @@
           response._debugFindSourceMapURL
         );
       var serverReference = resolveServerReference(
-        response._serverReferenceConfig,
-        metaData.id
-      );
-      if ((response = preloadModule(serverReference)))
-        metaData.bound && (response = Promise.all([response, metaData.bound]));
-      else if (metaData.bound) response = Promise.resolve(metaData.bound);
+          response._serverReferenceConfig,
+          metaData.id
+        ),
+        promise = preloadModule(serverReference);
+      if (promise)
+        metaData.bound && (promise = Promise.all([promise, metaData.bound]));
+      else if (metaData.bound) promise = Promise.resolve(metaData.bound);
       else
         return (
-          (response = requireModule(serverReference)),
-          registerBoundServerReference(response, metaData.id, metaData.bound),
-          response
+          (promise = requireModule(serverReference)),
+          registerBoundServerReference(promise, metaData.id, metaData.bound),
+          promise
         );
       if (initializingHandler) {
         var handler = initializingHandler;
@@ -1245,10 +2106,11 @@
           parent: null,
           chunk: null,
           value: null,
+          reason: null,
           deps: 1,
           errored: !1
         };
-      response.then(
+      promise.then(
         function () {
           var resolvedValue = requireModule(serverReference);
           if (metaData.bound) {
@@ -1286,13 +2148,15 @@
               ((boundArgs = resolvedValue.value),
               (resolvedValue.status = "fulfilled"),
               (resolvedValue.value = handler.value),
-              null !== boundArgs && wakeChunk(boundArgs, handler.value)));
+              null !== boundArgs &&
+                wakeChunk(boundArgs, handler.value, resolvedValue)));
         },
         function (error) {
           if (!handler.errored) {
             var blockedValue = handler.value;
             handler.errored = !0;
-            handler.value = error;
+            handler.value = null;
+            handler.reason = error;
             var chunk = handler.chunk;
             if (null !== chunk && "blocked" === chunk.status) {
               if (
@@ -1307,79 +2171,184 @@
                 erroredComponent.debugStack = blockedValue._debugStack;
                 supportsCreateTask &&
                   (erroredComponent.debugTask = blockedValue._debugTask);
-                (chunk._debugInfo || (chunk._debugInfo = [])).push(
-                  erroredComponent
-                );
+                chunk._debugInfo.push(erroredComponent);
               }
-              triggerErrorOnChunk(chunk, error);
+              triggerErrorOnChunk(response, chunk, error);
             }
           }
         }
       );
       return null;
     }
+    function resolveLazy(value) {
+      for (
+        ;
+        "object" === typeof value &&
+        null !== value &&
+        value.$$typeof === REACT_LAZY_TYPE;
+
+      ) {
+        var payload = value._payload;
+        if ("fulfilled" === payload.status) value = payload.value;
+        else break;
+      }
+      return value;
+    }
+    function transferReferencedDebugInfo(parentChunk, referencedChunk) {
+      if (null !== parentChunk) {
+        referencedChunk = referencedChunk._debugInfo;
+        parentChunk = parentChunk._debugInfo;
+        for (var i = 0; i < referencedChunk.length; ++i) {
+          var debugInfoEntry = referencedChunk[i];
+          null == debugInfoEntry.name && parentChunk.push(debugInfoEntry);
+        }
+      }
+    }
     function getOutlinedModel(response, reference, parentObject, key, map) {
-      reference = reference.split(":");
-      var id = parseInt(reference[0], 16);
-      id = getChunk(response, id);
-      switch (id.status) {
+      var path = reference.split(":");
+      reference = parseInt(path[0], 16);
+      reference = getChunk(response, reference);
+      null !== initializingChunk &&
+        isArrayImpl(initializingChunk._children) &&
+        initializingChunk._children.push(reference);
+      switch (reference.status) {
         case "resolved_model":
-          initializeModelChunk(id);
+          initializeModelChunk(reference);
           break;
         case "resolved_module":
-          initializeModuleChunk(id);
+          initializeModuleChunk(reference);
       }
-      switch (id.status) {
+      switch (reference.status) {
         case "fulfilled":
-          for (var value = id.value, i = 1; i < reference.length; i++) {
-            for (; value.$$typeof === REACT_LAZY_TYPE; )
-              if (((value = value._payload), "fulfilled" === value.status))
-                value = value.value;
-              else
-                return waitForReference(
-                  value,
-                  parentObject,
-                  key,
-                  response,
-                  map,
-                  reference.slice(i - 1)
-                );
-            value = value[reference[i]];
+          for (var value = reference.value, i = 1; i < path.length; i++) {
+            for (
+              ;
+              "object" === typeof value &&
+              null !== value &&
+              value.$$typeof === REACT_LAZY_TYPE;
+
+            ) {
+              value = value._payload;
+              switch (value.status) {
+                case "resolved_model":
+                  initializeModelChunk(value);
+                  break;
+                case "resolved_module":
+                  initializeModuleChunk(value);
+              }
+              switch (value.status) {
+                case "fulfilled":
+                  value = value.value;
+                  break;
+                case "blocked":
+                case "pending":
+                  return waitForReference(
+                    value,
+                    parentObject,
+                    key,
+                    response,
+                    map,
+                    path.slice(i - 1),
+                    !1
+                  );
+                case "halted":
+                  return (
+                    initializingHandler
+                      ? ((parentObject = initializingHandler),
+                        parentObject.deps++)
+                      : (initializingHandler = {
+                          parent: null,
+                          chunk: null,
+                          value: null,
+                          reason: null,
+                          deps: 1,
+                          errored: !1
+                        }),
+                    null
+                  );
+                default:
+                  return (
+                    initializingHandler
+                      ? ((initializingHandler.errored = !0),
+                        (initializingHandler.value = null),
+                        (initializingHandler.reason = value.reason))
+                      : (initializingHandler = {
+                          parent: null,
+                          chunk: null,
+                          value: null,
+                          reason: value.reason,
+                          deps: 0,
+                          errored: !0
+                        }),
+                    null
+                  );
+              }
+            }
+            value = value[path[i]];
+          }
+          for (
+            ;
+            "object" === typeof value &&
+            null !== value &&
+            value.$$typeof === REACT_LAZY_TYPE;
+
+          ) {
+            path = value._payload;
+            switch (path.status) {
+              case "resolved_model":
+                initializeModelChunk(path);
+                break;
+              case "resolved_module":
+                initializeModuleChunk(path);
+            }
+            switch (path.status) {
+              case "fulfilled":
+                value = path.value;
+                continue;
+            }
+            break;
           }
           response = map(response, value, parentObject, key);
-          id._debugInfo &&
-            ("object" !== typeof response ||
-              null === response ||
-              (!isArrayImpl(response) &&
-                "function" !== typeof response[ASYNC_ITERATOR] &&
-                response.$$typeof !== REACT_ELEMENT_TYPE) ||
-              response._debugInfo ||
-              Object.defineProperty(response, "_debugInfo", {
-                configurable: !1,
-                enumerable: !1,
-                writable: !0,
-                value: id._debugInfo
-              }));
+          (parentObject[0] !== REACT_ELEMENT_TYPE ||
+            ("4" !== key && "5" !== key)) &&
+            transferReferencedDebugInfo(initializingChunk, reference);
           return response;
         case "pending":
         case "blocked":
           return waitForReference(
-            id,
+            reference,
             parentObject,
             key,
             response,
             map,
-            reference
+            path,
+            !1
+          );
+        case "halted":
+          return (
+            initializingHandler
+              ? ((parentObject = initializingHandler), parentObject.deps++)
+              : (initializingHandler = {
+                  parent: null,
+                  chunk: null,
+                  value: null,
+                  reason: null,
+                  deps: 1,
+                  errored: !1
+                }),
+            null
           );
         default:
           return (
             initializingHandler
               ? ((initializingHandler.errored = !0),
-                (initializingHandler.value = id.reason))
+                (initializingHandler.value = null),
+                (initializingHandler.reason = reference.reason))
               : (initializingHandler = {
                   parent: null,
                   chunk: null,
-                  value: id.reason,
+                  value: null,
+                  reason: reference.reason,
                   deps: 0,
                   errored: !0
                 }),
@@ -1402,12 +2371,63 @@
         response.append(model[i][0], model[i][1]);
       return response;
     }
+    function applyConstructor(response, model, parentObject) {
+      Object.setPrototypeOf(parentObject, model.prototype);
+    }
+    function defineLazyGetter(response, chunk, parentObject, key) {
+      Object.defineProperty(parentObject, key, {
+        get: function () {
+          "resolved_model" === chunk.status && initializeModelChunk(chunk);
+          switch (chunk.status) {
+            case "fulfilled":
+              return chunk.value;
+            case "rejected":
+              throw chunk.reason;
+          }
+          return "This object has been omitted by React in the console log to avoid sending too much data from the server. Try logging smaller or more specific objects.";
+        },
+        enumerable: !0,
+        configurable: !1
+      });
+      return null;
+    }
     function extractIterator(response, model) {
       return model[Symbol.iterator]();
     }
     function createModel(response, model) {
       return model;
     }
+    function getInferredFunctionApproximate(code) {
+      code = code.startsWith("Object.defineProperty(")
+        ? code.slice(22)
+        : code.startsWith("(")
+          ? code.slice(1)
+          : code;
+      if (code.startsWith("async function")) {
+        var idx = code.indexOf("(", 14);
+        if (-1 !== idx)
+          return (
+            (code = code.slice(14, idx).trim()),
+            (0, eval)("({" + JSON.stringify(code) + ":async function(){}})")[
+              code
+            ]
+          );
+      } else if (code.startsWith("function")) {
+        if (((idx = code.indexOf("(", 8)), -1 !== idx))
+          return (
+            (code = code.slice(8, idx).trim()),
+            (0, eval)("({" + JSON.stringify(code) + ":function(){}})")[code]
+          );
+      } else if (
+        code.startsWith("class") &&
+        ((idx = code.indexOf("{", 5)), -1 !== idx)
+      )
+        return (
+          (code = code.slice(5, idx).trim()),
+          (0, eval)("({" + JSON.stringify(code) + ":class{}})")[code]
+        );
+      return function () {};
+    }
     function parseModelString(response, parentObject, key, value) {
       if ("$" === value[0]) {
         if ("$" === value)
@@ -1418,6 +2438,7 @@
                 parent: initializingHandler,
                 chunk: null,
                 value: null,
+                reason: null,
                 deps: 0,
                 errored: !1
               }),
@@ -1430,24 +2451,30 @@
             return (
               (parentObject = parseInt(value.slice(2), 16)),
               (response = getChunk(response, parentObject)),
-              createLazyChunkWrapper(response)
+              null !== initializingChunk &&
+                isArrayImpl(initializingChunk._children) &&
+                initializingChunk._children.push(response),
+              createLazyChunkWrapper(response, 0)
             );
           case "@":
-            if (2 === value.length) return new Promise(function () {});
-            parentObject = parseInt(value.slice(2), 16);
-            return getChunk(response, parentObject);
+            return (
+              (parentObject = parseInt(value.slice(2), 16)),
+              (response = getChunk(response, parentObject)),
+              null !== initializingChunk &&
+                isArrayImpl(initializingChunk._children) &&
+                initializingChunk._children.push(response),
+              response
+            );
           case "S":
             return Symbol.for(value.slice(2));
           case "F":
-            return (
-              (value = value.slice(2)),
-              getOutlinedModel(
-                response,
-                value,
-                parentObject,
-                key,
-                loadServerReference
-              )
+            var ref = value.slice(2);
+            return getOutlinedModel(
+              response,
+              ref,
+              parentObject,
+              key,
+              loadServerReference
             );
           case "T":
             parentObject = "$" + value.slice(2);
@@ -1459,36 +2486,30 @@
             return response.get(parentObject);
           case "Q":
             return (
-              (value = value.slice(2)),
-              getOutlinedModel(response, value, parentObject, key, createMap)
+              (ref = value.slice(2)),
+              getOutlinedModel(response, ref, parentObject, key, createMap)
             );
           case "W":
             return (
-              (value = value.slice(2)),
-              getOutlinedModel(response, value, parentObject, key, createSet)
+              (ref = value.slice(2)),
+              getOutlinedModel(response, ref, parentObject, key, createSet)
             );
           case "B":
             return (
-              (value = value.slice(2)),
-              getOutlinedModel(response, value, parentObject, key, createBlob)
+              (ref = value.slice(2)),
+              getOutlinedModel(response, ref, parentObject, key, createBlob)
             );
           case "K":
             return (
-              (value = value.slice(2)),
-              getOutlinedModel(
-                response,
-                value,
-                parentObject,
-                key,
-                createFormData
-              )
+              (ref = value.slice(2)),
+              getOutlinedModel(response, ref, parentObject, key, createFormData)
             );
           case "Z":
             return (
-              (value = value.slice(2)),
+              (ref = value.slice(2)),
               getOutlinedModel(
                 response,
-                value,
+                ref,
                 parentObject,
                 key,
                 resolveErrorDev
@@ -1496,10 +2517,10 @@
             );
           case "i":
             return (
-              (value = value.slice(2)),
+              (ref = value.slice(2)),
               getOutlinedModel(
                 response,
-                value,
+                ref,
                 parentObject,
                 key,
                 extractIterator
@@ -1517,27 +2538,72 @@
             return new Date(Date.parse(value.slice(2)));
           case "n":
             return BigInt(value.slice(2));
+          case "P":
+            return (
+              (ref = value.slice(2)),
+              getOutlinedModel(
+                response,
+                ref,
+                parentObject,
+                key,
+                applyConstructor
+              )
+            );
           case "E":
+            response = value.slice(2);
             try {
-              return (0, eval)(value.slice(2));
-            } catch (x) {
-              return function () {};
+              if (!mightHaveStaticConstructor.test(response))
+                return (0, eval)(response);
+            } catch (x) {}
+            try {
+              if (
+                ((ref = getInferredFunctionApproximate(response)),
+                response.startsWith("Object.defineProperty("))
+              ) {
+                var idx = response.lastIndexOf(',"name",{value:"');
+                if (-1 !== idx) {
+                  var name = JSON.parse(
+                    response.slice(idx + 16 - 1, response.length - 2)
+                  );
+                  Object.defineProperty(ref, "name", { value: name });
+                }
+              }
+            } catch (_) {
+              ref = function () {};
             }
+            return ref;
           case "Y":
-            return (
-              Object.defineProperty(parentObject, key, {
-                get: function () {
-                  return "This object has been omitted by React in the console log to avoid sending too much data from the server. Try logging smaller or more specific objects.";
-                },
-                enumerable: !0,
-                configurable: !1
-              }),
-              null
-            );
+            if (
+              2 < value.length &&
+              (ref = response._debugChannel && response._debugChannel.callback)
+            ) {
+              if ("@" === value[2])
+                return (
+                  (parentObject = value.slice(3)),
+                  (key = parseInt(parentObject, 16)),
+                  response._chunks.has(key) || ref("P:" + parentObject),
+                  getChunk(response, key)
+                );
+              value = value.slice(2);
+              idx = parseInt(value, 16);
+              response._chunks.has(idx) || ref("Q:" + value);
+              ref = getChunk(response, idx);
+              return "fulfilled" === ref.status
+                ? ref.value
+                : defineLazyGetter(response, ref, parentObject, key);
+            }
+            Object.defineProperty(parentObject, key, {
+              get: function () {
+                return "This object has been omitted by React in the console log to avoid sending too much data from the server. Try logging smaller or more specific objects.";
+              },
+              enumerable: !0,
+              configurable: !1
+            });
+            return null;
           default:
             return (
-              (value = value.slice(1)),
-              getOutlinedModel(response, value, parentObject, key, createModel)
+              (ref = value.slice(1)),
+              getOutlinedModel(response, ref, parentObject, key, createModel)
             );
         }
       }
@@ -1558,7 +2624,8 @@
       temporaryReferences,
       findSourceMapURL,
       replayConsole,
-      environmentName
+      environmentName,
+      debugChannel
     ) {
       var chunks = new Map();
       this._bundlerConfig = bundlerConfig;
@@ -1570,11 +2637,13 @@
       this._chunks = chunks;
       this._stringDecoder = new TextDecoder();
       this._fromJSON = null;
-      this._rowLength = this._rowTag = this._rowID = this._rowState = 0;
-      this._buffer = [];
       this._closed = !1;
       this._closedReason = null;
       this._tempRefs = temporaryReferences;
+      this._timeOrigin = 0;
+      this._pendingInitialRender = null;
+      this._pendingChunks = 0;
+      this._weakResponse = { weak: new WeakRef(this), response: this };
       this._debugRootOwner = bundlerConfig =
         void 0 === ReactSharedInteralsServer ||
         null === ReactSharedInteralsServer.A
@@ -1587,36 +2656,100 @@
         (this._debugRootTask = console.createTask(
           '"use ' + environmentName.toLowerCase() + '"'
         ));
+      this._debugStartTime = performance.now();
       this._debugFindSourceMapURL = findSourceMapURL;
+      this._debugChannel = debugChannel;
+      this._blockedConsole = null;
       this._replayConsole = replayConsole;
       this._rootEnvironmentName = environmentName;
+      debugChannel &&
+        (null === debugChannelRegistry
+          ? (closeDebugChannel(debugChannel), (this._debugChannel = void 0))
+          : debugChannelRegistry.register(this, debugChannel, this));
+      replayConsole && markAllTracksInOrder();
       this._fromJSON = createFromJSONCallback(this);
     }
-    function resolveModel(response, id, model) {
-      var chunks = response._chunks,
-        chunk = chunks.get(id);
-      chunk
-        ? resolveModelChunk(chunk, model)
-        : chunks.set(
-            id,
-            new ReactPromise("resolved_model", model, null, response)
-          );
+    function createStreamState(weakResponse, streamDebugValue) {
+      var streamState = {
+        _rowState: 0,
+        _rowID: 0,
+        _rowTag: 0,
+        _rowLength: 0,
+        _buffer: []
+      };
+      weakResponse = unwrapWeakResponse(weakResponse);
+      var debugValuePromise = Promise.resolve(streamDebugValue);
+      debugValuePromise.status = "fulfilled";
+      debugValuePromise.value = streamDebugValue;
+      streamState._debugInfo = {
+        name: "RSC stream",
+        start: weakResponse._debugStartTime,
+        end: weakResponse._debugStartTime,
+        byteSize: 0,
+        value: debugValuePromise,
+        owner: weakResponse._debugRootOwner,
+        debugStack: weakResponse._debugRootStack,
+        debugTask: weakResponse._debugRootTask
+      };
+      streamState._debugTargetChunkSize = MIN_CHUNK_SIZE;
+      return streamState;
     }
-    function resolveText(response, id, text) {
-      var chunks = response._chunks,
-        chunk = chunks.get(id);
-      chunk && "pending" !== chunk.status
-        ? chunk.reason.enqueueValue(text)
-        : chunks.set(id, new ReactPromise("fulfilled", text, null, response));
+    function incrementChunkDebugInfo(streamState, chunkLength) {
+      var debugInfo = streamState._debugInfo,
+        endTime = performance.now(),
+        previousEndTime = debugInfo.end;
+      chunkLength = debugInfo.byteSize + chunkLength;
+      chunkLength > streamState._debugTargetChunkSize ||
+      endTime > previousEndTime + 10
+        ? ((streamState._debugInfo = {
+            name: debugInfo.name,
+            start: debugInfo.start,
+            end: endTime,
+            byteSize: chunkLength,
+            value: debugInfo.value,
+            owner: debugInfo.owner,
+            debugStack: debugInfo.debugStack,
+            debugTask: debugInfo.debugTask
+          }),
+          (streamState._debugTargetChunkSize = chunkLength + MIN_CHUNK_SIZE))
+        : ((debugInfo.end = endTime), (debugInfo.byteSize = chunkLength));
+    }
+    function addDebugInfo(chunk, debugInfo) {
+      var value = resolveLazy(chunk.value);
+      "object" !== typeof value ||
+      null === value ||
+      (!isArrayImpl(value) &&
+        "function" !== typeof value[ASYNC_ITERATOR] &&
+        value.$$typeof !== REACT_ELEMENT_TYPE &&
+        value.$$typeof !== REACT_LAZY_TYPE)
+        ? chunk._debugInfo.push.apply(chunk._debugInfo, debugInfo)
+        : isArrayImpl(value._debugInfo)
+          ? value._debugInfo.push.apply(value._debugInfo, debugInfo)
+          : Object.defineProperty(value, "_debugInfo", {
+              configurable: !1,
+              enumerable: !1,
+              writable: !0,
+              value: debugInfo
+            });
+    }
+    function resolveChunkDebugInfo(streamState, chunk) {
+      streamState = [{ awaited: streamState._debugInfo }];
+      "pending" === chunk.status || "blocked" === chunk.status
+        ? ((streamState = addDebugInfo.bind(null, chunk, streamState)),
+          chunk.then(streamState, streamState))
+        : addDebugInfo(chunk, streamState);
     }
-    function resolveBuffer(response, id, buffer) {
+    function resolveBuffer(response, id, buffer, streamState) {
       var chunks = response._chunks,
         chunk = chunks.get(id);
       chunk && "pending" !== chunk.status
         ? chunk.reason.enqueueValue(buffer)
-        : chunks.set(id, new ReactPromise("fulfilled", buffer, null, response));
+        : (chunk && releasePendingChunk(response, chunk),
+          (response = new ReactPromise("fulfilled", buffer, null)),
+          resolveChunkDebugInfo(streamState, response),
+          chunks.set(id, response));
     }
-    function resolveModule(response, id, model) {
+    function resolveModule(response, id, model, streamState) {
       var chunks = response._chunks,
         chunk = chunks.get(id);
       model = JSON.parse(model, response._fromJSON);
@@ -1626,48 +2759,78 @@
       );
       if ((model = preloadModule(clientReference))) {
         if (chunk) {
+          releasePendingChunk(response, chunk);
           var blockedChunk = chunk;
           blockedChunk.status = "blocked";
         } else
-          (blockedChunk = new ReactPromise("blocked", null, null, response)),
+          (blockedChunk = new ReactPromise("blocked", null, null)),
             chunks.set(id, blockedChunk);
+        resolveChunkDebugInfo(streamState, blockedChunk);
         model.then(
           function () {
-            return resolveModuleChunk(blockedChunk, clientReference);
+            return resolveModuleChunk(response, blockedChunk, clientReference);
           },
           function (error) {
-            return triggerErrorOnChunk(blockedChunk, error);
+            return triggerErrorOnChunk(response, blockedChunk, error);
           }
         );
       } else
         chunk
-          ? resolveModuleChunk(chunk, clientReference)
-          : chunks.set(
-              id,
-              new ReactPromise(
-                "resolved_module",
-                clientReference,
-                null,
-                response
-              )
-            );
+          ? (resolveChunkDebugInfo(streamState, chunk),
+            resolveModuleChunk(response, chunk, clientReference))
+          : ((chunk = new ReactPromise(
+              "resolved_module",
+              clientReference,
+              null
+            )),
+            resolveChunkDebugInfo(streamState, chunk),
+            chunks.set(id, chunk));
     }
-    function resolveStream(response, id, stream, controller) {
+    function resolveStream(response, id, stream, controller, streamState) {
       var chunks = response._chunks,
         chunk = chunks.get(id);
-      chunk
-        ? "pending" === chunk.status &&
-          ((response = chunk.value),
-          (chunk.status = "fulfilled"),
-          (chunk.value = stream),
-          (chunk.reason = controller),
-          null !== response && wakeChunk(response, chunk.value))
-        : chunks.set(
-            id,
-            new ReactPromise("fulfilled", stream, controller, response)
-          );
+      if (chunk) {
+        if (
+          (resolveChunkDebugInfo(streamState, chunk),
+          "pending" === chunk.status)
+        ) {
+          releasePendingChunk(response, chunk);
+          id = chunk.value;
+          if (null != chunk._debugChunk) {
+            streamState = initializingHandler;
+            chunks = initializingChunk;
+            initializingHandler = null;
+            chunk.status = "blocked";
+            chunk.value = null;
+            chunk.reason = null;
+            initializingChunk = chunk;
+            try {
+              if (
+                (initializeDebugChunk(response, chunk),
+                null !== initializingHandler &&
+                  !initializingHandler.errored &&
+                  0 < initializingHandler.deps)
+              ) {
+                initializingHandler.value = stream;
+                initializingHandler.reason = controller;
+                initializingHandler.chunk = chunk;
+                return;
+              }
+            } finally {
+              (initializingHandler = streamState), (initializingChunk = chunks);
+            }
+          }
+          chunk.status = "fulfilled";
+          chunk.value = stream;
+          chunk.reason = controller;
+          null !== id && wakeChunk(id, chunk.value, chunk);
+        }
+      } else
+        (response = new ReactPromise("fulfilled", stream, controller)),
+          resolveChunkDebugInfo(streamState, response),
+          chunks.set(id, response);
     }
-    function startReadableStream(response, id, type) {
+    function startReadableStream(response, id, type, streamState) {
       var controller = null;
       type = new ReadableStream({
         type: type,
@@ -1676,73 +2839,75 @@
         }
       });
       var previousBlockedChunk = null;
-      resolveStream(response, id, type, {
-        enqueueValue: function (value) {
-          null === previousBlockedChunk
-            ? controller.enqueue(value)
-            : previousBlockedChunk.then(function () {
-                controller.enqueue(value);
+      resolveStream(
+        response,
+        id,
+        type,
+        {
+          enqueueValue: function (value) {
+            null === previousBlockedChunk
+              ? controller.enqueue(value)
+              : previousBlockedChunk.then(function () {
+                  controller.enqueue(value);
+                });
+          },
+          enqueueModel: function (json) {
+            if (null === previousBlockedChunk) {
+              var chunk = createResolvedModelChunk(response, json);
+              initializeModelChunk(chunk);
+              "fulfilled" === chunk.status
+                ? controller.enqueue(chunk.value)
+                : (chunk.then(
+                    function (v) {
+                      return controller.enqueue(v);
+                    },
+                    function (e) {
+                      return controller.error(e);
+                    }
+                  ),
+                  (previousBlockedChunk = chunk));
+            } else {
+              chunk = previousBlockedChunk;
+              var _chunk3 = createPendingChunk(response);
+              _chunk3.then(
+                function (v) {
+                  return controller.enqueue(v);
+                },
+                function (e) {
+                  return controller.error(e);
+                }
+              );
+              previousBlockedChunk = _chunk3;
+              chunk.then(function () {
+                previousBlockedChunk === _chunk3 &&
+                  (previousBlockedChunk = null);
+                resolveModelChunk(response, _chunk3, json);
               });
-        },
-        enqueueModel: function (json) {
-          if (null === previousBlockedChunk) {
-            var chunk = new ReactPromise(
-              "resolved_model",
-              json,
-              null,
-              response
-            );
-            initializeModelChunk(chunk);
-            "fulfilled" === chunk.status
-              ? controller.enqueue(chunk.value)
-              : (chunk.then(
-                  function (v) {
-                    return controller.enqueue(v);
-                  },
-                  function (e) {
-                    return controller.error(e);
-                  }
-                ),
-                (previousBlockedChunk = chunk));
-          } else {
-            chunk = previousBlockedChunk;
-            var _chunk3 = createPendingChunk(response);
-            _chunk3.then(
-              function (v) {
-                return controller.enqueue(v);
-              },
-              function (e) {
-                return controller.error(e);
-              }
-            );
-            previousBlockedChunk = _chunk3;
-            chunk.then(function () {
-              previousBlockedChunk === _chunk3 && (previousBlockedChunk = null);
-              resolveModelChunk(_chunk3, json);
-            });
-          }
-        },
-        close: function () {
-          if (null === previousBlockedChunk) controller.close();
-          else {
-            var blockedChunk = previousBlockedChunk;
-            previousBlockedChunk = null;
-            blockedChunk.then(function () {
-              return controller.close();
-            });
+            }
+          },
+          close: function () {
+            if (null === previousBlockedChunk) controller.close();
+            else {
+              var blockedChunk = previousBlockedChunk;
+              previousBlockedChunk = null;
+              blockedChunk.then(function () {
+                return controller.close();
+              });
+            }
+          },
+          error: function (error) {
+            if (null === previousBlockedChunk) controller.error(error);
+            else {
+              var blockedChunk = previousBlockedChunk;
+              previousBlockedChunk = null;
+              blockedChunk.then(function () {
+                return controller.error(error);
+              });
+            }
           }
         },
-        error: function (error) {
-          if (null === previousBlockedChunk) controller.error(error);
-          else {
-            var blockedChunk = previousBlockedChunk;
-            previousBlockedChunk = null;
-            blockedChunk.then(function () {
-              return controller.error(error);
-            });
-          }
-        }
-      });
+        streamState
+      );
     }
     function asyncIterator() {
       return this;
@@ -1752,30 +2917,30 @@
       next[ASYNC_ITERATOR] = asyncIterator;
       return next;
     }
-    function startAsyncIterable(response, id, iterator) {
+    function startAsyncIterable(response, id, iterator, streamState) {
       var buffer = [],
         closed = !1,
         nextWriteIndex = 0,
-        iterable = _defineProperty({}, ASYNC_ITERATOR, function () {
-          var nextReadIndex = 0;
-          return createIterator(function (arg) {
-            if (void 0 !== arg)
-              throw Error(
-                "Values cannot be passed to next() of AsyncIterables passed to Client Components."
+        iterable = {};
+      iterable[ASYNC_ITERATOR] = function () {
+        var nextReadIndex = 0;
+        return createIterator(function (arg) {
+          if (void 0 !== arg)
+            throw Error(
+              "Values cannot be passed to next() of AsyncIterables passed to Client Components."
+            );
+          if (nextReadIndex === buffer.length) {
+            if (closed)
+              return new ReactPromise(
+                "fulfilled",
+                { done: !0, value: void 0 },
+                null
               );
-            if (nextReadIndex === buffer.length) {
-              if (closed)
-                return new ReactPromise(
-                  "fulfilled",
-                  { done: !0, value: void 0 },
-                  null,
-                  response
-                );
-              buffer[nextReadIndex] = createPendingChunk(response);
-            }
-            return buffer[nextReadIndex++];
-          });
+            buffer[nextReadIndex] = createPendingChunk(response);
+          }
+          return buffer[nextReadIndex++];
         });
+      };
       resolveStream(
         response,
         id,
@@ -1786,8 +2951,7 @@
               buffer[nextWriteIndex] = new ReactPromise(
                 "fulfilled",
                 { done: !1, value: value },
-                null,
-                response
+                null
               );
             else {
               var chunk = buffer[nextWriteIndex],
@@ -1811,7 +2975,12 @@
                   value,
                   !1
                 ))
-              : resolveIteratorResultChunk(buffer[nextWriteIndex], value, !1);
+              : resolveIteratorResultChunk(
+                  response,
+                  buffer[nextWriteIndex],
+                  value,
+                  !1
+                );
             nextWriteIndex++;
           },
           close: function (value) {
@@ -1822,9 +2991,15 @@
                   value,
                   !0
                 ))
-              : resolveIteratorResultChunk(buffer[nextWriteIndex], value, !0);
+              : resolveIteratorResultChunk(
+                  response,
+                  buffer[nextWriteIndex],
+                  value,
+                  !0
+                );
             for (nextWriteIndex++; nextWriteIndex < buffer.length; )
               resolveIteratorResultChunk(
+                response,
                 buffer[nextWriteIndex++],
                 '"$undefined"',
                 !0
@@ -1838,78 +3013,45 @@
               nextWriteIndex < buffer.length;
 
             )
-              triggerErrorOnChunk(buffer[nextWriteIndex++], error);
+              triggerErrorOnChunk(response, buffer[nextWriteIndex++], error);
           }
-        }
+        },
+        streamState
       );
     }
-    function stopStream(response, id, row) {
-      (response = response._chunks.get(id)) &&
-        "fulfilled" === response.status &&
-        response.reason.close("" === row ? '"$undefined"' : row);
-    }
     function resolveErrorDev(response, errorInfo) {
       var name = errorInfo.name,
         env = errorInfo.env;
-      errorInfo = buildFakeCallStack(
+      var error = buildFakeCallStack(
         response,
         errorInfo.stack,
         env,
+        !1,
         Error.bind(
           null,
           errorInfo.message ||
             "An error occurred in the Server Components render but no message was provided"
         )
       );
-      response = getRootTask(response, env);
-      response = null != response ? response.run(errorInfo) : errorInfo();
-      response.name = name;
-      response.environmentName = env;
-      return response;
-    }
-    function resolveHint(response, code, model) {
-      response = JSON.parse(model, response._fromJSON);
-      model = ReactDOMSharedInternals.d;
-      switch (code) {
-        case "D":
-          model.D(response);
-          break;
-        case "C":
-          "string" === typeof response
-            ? model.C(response)
-            : model.C(response[0], response[1]);
-          break;
-        case "L":
-          code = response[0];
-          var as = response[1];
-          3 === response.length
-            ? model.L(code, as, response[2])
-            : model.L(code, as);
-          break;
-        case "m":
-          "string" === typeof response
-            ? model.m(response)
-            : model.m(response[0], response[1]);
-          break;
-        case "X":
-          "string" === typeof response
-            ? model.X(response)
-            : model.X(response[0], response[1]);
-          break;
-        case "S":
-          "string" === typeof response
-            ? model.S(response)
-            : model.S(
-                response[0],
-                0 === response[1] ? void 0 : response[1],
-                3 === response.length ? response[2] : void 0
-              );
-          break;
-        case "M":
-          "string" === typeof response
-            ? model.M(response)
-            : model.M(response[0], response[1]);
-      }
+      var ownerTask = null;
+      null != errorInfo.owner &&
+        ((errorInfo = errorInfo.owner.slice(1)),
+        (errorInfo = getOutlinedModel(
+          response,
+          errorInfo,
+          {},
+          "",
+          createModel
+        )),
+        null !== errorInfo &&
+          (ownerTask = initializeFakeTask(response, errorInfo)));
+      null === ownerTask
+        ? ((response = getRootTask(response, env)),
+          (error = null != response ? response.run(error) : error()))
+        : (error = ownerTask.run(error));
+      error.name = name;
+      error.environmentName = env;
+      return error;
     }
     function createFakeFunction(
       name,
@@ -1917,41 +3059,90 @@
       sourceMap,
       line,
       col,
+      enclosingLine,
+      enclosingCol,
       environmentName
     ) {
       name || (name = "<anonymous>");
       var encodedName = JSON.stringify(name);
-      1 >= line
-        ? ((line = encodedName.length + 7),
-          (col =
-            "({" +
-            encodedName +
-            ":_=>" +
-            " ".repeat(col < line ? 0 : col - line) +
-            "_()})\n/* This module was rendered by a Server Component. Turn on Source Maps to see the server source. */"))
-        : (col =
-            "/* This module was rendered by a Server Component. Turn on Source Maps to see the server source. */" +
-            "\n".repeat(line - 2) +
+      1 > enclosingLine ? (enclosingLine = 0) : enclosingLine--;
+      1 > enclosingCol ? (enclosingCol = 0) : enclosingCol--;
+      1 > line ? (line = 0) : line--;
+      1 > col ? (col = 0) : col--;
+      if (
+        line < enclosingLine ||
+        (line === enclosingLine && col < enclosingCol)
+      )
+        enclosingCol = enclosingLine = 0;
+      1 > line
+        ? ((line = encodedName.length + 3),
+          (enclosingCol -= line),
+          0 > enclosingCol && (enclosingCol = 0),
+          (col = col - enclosingCol - line - 3),
+          0 > col && (col = 0),
+          (encodedName =
             "({" +
             encodedName +
-            ":_=>\n" +
-            " ".repeat(1 > col ? 0 : col - 1) +
-            "_()})");
+            ":" +
+            " ".repeat(enclosingCol) +
+            "_=>" +
+            " ".repeat(col) +
+            "_()})"))
+        : 1 > enclosingLine
+          ? ((enclosingCol -= encodedName.length + 3),
+            0 > enclosingCol && (enclosingCol = 0),
+            (encodedName =
+              "({" +
+              encodedName +
+              ":" +
+              " ".repeat(enclosingCol) +
+              "_=>" +
+              "\n".repeat(line - enclosingLine) +
+              " ".repeat(col) +
+              "_()})"))
+          : enclosingLine === line
+            ? ((col = col - enclosingCol - 3),
+              0 > col && (col = 0),
+              (encodedName =
+                "\n".repeat(enclosingLine - 1) +
+                "({" +
+                encodedName +
+                ":\n" +
+                " ".repeat(enclosingCol) +
+                "_=>" +
+                " ".repeat(col) +
+                "_()})"))
+            : (encodedName =
+                "\n".repeat(enclosingLine - 1) +
+                "({" +
+                encodedName +
+                ":\n" +
+                " ".repeat(enclosingCol) +
+                "_=>" +
+                "\n".repeat(line - enclosingLine) +
+                " ".repeat(col) +
+                "_()})");
+      encodedName =
+        1 > enclosingLine
+          ? encodedName +
+            "\n/* This module was rendered by a Server Component. Turn on Source Maps to see the server source. */"
+          : "/* This module was rendered by a Server Component. Turn on Source Maps to see the server source. */" +
+            encodedName;
       filename.startsWith("/") && (filename = "file://" + filename);
       sourceMap
-        ? ((col +=
-            "\n//# sourceURL=rsc://React/" +
+        ? ((encodedName +=
+            "\n//# sourceURL=about://React/" +
             encodeURIComponent(environmentName) +
             "/" +
             encodeURI(filename) +
             "?" +
             fakeFunctionIdx++),
-          (col += "\n//# sourceMappingURL=" + sourceMap))
-        : (col = filename
-            ? col + ("\n//# sourceURL=" + encodeURI(filename))
-            : col + "\n//# sourceURL=<anonymous>");
+          (encodedName += "\n//# sourceMappingURL=" + sourceMap))
+        : (encodedName = filename
+            ? encodedName + ("\n//# sourceURL=" + encodeURI(filename))
+            : encodedName + "\n//# sourceURL=<anonymous>");
       try {
-        var fn = (0, eval)(col)[name];
+        var fn = (0, eval)(encodedName)[name];
       } catch (x) {
         fn = function (_) {
           return _();
@@ -1959,16 +3150,28 @@
       }
       return fn;
     }
-    function buildFakeCallStack(response, stack, environmentName, innerCall) {
+    function buildFakeCallStack(
+      response,
+      stack,
+      environmentName,
+      useEnclosingLine,
+      innerCall
+    ) {
       for (var i = 0; i < stack.length; i++) {
         var frame = stack[i],
-          frameKey = frame.join("-") + "-" + environmentName,
+          frameKey =
+            frame.join("-") +
+            "-" +
+            environmentName +
+            (useEnclosingLine ? "-e" : "-n"),
           fn = fakeFunctionCache.get(frameKey);
         if (void 0 === fn) {
           fn = frame[0];
           var filename = frame[1],
-            line = frame[2];
-          frame = frame[3];
+            line = frame[2],
+            col = frame[3],
+            enclosingLine = frame[4];
+          frame = frame[5];
           var findSourceMapURL = response._debugFindSourceMapURL;
           findSourceMapURL = findSourceMapURL
             ? findSourceMapURL(filename, environmentName)
@@ -1978,7 +3181,9 @@
             filename,
             findSourceMapURL,
             line,
-            frame,
+            col,
+            useEnclosingLine ? line : enclosingLine,
+            useEnclosingLine ? col : frame,
             environmentName
           );
           fakeFunctionCache.set(frameKey, fn);
@@ -1999,75 +3204,79 @@
           : rootTask
         : null;
     }
-    function initializeFakeTask(response, debugInfo, childEnvironmentName) {
+    function initializeFakeTask(response, debugInfo) {
       if (!supportsCreateTask || null == debugInfo.stack) return null;
-      var stack = debugInfo.stack,
+      var cachedEntry = debugInfo.debugTask;
+      if (void 0 !== cachedEntry) return cachedEntry;
+      var useEnclosingLine = void 0 === debugInfo.key,
+        stack = debugInfo.stack,
         env =
           null == debugInfo.env ? response._rootEnvironmentName : debugInfo.env;
-      if (env !== childEnvironmentName)
-        return (
-          (debugInfo =
-            null == debugInfo.owner
-              ? null
-              : initializeFakeTask(response, debugInfo.owner, env)),
-          buildFakeTask(
-            response,
-            debugInfo,
-            stack,
-            '"use ' + childEnvironmentName.toLowerCase() + '"',
-            env
-          )
-        );
-      childEnvironmentName = debugInfo.debugTask;
-      if (void 0 !== childEnvironmentName) return childEnvironmentName;
-      childEnvironmentName =
+      cachedEntry =
+        null == debugInfo.owner || null == debugInfo.owner.env
+          ? response._rootEnvironmentName
+          : debugInfo.owner.env;
+      var ownerTask =
         null == debugInfo.owner
           ? null
-          : initializeFakeTask(response, debugInfo.owner, env);
-      return (debugInfo.debugTask = buildFakeTask(
+          : initializeFakeTask(response, debugInfo.owner);
+      env =
+        env !== cachedEntry
+          ? '"use ' + env.toLowerCase() + '"'
+          : void 0 !== debugInfo.key
+            ? "<" + (debugInfo.name || "...") + ">"
+            : void 0 !== debugInfo.name
+              ? debugInfo.name || "unknown"
+              : "await " + (debugInfo.awaited.name || "unknown");
+      env = console.createTask.bind(console, env);
+      useEnclosingLine = buildFakeCallStack(
         response,
-        childEnvironmentName,
         stack,
-        "<" + (debugInfo.name || "...") + ">",
+        cachedEntry,
+        useEnclosingLine,
         env
-      ));
-    }
-    function buildFakeTask(response, ownerTask, stack, taskName, env) {
-      taskName = console.createTask.bind(console, taskName);
-      stack = buildFakeCallStack(response, stack, env, taskName);
-      return null === ownerTask
-        ? ((response = getRootTask(response, env)),
-          null != response ? response.run(stack) : stack())
-        : ownerTask.run(stack);
+      );
+      null === ownerTask
+        ? ((response = getRootTask(response, cachedEntry)),
+          (response =
+            null != response
+              ? response.run(useEnclosingLine)
+              : useEnclosingLine()))
+        : (response = ownerTask.run(useEnclosingLine));
+      return (debugInfo.debugTask = response);
     }
     function fakeJSXCallSite() {
       return Error("react-stack-top-frame");
     }
     function initializeFakeStack(response, debugInfo) {
-      void 0 === debugInfo.debugStack &&
-        (null != debugInfo.stack &&
+      if (void 0 === debugInfo.debugStack) {
+        null != debugInfo.stack &&
           (debugInfo.debugStack = createFakeJSXCallStackInDEV(
             response,
             debugInfo.stack,
             null == debugInfo.env ? "" : debugInfo.env
-          )),
-        null != debugInfo.owner &&
-          initializeFakeStack(response, debugInfo.owner));
+          ));
+        var owner = debugInfo.owner;
+        null != owner &&
+          (initializeFakeStack(response, owner),
+          void 0 === owner.debugLocation &&
+            null != debugInfo.debugStack &&
+            (owner.debugLocation = debugInfo.debugStack));
+      }
     }
-    function resolveDebugInfo(response, id, debugInfo) {
-      var env =
-        void 0 === debugInfo.env
-          ? response._rootEnvironmentName
-          : debugInfo.env;
-      void 0 !== debugInfo.stack &&
-        initializeFakeTask(response, debugInfo, env);
-      null === debugInfo.owner && null != response._debugRootOwner
-        ? ((debugInfo.owner = response._debugRootOwner),
-          (debugInfo.debugStack = response._debugRootStack))
-        : void 0 !== debugInfo.stack &&
-          initializeFakeStack(response, debugInfo);
-      response = getChunk(response, id);
-      (response._debugInfo || (response._debugInfo = [])).push(debugInfo);
+    function initializeDebugInfo(response, debugInfo) {
+      void 0 !== debugInfo.stack && initializeFakeTask(response, debugInfo);
+      if (null == debugInfo.owner && null != response._debugRootOwner) {
+        var _componentInfoOrAsyncInfo = debugInfo;
+        _componentInfoOrAsyncInfo.owner = response._debugRootOwner;
+        _componentInfoOrAsyncInfo.stack = null;
+        _componentInfoOrAsyncInfo.debugStack = response._debugRootStack;
+        _componentInfoOrAsyncInfo.debugTask = response._debugRootTask;
+      } else
+        void 0 !== debugInfo.stack && initializeFakeStack(response, debugInfo);
+      "number" === typeof debugInfo.time &&
+        (debugInfo = { time: debugInfo.time + response._timeOrigin });
+      return debugInfo;
     }
     function getCurrentStackInDEV() {
       var owner = currentOwnerInDEV;
@@ -2124,24 +3333,83 @@
       }
       return JSCompiler_inline_result$jscomp$0;
     }
-    function resolveConsoleEntry(response, value) {
+    function resolveConsoleEntry(response, json) {
       if (response._replayConsole) {
-        var payload = JSON.parse(value, response._fromJSON);
-        value = payload[0];
-        var stackTrace = payload[1],
-          owner = payload[2],
-          env = payload[3];
-        payload = payload.slice(4);
-        replayConsoleWithCallStackInDEV(
-          response,
-          value,
-          stackTrace,
-          owner,
-          env,
-          payload
-        );
+        var blockedChunk = response._blockedConsole;
+        if (null == blockedChunk)
+          (blockedChunk = createResolvedModelChunk(response, json)),
+            initializeModelChunk(blockedChunk),
+            "fulfilled" === blockedChunk.status
+              ? replayConsoleWithCallStackInDEV(response, blockedChunk.value)
+              : (blockedChunk.then(
+                  function (v) {
+                    return replayConsoleWithCallStackInDEV(response, v);
+                  },
+                  function () {}
+                ),
+                (response._blockedConsole = blockedChunk));
+        else {
+          var _chunk4 = createPendingChunk(response);
+          _chunk4.then(
+            function (v) {
+              return replayConsoleWithCallStackInDEV(response, v);
+            },
+            function () {}
+          );
+          response._blockedConsole = _chunk4;
+          var unblock = function () {
+            response._blockedConsole === _chunk4 &&
+              (response._blockedConsole = null);
+            resolveModelChunk(response, _chunk4, json);
+          };
+          blockedChunk.then(unblock, unblock);
+        }
       }
     }
+    function initializeIOInfo(response, ioInfo) {
+      void 0 !== ioInfo.stack &&
+        (initializeFakeTask(response, ioInfo),
+        initializeFakeStack(response, ioInfo));
+      ioInfo.start += response._timeOrigin;
+      ioInfo.end += response._timeOrigin;
+      if (response._replayConsole) {
+        response = response._rootEnvironmentName;
+        var promise = ioInfo.value;
+        if (promise)
+          switch (promise.status) {
+            case "fulfilled":
+              logIOInfo(ioInfo, response, promise.value);
+              break;
+            case "rejected":
+              logIOInfoErrored(ioInfo, response, promise.reason);
+              break;
+            default:
+              promise.then(
+                logIOInfo.bind(null, ioInfo, response),
+                logIOInfoErrored.bind(null, ioInfo, response)
+              );
+          }
+        else logIOInfo(ioInfo, response, void 0);
+      }
+    }
+    function resolveIOInfo(response, id, model) {
+      var chunks = response._chunks,
+        chunk = chunks.get(id);
+      chunk
+        ? (resolveModelChunk(response, chunk, model),
+          "resolved_model" === chunk.status && initializeModelChunk(chunk))
+        : ((chunk = createResolvedModelChunk(response, model)),
+          chunks.set(id, chunk),
+          initializeModelChunk(chunk));
+      "fulfilled" === chunk.status
+        ? initializeIOInfo(response, chunk.value)
+        : chunk.then(
+            function (v) {
+              initializeIOInfo(response, v);
+            },
+            function () {}
+          );
+    }
     function mergeBuffer(buffer, lastChunk) {
       for (
         var l = buffer.length, byteLength = lastChunk.length, i = 0;
@@ -2150,8 +3418,8 @@
       )
         byteLength += buffer[i].byteLength;
       byteLength = new Uint8Array(byteLength);
-      for (var _i2 = (i = 0); _i2 < l; _i2++) {
-        var chunk = buffer[_i2];
+      for (var _i3 = (i = 0); _i3 < l; _i3++) {
+        var chunk = buffer[_i3];
         byteLength.set(chunk, i);
         i += chunk.byteLength;
       }
@@ -2164,7 +3432,8 @@
       buffer,
       lastChunk,
       constructor,
-      bytesPerElement
+      bytesPerElement,
+      streamState
     ) {
       buffer =
         0 === buffer.length && 0 === lastChunk.byteOffset % bytesPerElement
@@ -2175,52 +3444,684 @@
         buffer.byteOffset,
         buffer.byteLength / bytesPerElement
       );
-      resolveBuffer(response, id, constructor);
+      resolveBuffer(response, id, constructor, streamState);
+    }
+    function flushComponentPerformance(
+      response$jscomp$0,
+      root,
+      trackIdx$jscomp$6,
+      trackTime,
+      parentEndTime
+    ) {
+      if (!isArrayImpl(root._children)) {
+        var previousResult = root._children,
+          previousEndTime = previousResult.endTime;
+        if (
+          -Infinity < parentEndTime &&
+          parentEndTime < previousEndTime &&
+          null !== previousResult.component
+        ) {
+          var componentInfo = previousResult.component,
+            trackIdx = trackIdx$jscomp$6,
+            startTime = parentEndTime;
+          if (supportsUserTiming && 0 <= previousEndTime && 10 > trackIdx) {
+            var color =
+                componentInfo.env === response$jscomp$0._rootEnvironmentName
+                  ? "primary-light"
+                  : "secondary-light",
+              entryName = componentInfo.name + " [deduped]",
+              debugTask = componentInfo.debugTask;
+            debugTask
+              ? debugTask.run(
+                  console.timeStamp.bind(
+                    console,
+                    entryName,
+                    0 > startTime ? 0 : startTime,
+                    previousEndTime,
+                    trackNames[trackIdx],
+                    "Server Components \u269b",
+                    color
+                  )
+                )
+              : console.timeStamp(
+                  entryName,
+                  0 > startTime ? 0 : startTime,
+                  previousEndTime,
+                  trackNames[trackIdx],
+                  "Server Components \u269b",
+                  color
+                );
+          }
+        }
+        previousResult.track = trackIdx$jscomp$6;
+        return previousResult;
+      }
+      var children = root._children,
+        debugInfo = root._debugInfo;
+      if (debugInfo) {
+        for (var startTime$jscomp$0 = 0, i = 0; i < debugInfo.length; i++) {
+          var info = debugInfo[i];
+          "number" === typeof info.time && (startTime$jscomp$0 = info.time);
+          if ("string" === typeof info.name) {
+            startTime$jscomp$0 < trackTime && trackIdx$jscomp$6++;
+            trackTime = startTime$jscomp$0;
+            break;
+          }
+        }
+        for (var _i4 = debugInfo.length - 1; 0 <= _i4; _i4--) {
+          var _info = debugInfo[_i4];
+          if ("number" === typeof _info.time && _info.time > parentEndTime) {
+            parentEndTime = _info.time;
+            break;
+          }
+        }
+      }
+      var result = {
+        track: trackIdx$jscomp$6,
+        endTime: -Infinity,
+        component: null
+      };
+      root._children = result;
+      for (
+        var childrenEndTime = -Infinity,
+          childTrackIdx = trackIdx$jscomp$6,
+          childTrackTime = trackTime,
+          _i5 = 0;
+        _i5 < children.length;
+        _i5++
+      ) {
+        var childResult = flushComponentPerformance(
+          response$jscomp$0,
+          children[_i5],
+          childTrackIdx,
+          childTrackTime,
+          parentEndTime
+        );
+        null !== childResult.component &&
+          (result.component = childResult.component);
+        childTrackIdx = childResult.track;
+        var childEndTime = childResult.endTime;
+        childEndTime > childTrackTime && (childTrackTime = childEndTime);
+        childEndTime > childrenEndTime && (childrenEndTime = childEndTime);
+      }
+      if (debugInfo)
+        for (
+          var componentEndTime = 0,
+            isLastComponent = !0,
+            endTime = -1,
+            endTimeIdx = -1,
+            _i6 = debugInfo.length - 1;
+          0 <= _i6;
+          _i6--
+        ) {
+          var _info2 = debugInfo[_i6];
+          if ("number" === typeof _info2.time) {
+            0 === componentEndTime && (componentEndTime = _info2.time);
+            var time = _info2.time;
+            if (-1 < endTimeIdx)
+              for (var j = endTimeIdx - 1; j > _i6; j--) {
+                var candidateInfo = debugInfo[j];
+                if ("string" === typeof candidateInfo.name) {
+                  componentEndTime > childrenEndTime &&
+                    (childrenEndTime = componentEndTime);
+                  var componentInfo$jscomp$0 = candidateInfo,
+                    response = response$jscomp$0,
+                    componentInfo$jscomp$1 = componentInfo$jscomp$0,
+                    trackIdx$jscomp$0 = trackIdx$jscomp$6,
+                    startTime$jscomp$1 = time,
+                    componentEndTime$jscomp$0 = componentEndTime,
+                    childrenEndTime$jscomp$0 = childrenEndTime;
+                  if (
+                    isLastComponent &&
+                    "rejected" === root.status &&
+                    root.reason !== response._closedReason
+                  ) {
+                    var componentInfo$jscomp$2 = componentInfo$jscomp$1,
+                      trackIdx$jscomp$1 = trackIdx$jscomp$0,
+                      startTime$jscomp$2 = startTime$jscomp$1,
+                      childrenEndTime$jscomp$1 = childrenEndTime$jscomp$0,
+                      error = root.reason;
+                    if (supportsUserTiming) {
+                      var env = componentInfo$jscomp$2.env,
+                        name = componentInfo$jscomp$2.name,
+                        entryName$jscomp$0 =
+                          env === response._rootEnvironmentName ||
+                          void 0 === env
+                            ? name
+                            : name + " [" + env + "]",
+                        properties = [
+                          [
+                            "Error",
+                            "object" === typeof error &&
+                            null !== error &&
+                            "string" === typeof error.message
+                              ? String(error.message)
+                              : String(error)
+                          ]
+                        ];
+                      null != componentInfo$jscomp$2.key &&
+                        addValueToProperties(
+                          "key",
+                          componentInfo$jscomp$2.key,
+                          properties,
+                          0,
+                          ""
+                        );
+                      null != componentInfo$jscomp$2.props &&
+                        addObjectToProperties(
+                          componentInfo$jscomp$2.props,
+                          properties,
+                          0,
+                          ""
+                        );
+                      performance.measure("\u200b" + entryName$jscomp$0, {
+                        start: 0 > startTime$jscomp$2 ? 0 : startTime$jscomp$2,
+                        end: childrenEndTime$jscomp$1,
+                        detail: {
+                          devtools: {
+                            color: "error",
+                            track: trackNames[trackIdx$jscomp$1],
+                            trackGroup: "Server Components \u269b",
+                            tooltipText: entryName$jscomp$0 + " Errored",
+                            properties: properties
+                          }
+                        }
+                      });
+                    }
+                  } else {
+                    var componentInfo$jscomp$3 = componentInfo$jscomp$1,
+                      trackIdx$jscomp$2 = trackIdx$jscomp$0,
+                      startTime$jscomp$3 = startTime$jscomp$1,
+                      childrenEndTime$jscomp$2 = childrenEndTime$jscomp$0;
+                    if (
+                      supportsUserTiming &&
+                      0 <= childrenEndTime$jscomp$2 &&
+                      10 > trackIdx$jscomp$2
+                    ) {
+                      var env$jscomp$0 = componentInfo$jscomp$3.env,
+                        name$jscomp$0 = componentInfo$jscomp$3.name,
+                        isPrimaryEnv =
+                          env$jscomp$0 === response._rootEnvironmentName,
+                        selfTime =
+                          componentEndTime$jscomp$0 - startTime$jscomp$3,
+                        color$jscomp$0 =
+                          0.5 > selfTime
+                            ? isPrimaryEnv
+                              ? "primary-light"
+                              : "secondary-light"
+                            : 50 > selfTime
+                              ? isPrimaryEnv
+                                ? "primary"
+                                : "secondary"
+                              : 500 > selfTime
+                                ? isPrimaryEnv
+                                  ? "primary-dark"
+                                  : "secondary-dark"
+                                : "error",
+                        entryName$jscomp$1 =
+                          isPrimaryEnv || void 0 === env$jscomp$0
+                            ? name$jscomp$0
+                            : name$jscomp$0 + " [" + env$jscomp$0 + "]",
+                        debugTask$jscomp$0 = componentInfo$jscomp$3.debugTask;
+                      if (debugTask$jscomp$0) {
+                        var properties$jscomp$0 = [];
+                        null != componentInfo$jscomp$3.key &&
+                          addValueToProperties(
+                            "key",
+                            componentInfo$jscomp$3.key,
+                            properties$jscomp$0,
+                            0,
+                            ""
+                          );
+                        null != componentInfo$jscomp$3.props &&
+                          addObjectToProperties(
+                            componentInfo$jscomp$3.props,
+                            properties$jscomp$0,
+                            0,
+                            ""
+                          );
+                        debugTask$jscomp$0.run(
+                          performance.measure.bind(
+                            performance,
+                            "\u200b" + entryName$jscomp$1,
+                            {
+                              start:
+                                0 > startTime$jscomp$3 ? 0 : startTime$jscomp$3,
+                              end: childrenEndTime$jscomp$2,
+                              detail: {
+                                devtools: {
+                                  color: color$jscomp$0,
+                                  track: trackNames[trackIdx$jscomp$2],
+                                  trackGroup: "Server Components \u269b",
+                                  properties: properties$jscomp$0
+                                }
+                              }
+                            }
+                          )
+                        );
+                      } else
+                        console.timeStamp(
+                          "\u200b" + entryName$jscomp$1,
+                          0 > startTime$jscomp$3 ? 0 : startTime$jscomp$3,
+                          childrenEndTime$jscomp$2,
+                          trackNames[trackIdx$jscomp$2],
+                          "Server Components \u269b",
+                          color$jscomp$0
+                        );
+                    }
+                  }
+                  componentEndTime = time;
+                  result.component = componentInfo$jscomp$0;
+                  isLastComponent = !1;
+                } else if (
+                  candidateInfo.awaited &&
+                  null != candidateInfo.awaited.env
+                ) {
+                  endTime > childrenEndTime && (childrenEndTime = endTime);
+                  var asyncInfo = candidateInfo,
+                    env$jscomp$1 = response$jscomp$0._rootEnvironmentName,
+                    promise = asyncInfo.awaited.value;
+                  if (promise) {
+                    var thenable = promise;
+                    switch (thenable.status) {
+                      case "fulfilled":
+                        logComponentAwait(
+                          asyncInfo,
+                          trackIdx$jscomp$6,
+                          time,
+                          endTime,
+                          env$jscomp$1,
+                          thenable.value
+                        );
+                        break;
+                      case "rejected":
+                        var asyncInfo$jscomp$0 = asyncInfo,
+                          trackIdx$jscomp$3 = trackIdx$jscomp$6,
+                          startTime$jscomp$4 = time,
+                          endTime$jscomp$0 = endTime,
+                          rootEnv = env$jscomp$1,
+                          error$jscomp$0 = thenable.reason;
+                        if (supportsUserTiming && 0 < endTime$jscomp$0) {
+                          var description = getIODescription(error$jscomp$0),
+                            entryName$jscomp$2 =
+                              "await " +
+                              getIOShortName(
+                                asyncInfo$jscomp$0.awaited,
+                                description,
+                                asyncInfo$jscomp$0.env,
+                                rootEnv
+                              ),
+                            debugTask$jscomp$1 =
+                              asyncInfo$jscomp$0.debugTask ||
+                              asyncInfo$jscomp$0.awaited.debugTask;
+                          if (debugTask$jscomp$1) {
+                            var properties$jscomp$1 = [
+                                [
+                                  "Rejected",
+                                  "object" === typeof error$jscomp$0 &&
+                                  null !== error$jscomp$0 &&
+                                  "string" === typeof error$jscomp$0.message
+                                    ? String(error$jscomp$0.message)
+                                    : String(error$jscomp$0)
+                                ]
+                              ],
+                              tooltipText =
+                                getIOLongName(
+                                  asyncInfo$jscomp$0.awaited,
+                                  description,
+                                  asyncInfo$jscomp$0.env,
+                                  rootEnv
+                                ) + " Rejected";
+                            debugTask$jscomp$1.run(
+                              performance.measure.bind(
+                                performance,
+                                entryName$jscomp$2,
+                                {
+                                  start:
+                                    0 > startTime$jscomp$4
+                                      ? 0
+                                      : startTime$jscomp$4,
+                                  end: endTime$jscomp$0,
+                                  detail: {
+                                    devtools: {
+                                      color: "error",
+                                      track: trackNames[trackIdx$jscomp$3],
+                                      trackGroup: "Server Components \u269b",
+                                      properties: properties$jscomp$1,
+                                      tooltipText: tooltipText
+                                    }
+                                  }
+                                }
+                              )
+                            );
+                          } else
+                            console.timeStamp(
+                              entryName$jscomp$2,
+                              0 > startTime$jscomp$4 ? 0 : startTime$jscomp$4,
+                              endTime$jscomp$0,
+                              trackNames[trackIdx$jscomp$3],
+                              "Server Components \u269b",
+                              "error"
+                            );
+                        }
+                        break;
+                      default:
+                        logComponentAwait(
+                          asyncInfo,
+                          trackIdx$jscomp$6,
+                          time,
+                          endTime,
+                          env$jscomp$1,
+                          void 0
+                        );
+                    }
+                  } else
+                    logComponentAwait(
+                      asyncInfo,
+                      trackIdx$jscomp$6,
+                      time,
+                      endTime,
+                      env$jscomp$1,
+                      void 0
+                    );
+                }
+              }
+            else {
+              endTime = time;
+              for (var _j = debugInfo.length - 1; _j > _i6; _j--) {
+                var _candidateInfo = debugInfo[_j];
+                if ("string" === typeof _candidateInfo.name) {
+                  componentEndTime > childrenEndTime &&
+                    (childrenEndTime = componentEndTime);
+                  var _componentInfo = _candidateInfo,
+                    _env = response$jscomp$0._rootEnvironmentName,
+                    componentInfo$jscomp$4 = _componentInfo,
+                    trackIdx$jscomp$4 = trackIdx$jscomp$6,
+                    startTime$jscomp$5 = time,
+                    childrenEndTime$jscomp$3 = childrenEndTime;
+                  if (supportsUserTiming) {
+                    var env$jscomp$2 = componentInfo$jscomp$4.env,
+                      name$jscomp$1 = componentInfo$jscomp$4.name,
+                      entryName$jscomp$3 =
+                        env$jscomp$2 === _env || void 0 === env$jscomp$2
+                          ? name$jscomp$1
+                          : name$jscomp$1 + " [" + env$jscomp$2 + "]",
+                      properties$jscomp$2 = [
+                        [
+                          "Aborted",
+                          "The stream was aborted before this Component finished rendering."
+                        ]
+                      ];
+                    null != componentInfo$jscomp$4.key &&
+                      addValueToProperties(
+                        "key",
+                        componentInfo$jscomp$4.key,
+                        properties$jscomp$2,
+                        0,
+                        ""
+                      );
+                    null != componentInfo$jscomp$4.props &&
+                      addObjectToProperties(
+                        componentInfo$jscomp$4.props,
+                        properties$jscomp$2,
+                        0,
+                        ""
+                      );
+                    performance.measure("\u200b" + entryName$jscomp$3, {
+                      start: 0 > startTime$jscomp$5 ? 0 : startTime$jscomp$5,
+                      end: childrenEndTime$jscomp$3,
+                      detail: {
+                        devtools: {
+                          color: "warning",
+                          track: trackNames[trackIdx$jscomp$4],
+                          trackGroup: "Server Components \u269b",
+                          tooltipText: entryName$jscomp$3 + " Aborted",
+                          properties: properties$jscomp$2
+                        }
+                      }
+                    });
+                  }
+                  componentEndTime = time;
+                  result.component = _componentInfo;
+                  isLastComponent = !1;
+                } else if (
+                  _candidateInfo.awaited &&
+                  null != _candidateInfo.awaited.env
+                ) {
+                  var _asyncInfo = _candidateInfo,
+                    _env2 = response$jscomp$0._rootEnvironmentName;
+                  _asyncInfo.awaited.end > endTime &&
+                    (endTime = _asyncInfo.awaited.end);
+                  endTime > childrenEndTime && (childrenEndTime = endTime);
+                  var asyncInfo$jscomp$1 = _asyncInfo,
+                    trackIdx$jscomp$5 = trackIdx$jscomp$6,
+                    startTime$jscomp$6 = time,
+                    endTime$jscomp$1 = endTime,
+                    rootEnv$jscomp$0 = _env2;
+                  if (supportsUserTiming && 0 < endTime$jscomp$1) {
+                    var entryName$jscomp$4 =
+                        "await " +
+                        getIOShortName(
+                          asyncInfo$jscomp$1.awaited,
+                          "",
+                          asyncInfo$jscomp$1.env,
+                          rootEnv$jscomp$0
+                        ),
+                      debugTask$jscomp$2 =
+                        asyncInfo$jscomp$1.debugTask ||
+                        asyncInfo$jscomp$1.awaited.debugTask;
+                    if (debugTask$jscomp$2) {
+                      var tooltipText$jscomp$0 =
+                        getIOLongName(
+                          asyncInfo$jscomp$1.awaited,
+                          "",
+                          asyncInfo$jscomp$1.env,
+                          rootEnv$jscomp$0
+                        ) + " Aborted";
+                      debugTask$jscomp$2.run(
+                        performance.measure.bind(
+                          performance,
+                          entryName$jscomp$4,
+                          {
+                            start:
+                              0 > startTime$jscomp$6 ? 0 : startTime$jscomp$6,
+                            end: endTime$jscomp$1,
+                            detail: {
+                              devtools: {
+                                color: "warning",
+                                track: trackNames[trackIdx$jscomp$5],
+                                trackGroup: "Server Components \u269b",
+                                properties: [
+                                  [
+                                    "Aborted",
+                                    "The stream was aborted before this Promise resolved."
+                                  ]
+                                ],
+                                tooltipText: tooltipText$jscomp$0
+                              }
+                            }
+                          }
+                        )
+                      );
+                    } else
+                      console.timeStamp(
+                        entryName$jscomp$4,
+                        0 > startTime$jscomp$6 ? 0 : startTime$jscomp$6,
+                        endTime$jscomp$1,
+                        trackNames[trackIdx$jscomp$5],
+                        "Server Components \u269b",
+                        "warning"
+                      );
+                  }
+                }
+              }
+            }
+            endTime = time;
+            endTimeIdx = _i6;
+          }
+        }
+      result.endTime = childrenEndTime;
+      return result;
+    }
+    function flushInitialRenderPerformance(response) {
+      if (response._replayConsole) {
+        var rootChunk = getChunk(response, 0);
+        isArrayImpl(rootChunk._children) &&
+          (markAllTracksInOrder(),
+          flushComponentPerformance(
+            response,
+            rootChunk,
+            0,
+            -Infinity,
+            -Infinity
+          ));
+      }
     }
-    function processFullBinaryRow(response, id, tag, buffer, chunk) {
+    function processFullBinaryRow(
+      response,
+      streamState,
+      id,
+      tag,
+      buffer,
+      chunk
+    ) {
       switch (tag) {
         case 65:
-          resolveBuffer(response, id, mergeBuffer(buffer, chunk).buffer);
+          resolveBuffer(
+            response,
+            id,
+            mergeBuffer(buffer, chunk).buffer,
+            streamState
+          );
           return;
         case 79:
-          resolveTypedArray(response, id, buffer, chunk, Int8Array, 1);
+          resolveTypedArray(
+            response,
+            id,
+            buffer,
+            chunk,
+            Int8Array,
+            1,
+            streamState
+          );
           return;
         case 111:
           resolveBuffer(
             response,
             id,
-            0 === buffer.length ? chunk : mergeBuffer(buffer, chunk)
+            0 === buffer.length ? chunk : mergeBuffer(buffer, chunk),
+            streamState
           );
           return;
         case 85:
-          resolveTypedArray(response, id, buffer, chunk, Uint8ClampedArray, 1);
+          resolveTypedArray(
+            response,
+            id,
+            buffer,
+            chunk,
+            Uint8ClampedArray,
+            1,
+            streamState
+          );
           return;
         case 83:
-          resolveTypedArray(response, id, buffer, chunk, Int16Array, 2);
+          resolveTypedArray(
+            response,
+            id,
+            buffer,
+            chunk,
+            Int16Array,
+            2,
+            streamState
+          );
           return;
         case 115:
-          resolveTypedArray(response, id, buffer, chunk, Uint16Array, 2);
+          resolveTypedArray(
+            response,
+            id,
+            buffer,
+            chunk,
+            Uint16Array,
+            2,
+            streamState
+          );
           return;
         case 76:
-          resolveTypedArray(response, id, buffer, chunk, Int32Array, 4);
+          resolveTypedArray(
+            response,
+            id,
+            buffer,
+            chunk,
+            Int32Array,
+            4,
+            streamState
+          );
           return;
         case 108:
-          resolveTypedArray(response, id, buffer, chunk, Uint32Array, 4);
+          resolveTypedArray(
+            response,
+            id,
+            buffer,
+            chunk,
+            Uint32Array,
+            4,
+            streamState
+          );
           return;
         case 71:
-          resolveTypedArray(response, id, buffer, chunk, Float32Array, 4);
+          resolveTypedArray(
+            response,
+            id,
+            buffer,
+            chunk,
+            Float32Array,
+            4,
+            streamState
+          );
           return;
         case 103:
-          resolveTypedArray(response, id, buffer, chunk, Float64Array, 8);
+          resolveTypedArray(
+            response,
+            id,
+            buffer,
+            chunk,
+            Float64Array,
+            8,
+            streamState
+          );
           return;
         case 77:
-          resolveTypedArray(response, id, buffer, chunk, BigInt64Array, 8);
+          resolveTypedArray(
+            response,
+            id,
+            buffer,
+            chunk,
+            BigInt64Array,
+            8,
+            streamState
+          );
           return;
         case 109:
-          resolveTypedArray(response, id, buffer, chunk, BigUint64Array, 8);
+          resolveTypedArray(
+            response,
+            id,
+            buffer,
+            chunk,
+            BigUint64Array,
+            8,
+            streamState
+          );
           return;
         case 86:
-          resolveTypedArray(response, id, buffer, chunk, DataView, 1);
+          resolveTypedArray(
+            response,
+            id,
+            buffer,
+            chunk,
+            DataView,
+            1,
+            streamState
+          );
           return;
       }
       for (
@@ -2230,62 +4131,242 @@
       )
         row += stringDecoder.decode(buffer[i], decoderOptions);
       row += stringDecoder.decode(chunk);
-      processFullStringRow(response, id, tag, row);
+      processFullStringRow(response, streamState, id, tag, row);
     }
-    function processFullStringRow(response, id, tag, row) {
+    function processFullStringRow(response, streamState, id, tag, row) {
       switch (tag) {
         case 73:
-          resolveModule(response, id, row);
+          resolveModule(response, id, row, streamState);
           break;
         case 72:
-          resolveHint(response, row[0], row.slice(1));
+          id = row[0];
+          streamState = row.slice(1);
+          response = JSON.parse(streamState, response._fromJSON);
+          streamState = ReactDOMSharedInternals.d;
+          switch (id) {
+            case "D":
+              streamState.D(response);
+              break;
+            case "C":
+              "string" === typeof response
+                ? streamState.C(response)
+                : streamState.C(response[0], response[1]);
+              break;
+            case "L":
+              id = response[0];
+              row = response[1];
+              3 === response.length
+                ? streamState.L(id, row, response[2])
+                : streamState.L(id, row);
+              break;
+            case "m":
+              "string" === typeof response
+                ? streamState.m(response)
+                : streamState.m(response[0], response[1]);
+              break;
+            case "X":
+              "string" === typeof response
+                ? streamState.X(response)
+                : streamState.X(response[0], response[1]);
+              break;
+            case "S":
+              "string" === typeof response
+                ? streamState.S(response)
+                : streamState.S(
+                    response[0],
+                    0 === response[1] ? void 0 : response[1],
+                    3 === response.length ? response[2] : void 0
+                  );
+              break;
+            case "M":
+              "string" === typeof response
+                ? streamState.M(response)
+                : streamState.M(response[0], response[1]);
+          }
           break;
         case 69:
+          tag = response._chunks;
+          var chunk = tag.get(id);
           row = JSON.parse(row);
-          tag = resolveErrorDev(response, row);
-          tag.digest = row.digest;
-          row = response._chunks;
-          var chunk = row.get(id);
+          var error = resolveErrorDev(response, row);
+          error.digest = row.digest;
           chunk
-            ? triggerErrorOnChunk(chunk, tag)
-            : row.set(id, new ReactPromise("rejected", null, tag, response));
+            ? (resolveChunkDebugInfo(streamState, chunk),
+              triggerErrorOnChunk(response, chunk, error))
+            : ((response = new ReactPromise("rejected", null, error)),
+              resolveChunkDebugInfo(streamState, response),
+              tag.set(id, response));
           break;
         case 84:
-          resolveText(response, id, row);
+          tag = response._chunks;
+          (chunk = tag.get(id)) && "pending" !== chunk.status
+            ? chunk.reason.enqueueValue(row)
+            : (chunk && releasePendingChunk(response, chunk),
+              (response = new ReactPromise("fulfilled", row, null)),
+              resolveChunkDebugInfo(streamState, response),
+              tag.set(id, response));
           break;
         case 78:
+          response._timeOrigin = +row - performance.timeOrigin;
+          break;
         case 68:
-          tag = new ReactPromise("resolved_model", row, null, response);
-          initializeModelChunk(tag);
-          "fulfilled" === tag.status
-            ? resolveDebugInfo(response, id, tag.value)
-            : tag.then(
-                function (v) {
-                  return resolveDebugInfo(response, id, v);
-                },
-                function () {}
-              );
+          id = getChunk(response, id);
+          "fulfilled" !== id.status &&
+            "rejected" !== id.status &&
+            "halted" !== id.status &&
+            "blocked" !== id.status &&
+            "resolved_module" !== id.status &&
+            ((streamState = id._debugChunk),
+            (tag = createResolvedModelChunk(response, row)),
+            (tag._debugChunk = streamState),
+            (id._debugChunk = tag),
+            initializeDebugChunk(response, id),
+            "blocked" !== tag.status ||
+              (void 0 !== response._debugChannel &&
+                response._debugChannel.hasReadable) ||
+              '"' !== row[0] ||
+              "$" !== row[1] ||
+              ((streamState = row.slice(2, row.length - 1).split(":")),
+              (streamState = parseInt(streamState[0], 16)),
+              "pending" === getChunk(response, streamState).status &&
+                (id._debugChunk = null)));
+          break;
+        case 74:
+          resolveIOInfo(response, id, row);
           break;
         case 87:
           resolveConsoleEntry(response, row);
           break;
         case 82:
-          startReadableStream(response, id, void 0);
+          startReadableStream(response, id, void 0, streamState);
           break;
         case 114:
-          startReadableStream(response, id, "bytes");
+          startReadableStream(response, id, "bytes", streamState);
           break;
         case 88:
-          startAsyncIterable(response, id, !1);
+          startAsyncIterable(response, id, !1, streamState);
           break;
         case 120:
-          startAsyncIterable(response, id, !0);
+          startAsyncIterable(response, id, !0, streamState);
           break;
         case 67:
-          stopStream(response, id, row);
+          (response = response._chunks.get(id)) &&
+            "fulfilled" === response.status &&
+            response.reason.close("" === row ? '"$undefined"' : row);
           break;
         default:
-          resolveModel(response, id, row);
+          if ("" === row) {
+            if (
+              ((streamState = response._chunks),
+              (row = streamState.get(id)) ||
+                streamState.set(id, (row = createPendingChunk(response))),
+              "pending" === row.status || "blocked" === row.status)
+            )
+              releasePendingChunk(response, row),
+                (response = row),
+                (response.status = "halted"),
+                (response.value = null),
+                (response.reason = null);
+          } else
+            (tag = response._chunks),
+              (chunk = tag.get(id))
+                ? (resolveChunkDebugInfo(streamState, chunk),
+                  resolveModelChunk(response, chunk, row))
+                : ((response = createResolvedModelChunk(response, row)),
+                  resolveChunkDebugInfo(streamState, response),
+                  tag.set(id, response));
+      }
+    }
+    function processBinaryChunk(weakResponse, streamState, chunk) {
+      if (void 0 !== weakResponse.weak.deref()) {
+        var response = unwrapWeakResponse(weakResponse),
+          i = 0,
+          rowState = streamState._rowState;
+        weakResponse = streamState._rowID;
+        var rowTag = streamState._rowTag,
+          rowLength = streamState._rowLength,
+          buffer = streamState._buffer,
+          chunkLength = chunk.length;
+        for (
+          incrementChunkDebugInfo(streamState, chunkLength);
+          i < chunkLength;
+
+        ) {
+          var lastIdx = -1;
+          switch (rowState) {
+            case 0:
+              lastIdx = chunk[i++];
+              58 === lastIdx
+                ? (rowState = 1)
+                : (weakResponse =
+                    (weakResponse << 4) |
+                    (96 < lastIdx ? lastIdx - 87 : lastIdx - 48));
+              continue;
+            case 1:
+              rowState = chunk[i];
+              84 === rowState ||
+              65 === rowState ||
+              79 === rowState ||
+              111 === rowState ||
+              85 === rowState ||
+              83 === rowState ||
+              115 === rowState ||
+              76 === rowState ||
+              108 === rowState ||
+              71 === rowState ||
+              103 === rowState ||
+              77 === rowState ||
+              109 === rowState ||
+              86 === rowState
+                ? ((rowTag = rowState), (rowState = 2), i++)
+                : (64 < rowState && 91 > rowState) ||
+                    35 === rowState ||
+                    114 === rowState ||
+                    120 === rowState
+                  ? ((rowTag = rowState), (rowState = 3), i++)
+                  : ((rowTag = 0), (rowState = 3));
+              continue;
+            case 2:
+              lastIdx = chunk[i++];
+              44 === lastIdx
+                ? (rowState = 4)
+                : (rowLength =
+                    (rowLength << 4) |
+                    (96 < lastIdx ? lastIdx - 87 : lastIdx - 48));
+              continue;
+            case 3:
+              lastIdx = chunk.indexOf(10, i);
+              break;
+            case 4:
+              (lastIdx = i + rowLength),
+                lastIdx > chunk.length && (lastIdx = -1);
+          }
+          var offset = chunk.byteOffset + i;
+          if (-1 < lastIdx)
+            (rowLength = new Uint8Array(chunk.buffer, offset, lastIdx - i)),
+              processFullBinaryRow(
+                response,
+                streamState,
+                weakResponse,
+                rowTag,
+                buffer,
+                rowLength
+              ),
+              (i = lastIdx),
+              3 === rowState && i++,
+              (rowLength = weakResponse = rowTag = rowState = 0),
+              (buffer.length = 0);
+          else {
+            chunk = new Uint8Array(chunk.buffer, offset, chunk.byteLength - i);
+            buffer.push(chunk);
+            rowLength -= chunk.byteLength;
+            break;
+          }
+        }
+        streamState._rowState = rowState;
+        streamState._rowID = weakResponse;
+        streamState._rowTag = rowTag;
+        streamState._rowLength = rowLength;
       }
     }
     function createFromJSONCallback(response) {
@@ -2293,106 +4374,109 @@
         if ("string" === typeof value)
           return parseModelString(response, this, key, value);
         if ("object" === typeof value && null !== value) {
-          if (value[0] === REACT_ELEMENT_TYPE) {
-            var type = value[1];
-            key = value[4];
-            var stack = value[5],
-              validated = value[6];
-            value = {
-              $$typeof: REACT_ELEMENT_TYPE,
-              type: type,
-              key: value[2],
-              props: value[3],
-              _owner: null === key ? response._debugRootOwner : key
-            };
-            Object.defineProperty(value, "ref", {
-              enumerable: !1,
-              get: nullRefGetter
-            });
-            value._store = {};
-            Object.defineProperty(value._store, "validated", {
-              configurable: !1,
-              enumerable: !1,
-              writable: !0,
-              value: validated
-            });
-            Object.defineProperty(value, "_debugInfo", {
-              configurable: !1,
-              enumerable: !1,
-              writable: !0,
-              value: null
-            });
-            validated = response._rootEnvironmentName;
-            null !== key && null != key.env && (validated = key.env);
-            var normalizedStackTrace = null;
-            null === key && null != response._debugRootStack
-              ? (normalizedStackTrace = response._debugRootStack)
-              : null !== stack &&
-                (normalizedStackTrace = createFakeJSXCallStackInDEV(
-                  response,
-                  stack,
-                  validated
-                ));
-            Object.defineProperty(value, "_debugStack", {
-              configurable: !1,
-              enumerable: !1,
-              writable: !0,
-              value: normalizedStackTrace
-            });
-            normalizedStackTrace = null;
-            supportsCreateTask &&
-              null !== stack &&
-              ((type = console.createTask.bind(console, getTaskName(type))),
-              (stack = buildFakeCallStack(response, stack, validated, type)),
-              (type =
-                null === key
-                  ? null
-                  : initializeFakeTask(response, key, validated)),
-              null === type
-                ? ((type = response._debugRootTask),
-                  (normalizedStackTrace =
-                    null != type ? type.run(stack) : stack()))
-                : (normalizedStackTrace = type.run(stack)));
-            Object.defineProperty(value, "_debugTask", {
-              configurable: !1,
-              enumerable: !1,
-              writable: !0,
-              value: normalizedStackTrace
-            });
-            null !== key && initializeFakeStack(response, key);
-            null !== initializingHandler
-              ? ((stack = initializingHandler),
-                (initializingHandler = stack.parent),
-                stack.errored
-                  ? ((key = new ReactPromise(
-                      "rejected",
-                      null,
-                      stack.value,
-                      response
-                    )),
-                    (stack = {
-                      name: getComponentNameFromType(value.type) || "",
-                      owner: value._owner
-                    }),
-                    (stack.debugStack = value._debugStack),
-                    supportsCreateTask && (stack.debugTask = value._debugTask),
-                    (key._debugInfo = [stack]),
-                    (value = createLazyChunkWrapper(key)))
-                  : 0 < stack.deps &&
-                    ((key = new ReactPromise("blocked", null, null, response)),
-                    (stack.value = value),
-                    (stack.chunk = key),
-                    (value = Object.freeze.bind(Object, value.props)),
-                    key.then(value, value),
-                    (value = createLazyChunkWrapper(key))))
-              : Object.freeze(value.props);
-          }
-          return value;
+          if (value[0] === REACT_ELEMENT_TYPE)
+            b: {
+              var owner = value[4],
+                stack = value[5];
+              key = value[6];
+              value = {
+                $$typeof: REACT_ELEMENT_TYPE,
+                type: value[1],
+                key: value[2],
+                props: value[3],
+                _owner: void 0 === owner ? null : owner
+              };
+              Object.defineProperty(value, "ref", {
+                enumerable: !1,
+                get: nullRefGetter
+              });
+              value._store = {};
+              Object.defineProperty(value._store, "validated", {
+                configurable: !1,
+                enumerable: !1,
+                writable: !0,
+                value: key
+              });
+              Object.defineProperty(value, "_debugInfo", {
+                configurable: !1,
+                enumerable: !1,
+                writable: !0,
+                value: null
+              });
+              Object.defineProperty(value, "_debugStack", {
+                configurable: !1,
+                enumerable: !1,
+                writable: !0,
+                value: void 0 === stack ? null : stack
+              });
+              Object.defineProperty(value, "_debugTask", {
+                configurable: !1,
+                enumerable: !1,
+                writable: !0,
+                value: null
+              });
+              if (null !== initializingHandler) {
+                owner = initializingHandler;
+                initializingHandler = owner.parent;
+                if (owner.errored) {
+                  stack = new ReactPromise("rejected", null, owner.reason);
+                  initializeElement(response, value, null);
+                  owner = {
+                    name: getComponentNameFromType(value.type) || "",
+                    owner: value._owner
+                  };
+                  owner.debugStack = value._debugStack;
+                  supportsCreateTask && (owner.debugTask = value._debugTask);
+                  stack._debugInfo = [owner];
+                  key = createLazyChunkWrapper(stack, key);
+                  break b;
+                }
+                if (0 < owner.deps) {
+                  stack = new ReactPromise("blocked", null, null);
+                  owner.value = value;
+                  owner.chunk = stack;
+                  key = createLazyChunkWrapper(stack, key);
+                  value = initializeElement.bind(null, response, value, key);
+                  stack.then(value, value);
+                  break b;
+                }
+              }
+              initializeElement(response, value, null);
+              key = value;
+            }
+          else key = value;
+          return key;
         }
         return value;
       };
     }
+    function close(weakResponse) {
+      reportGlobalError(weakResponse, Error("Connection closed."));
+    }
+    function createDebugCallbackFromWritableStream(debugWritable) {
+      var textEncoder = new TextEncoder(),
+        writer = debugWritable.getWriter();
+      return function (message) {
+        "" === message
+          ? writer.close()
+          : writer
+              .write(textEncoder.encode(message + "\n"))
+              .catch(console.error);
+      };
+    }
     function createResponseFromOptions(options) {
+      var debugChannel =
+        options && void 0 !== options.debugChannel
+          ? {
+              hasReadable: void 0 !== options.debugChannel.readable,
+              callback:
+                void 0 !== options.debugChannel.writable
+                  ? createDebugCallbackFromWritableStream(
+                      options.debugChannel.writable
+                    )
+                  : null
+            }
+          : void 0;
       return new ResponseInstance(
         null,
         null,
@@ -2405,104 +4489,139 @@
           : void 0,
         options && options.findSourceMapURL ? options.findSourceMapURL : void 0,
         options ? !1 !== options.replayConsoleLogs : !0,
-        options && options.environmentName ? options.environmentName : void 0
-      );
+        options && options.environmentName ? options.environmentName : void 0,
+        debugChannel
+      )._weakResponse;
     }
-    function startReadingFromStream(response, stream) {
+    function startReadingFromUniversalStream(
+      response$jscomp$0,
+      stream,
+      onDone
+    ) {
       function progress(_ref) {
         var value = _ref.value;
-        if (_ref.done) reportGlobalError(response, Error("Connection closed."));
-        else {
-          var i = 0,
-            rowState = response._rowState;
-          _ref = response._rowID;
-          for (
-            var rowTag = response._rowTag,
-              rowLength = response._rowLength,
-              buffer = response._buffer,
+        if (_ref.done) return onDone();
+        if (value instanceof ArrayBuffer)
+          processBinaryChunk(
+            response$jscomp$0,
+            streamState,
+            new Uint8Array(value)
+          );
+        else if ("string" === typeof value) {
+          if (
+            ((_ref = streamState), void 0 !== response$jscomp$0.weak.deref())
+          ) {
+            var response = unwrapWeakResponse(response$jscomp$0),
+              i = 0,
+              rowState = _ref._rowState,
+              rowID = _ref._rowID,
+              rowTag = _ref._rowTag,
+              rowLength = _ref._rowLength,
+              buffer = _ref._buffer,
               chunkLength = value.length;
-            i < chunkLength;
+            for (
+              incrementChunkDebugInfo(_ref, chunkLength);
+              i < chunkLength;
 
-          ) {
-            var lastIdx = -1;
-            switch (rowState) {
-              case 0:
-                lastIdx = value[i++];
-                58 === lastIdx
-                  ? (rowState = 1)
-                  : (_ref =
-                      (_ref << 4) |
-                      (96 < lastIdx ? lastIdx - 87 : lastIdx - 48));
-                continue;
-              case 1:
-                rowState = value[i];
-                84 === rowState ||
-                65 === rowState ||
-                79 === rowState ||
-                111 === rowState ||
-                85 === rowState ||
-                83 === rowState ||
-                115 === rowState ||
-                76 === rowState ||
-                108 === rowState ||
-                71 === rowState ||
-                103 === rowState ||
-                77 === rowState ||
-                109 === rowState ||
-                86 === rowState
-                  ? ((rowTag = rowState), (rowState = 2), i++)
-                  : (64 < rowState && 91 > rowState) ||
-                      35 === rowState ||
-                      114 === rowState ||
-                      120 === rowState
-                    ? ((rowTag = rowState), (rowState = 3), i++)
-                    : ((rowTag = 0), (rowState = 3));
-                continue;
-              case 2:
-                lastIdx = value[i++];
-                44 === lastIdx
-                  ? (rowState = 4)
-                  : (rowLength =
-                      (rowLength << 4) |
-                      (96 < lastIdx ? lastIdx - 87 : lastIdx - 48));
-                continue;
-              case 3:
-                lastIdx = value.indexOf(10, i);
-                break;
-              case 4:
-                (lastIdx = i + rowLength),
-                  lastIdx > value.length && (lastIdx = -1);
-            }
-            var offset = value.byteOffset + i;
-            if (-1 < lastIdx)
-              (rowLength = new Uint8Array(value.buffer, offset, lastIdx - i)),
-                processFullBinaryRow(response, _ref, rowTag, buffer, rowLength),
-                (i = lastIdx),
-                3 === rowState && i++,
-                (rowLength = _ref = rowTag = rowState = 0),
-                (buffer.length = 0);
-            else {
-              value = new Uint8Array(
-                value.buffer,
-                offset,
-                value.byteLength - i
-              );
-              buffer.push(value);
-              rowLength -= value.byteLength;
-              break;
+            ) {
+              var lastIdx = -1;
+              switch (rowState) {
+                case 0:
+                  lastIdx = value.charCodeAt(i++);
+                  58 === lastIdx
+                    ? (rowState = 1)
+                    : (rowID =
+                        (rowID << 4) |
+                        (96 < lastIdx ? lastIdx - 87 : lastIdx - 48));
+                  continue;
+                case 1:
+                  rowState = value.charCodeAt(i);
+                  84 === rowState ||
+                  65 === rowState ||
+                  79 === rowState ||
+                  111 === rowState ||
+                  85 === rowState ||
+                  83 === rowState ||
+                  115 === rowState ||
+                  76 === rowState ||
+                  108 === rowState ||
+                  71 === rowState ||
+                  103 === rowState ||
+                  77 === rowState ||
+                  109 === rowState ||
+                  86 === rowState
+                    ? ((rowTag = rowState), (rowState = 2), i++)
+                    : (64 < rowState && 91 > rowState) ||
+                        114 === rowState ||
+                        120 === rowState
+                      ? ((rowTag = rowState), (rowState = 3), i++)
+                      : ((rowTag = 0), (rowState = 3));
+                  continue;
+                case 2:
+                  lastIdx = value.charCodeAt(i++);
+                  44 === lastIdx
+                    ? (rowState = 4)
+                    : (rowLength =
+                        (rowLength << 4) |
+                        (96 < lastIdx ? lastIdx - 87 : lastIdx - 48));
+                  continue;
+                case 3:
+                  lastIdx = value.indexOf("\n", i);
+                  break;
+                case 4:
+                  if (84 !== rowTag)
+                    throw Error(
+                      "Binary RSC chunks cannot be encoded as strings. This is a bug in the wiring of the React streams."
+                    );
+                  if (rowLength < value.length || value.length > 3 * rowLength)
+                    throw Error(
+                      "String chunks need to be passed in their original shape. Not split into smaller string chunks. This is a bug in the wiring of the React streams."
+                    );
+                  lastIdx = value.length;
+              }
+              if (-1 < lastIdx) {
+                if (0 < buffer.length)
+                  throw Error(
+                    "String chunks need to be passed in their original shape. Not split into smaller string chunks. This is a bug in the wiring of the React streams."
+                  );
+                i = value.slice(i, lastIdx);
+                processFullStringRow(response, _ref, rowID, rowTag, i);
+                i = lastIdx;
+                3 === rowState && i++;
+                rowLength = rowID = rowTag = rowState = 0;
+                buffer.length = 0;
+              } else if (value.length !== i)
+                throw Error(
+                  "String chunks need to be passed in their original shape. Not split into smaller string chunks. This is a bug in the wiring of the React streams."
+                );
             }
+            _ref._rowState = rowState;
+            _ref._rowID = rowID;
+            _ref._rowTag = rowTag;
+            _ref._rowLength = rowLength;
           }
-          response._rowState = rowState;
-          response._rowID = _ref;
-          response._rowTag = rowTag;
-          response._rowLength = rowLength;
-          return reader.read().then(progress).catch(error);
-        }
+        } else processBinaryChunk(response$jscomp$0, streamState, value);
+        return reader.read().then(progress).catch(error);
+      }
+      function error(e) {
+        reportGlobalError(response$jscomp$0, e);
+      }
+      var streamState = createStreamState(response$jscomp$0, stream),
+        reader = stream.getReader();
+      reader.read().then(progress).catch(error);
+    }
+    function startReadingFromStream(response, stream, onDone, debugValue) {
+      function progress(_ref2) {
+        var value = _ref2.value;
+        if (_ref2.done) return onDone();
+        processBinaryChunk(response, streamState, value);
+        return reader.read().then(progress).catch(error);
       }
       function error(e) {
         reportGlobalError(response, e);
       }
-      var reader = stream.getReader();
+      var streamState = createStreamState(response, debugValue),
+        reader = stream.getReader();
       reader.read().then(progress).catch(error);
     }
     var React = require("react"),
@@ -2518,15 +4637,15 @@
         ? flightChunk
         : webpackGetChunkFilename(chunkId);
     };
-    var ReactDOMSharedInternals =
+    var chunkIOInfoCache = new Map(),
+      ReactDOMSharedInternals =
         ReactDOM.__DOM_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE,
       REACT_ELEMENT_TYPE = Symbol.for("react.transitional.element"),
       REACT_PORTAL_TYPE = Symbol.for("react.portal"),
       REACT_FRAGMENT_TYPE = Symbol.for("react.fragment"),
       REACT_STRICT_MODE_TYPE = Symbol.for("react.strict_mode"),
-      REACT_PROFILER_TYPE = Symbol.for("react.profiler");
-    Symbol.for("react.provider");
-    var REACT_CONSUMER_TYPE = Symbol.for("react.consumer"),
+      REACT_PROFILER_TYPE = Symbol.for("react.profiler"),
+      REACT_CONSUMER_TYPE = Symbol.for("react.consumer"),
       REACT_CONTEXT_TYPE = Symbol.for("react.context"),
       REACT_FORWARD_REF_TYPE = Symbol.for("react.forward_ref"),
       REACT_SUSPENSE_TYPE = Symbol.for("react.suspense"),
@@ -2547,7 +4666,17 @@
       v8FrameRegExp =
         /^ {3} at (?:(.+) \((.+):(\d+):(\d+)\)|(?:async )?(.+):(\d+):(\d+))$/,
       jscSpiderMonkeyFrameRegExp = /(?:(.*)@)?(.*):(\d+):(\d+)/,
+      hasOwnProperty = Object.prototype.hasOwnProperty,
       REACT_CLIENT_REFERENCE = Symbol.for("react.client.reference"),
+      supportsUserTiming =
+        "undefined" !== typeof console &&
+        "function" === typeof console.timeStamp &&
+        "undefined" !== typeof performance &&
+        "function" === typeof performance.measure,
+      trackNames =
+        "Primary Parallel Parallel\u200b Parallel\u200b\u200b Parallel\u200b\u200b\u200b Parallel\u200b\u200b\u200b\u200b Parallel\u200b\u200b\u200b\u200b\u200b Parallel\u200b\u200b\u200b\u200b\u200b\u200b Parallel\u200b\u200b\u200b\u200b\u200b\u200b\u200b Parallel\u200b\u200b\u200b\u200b\u200b\u200b\u200b\u200b".split(
+          " "
+        ),
       prefix,
       suffix;
     new ("function" === typeof WeakMap ? WeakMap : Map)();
@@ -2558,6 +4687,7 @@
         ReactSharedInteralsServer;
     ReactPromise.prototype = Object.create(Promise.prototype);
     ReactPromise.prototype.then = function (resolve, reject) {
+      var _this = this;
       switch (this.status) {
         case "resolved_model":
           initializeModelChunk(this);
@@ -2565,24 +4695,46 @@
         case "resolved_module":
           initializeModuleChunk(this);
       }
+      var resolveCallback = resolve,
+        rejectCallback = reject,
+        wrapperPromise = new Promise(function (res, rej) {
+          resolve = function (value) {
+            wrapperPromise._debugInfo = _this._debugInfo;
+            res(value);
+          };
+          reject = function (reason) {
+            wrapperPromise._debugInfo = _this._debugInfo;
+            rej(reason);
+          };
+        });
+      wrapperPromise.then(resolveCallback, rejectCallback);
       switch (this.status) {
         case "fulfilled":
-          resolve(this.value);
+          "function" === typeof resolve && resolve(this.value);
           break;
         case "pending":
         case "blocked":
-          resolve &&
+          "function" === typeof resolve &&
             (null === this.value && (this.value = []),
             this.value.push(resolve));
-          reject &&
+          "function" === typeof reject &&
             (null === this.reason && (this.reason = []),
             this.reason.push(reject));
           break;
+        case "halted":
+          break;
         default:
-          reject && reject(this.reason);
+          "function" === typeof reject && reject(this.reason);
       }
     };
-    var initializingHandler = null,
+    var debugChannelRegistry =
+        "function" === typeof FinalizationRegistry
+          ? new FinalizationRegistry(closeDebugChannel)
+          : null,
+      initializingHandler = null,
+      initializingChunk = null,
+      mightHaveStaticConstructor = /\bclass\b.*\bstatic\b/,
+      MIN_CHUNK_SIZE = 65536,
       supportsCreateTask = !!console.createTask,
       fakeFunctionCache = new Map(),
       fakeFunctionIdx = 0,
@@ -2592,6 +4744,7 @@
             response,
             stack,
             environmentName,
+            !1,
             fakeJSXCallSite
           )();
         }
@@ -2602,14 +4755,12 @@
         ),
       currentOwnerInDEV = null,
       replayConsoleWithCallStack = {
-        react_stack_bottom_frame: function (
-          response,
-          methodName,
-          stackTrace,
-          owner,
-          env,
-          args
-        ) {
+        react_stack_bottom_frame: function (response, payload) {
+          var methodName = payload[0],
+            stackTrace = payload[1],
+            owner = payload[2],
+            env = payload[3];
+          payload = payload.slice(4);
           var prevStack = ReactSharedInternals.getCurrentStack;
           ReactSharedInternals.getCurrentStack = getCurrentStackInDEV;
           currentOwnerInDEV = null === owner ? response._debugRootOwner : owner;
@@ -2623,13 +4774,13 @@
                 case "table":
                   var JSCompiler_inline_result = bind.apply(
                     console[methodName],
-                    [console].concat(args)
+                    [console].concat(payload)
                   );
                   break a;
                 case "assert":
                   offset = 1;
               }
-              var newArgs = args.slice(0);
+              var newArgs = payload.slice(0);
               "string" === typeof newArgs[offset]
                 ? newArgs.splice(
                     offset,
@@ -2642,7 +4793,7 @@
                 : newArgs.splice(
                     offset,
                     0,
-                    "%c%s%c ",
+                    "%c%s%c",
                     "background: #e6e6e6;background: light-dark(rgba(0,0,0,0.1), rgba(255,255,255,0.25));color: #000000;color: light-dark(#000000, #ffffff);border-radius: 2px",
                     " " + env + " ",
                     ""
@@ -2657,10 +4808,11 @@
               response,
               stackTrace,
               env,
+              !1,
               JSCompiler_inline_result
             );
             if (null != owner) {
-              var task = initializeFakeTask(response, owner, env);
+              var task = initializeFakeTask(response, owner);
               initializeFakeStack(response, owner);
               if (null !== task) {
                 task.run(callStack);
@@ -2686,15 +4838,15 @@
       try {
         hook.inject(internals);
       } catch (err) {
-        console.error("React instrumentation encountered an error: %s.", err);
+        console.error("React instrumentation encountered an error: %o.", err);
       }
       return hook.checkDCE ? !0 : !1;
     })({
       bundleType: 1,
-      version: "19.1.1",
+      version: "19.2.0",
       rendererPackageName: "react-server-dom-webpack",
       currentDispatcherRef: ReactSharedInternals,
-      reconcilerVersion: "19.1.1",
+      reconcilerVersion: "19.2.0",
       getCurrentComponentInfo: function () {
         return currentOwnerInDEV;
       }
@@ -2703,18 +4855,56 @@
       var response = createResponseFromOptions(options);
       promiseForResponse.then(
         function (r) {
-          startReadingFromStream(response, r.body);
+          if (
+            options &&
+            options.debugChannel &&
+            options.debugChannel.readable
+          ) {
+            var streamDoneCount = 0,
+              handleDone = function () {
+                2 === ++streamDoneCount && close(response);
+              };
+            startReadingFromUniversalStream(
+              response,
+              options.debugChannel.readable,
+              handleDone
+            );
+            startReadingFromStream(response, r.body, handleDone, r);
+          } else
+            startReadingFromStream(
+              response,
+              r.body,
+              close.bind(null, response),
+              r
+            );
         },
         function (e) {
           reportGlobalError(response, e);
         }
       );
-      return getChunk(response, 0);
+      return getRoot(response);
     };
     exports.createFromReadableStream = function (stream, options) {
-      options = createResponseFromOptions(options);
-      startReadingFromStream(options, stream);
-      return getChunk(options, 0);
+      var response = createResponseFromOptions(options);
+      if (options && options.debugChannel && options.debugChannel.readable) {
+        var streamDoneCount = 0,
+          handleDone = function () {
+            2 === ++streamDoneCount && close(response);
+          };
+        startReadingFromUniversalStream(
+          response,
+          options.debugChannel.readable,
+          handleDone
+        );
+        startReadingFromStream(response, stream, handleDone, stream);
+      } else
+        startReadingFromStream(
+          response,
+          stream,
+          close.bind(null, response),
+          stream
+        );
+      return getRoot(response);
     };
     exports.createServerReference = function (
       id,