react-server-dom-webpack 19.0.0-rc.0 → 19.0.0

package/cjs/react-server-dom-webpack-client.node.unbundled.production.js

@@ -14,15 +14,15 @@ var util = require("util"),
   decoderOptions = { stream: !0 };
 function resolveClientReference(bundlerConfig, metadata) {
   var moduleExports = bundlerConfig[metadata[0]];
-  if ((bundlerConfig = moduleExports[metadata[2]]))
+  if ((bundlerConfig = moduleExports && moduleExports[metadata[2]]))
     moduleExports = bundlerConfig.name;
   else {
-    bundlerConfig = moduleExports["*"];
+    bundlerConfig = moduleExports && moduleExports["*"];
     if (!bundlerConfig)
       throw Error(
         'Could not find the module "' +
           metadata[0] +
-          '" in the React SSR Manifest. This is probably a bug in the React Server Components bundler.'
+          '" in the React Server Consumer Manifest. This is probably a bug in the React Server Components bundler.'
       );
     moduleExports = metadata[2];
   }
@@ -32,6 +32,12 @@ function resolveClientReference(bundlerConfig, metadata) {
     async: 4 === metadata.length
   };
 }
+function resolveServerReference(bundlerConfig, id) {
+  var idx = id.lastIndexOf("#");
+  bundlerConfig = id.slice(0, idx);
+  id = id.slice(idx + 1);
+  return { specifier: bundlerConfig, name: id };
+}
 var asyncModuleCache = new Map();
 function preloadModule(metadata) {
   var existingPromise = asyncModuleCache.get(metadata.specifier);
@@ -57,6 +63,16 @@ function preloadModule(metadata) {
   asyncModuleCache.set(metadata.specifier, modulePromise);
   return modulePromise;
 }
+function requireModule(metadata) {
+  var moduleExports = asyncModuleCache.get(metadata.specifier);
+  if ("fulfilled" === moduleExports.status) moduleExports = moduleExports.value;
+  else throw moduleExports.reason;
+  return "*" === metadata.name
+    ? moduleExports
+    : "" === metadata.name
+      ? moduleExports.default
+      : moduleExports[metadata.name];
+}
 function prepareDestinationWithChunks(moduleLoading, chunks, nonce$jscomp$0) {
   if (null !== moduleLoading)
     for (var i = 1; i < chunks.length; i += 2) {
@@ -101,10 +117,10 @@ function serializeNumber(number) {
       ? "$-0"
       : number
     : Infinity === number
-    ? "$Infinity"
-    : -Infinity === number
-    ? "$-Infinity"
-    : "$NaN";
+      ? "$Infinity"
+      : -Infinity === number
+        ? "$-Infinity"
+        : "$NaN";
 }
 function processReply(
   root,
@@ -453,12 +469,17 @@ function processReply(
     pendingParts = 0,
     formData = null,
     writtenObjects = new WeakMap(),
-    modelRoot = root;
-  root = serializeModel(root, 0);
+    modelRoot = root,
+    json = serializeModel(root, 0);
   null === formData
-    ? resolve(root)
-    : (formData.set(formFieldPrefix + "0", root),
+    ? resolve(json)
+    : (formData.set(formFieldPrefix + "0", json),
       0 === pendingParts && resolve(formData));
+  return function () {
+    0 < pendingParts &&
+      ((pendingParts = 0),
+      null === formData ? resolve(json) : resolve(formData));
+  };
 }
 var boundCache = new WeakMap();
 function encodeFormData(reference) {
@@ -597,22 +618,38 @@ function bind() {
   }
   return newFn;
 }
+function createBoundServerReference(metaData, callServer, encodeFormAction) {
+  function action() {
+    var args = Array.prototype.slice.call(arguments);
+    return bound
+      ? "fulfilled" === bound.status
+        ? callServer(id, bound.value.concat(args))
+        : Promise.resolve(bound).then(function (boundArgs) {
+            return callServer(id, boundArgs.concat(args));
+          })
+      : callServer(id, args);
+  }
+  var id = metaData.id,
+    bound = metaData.bound;
+  registerServerReference(action, { id: id, bound: bound }, encodeFormAction);
+  return action;
+}
 function createServerReference$1(id, callServer, encodeFormAction) {
-  function proxy() {
+  function action() {
     var args = Array.prototype.slice.call(arguments);
     return callServer(id, args);
   }
-  registerServerReference(proxy, { id: id, bound: null }, encodeFormAction);
-  return proxy;
+  registerServerReference(action, { id: id, bound: null }, encodeFormAction);
+  return action;
 }
-function Chunk(status, value, reason, response) {
+function ReactPromise(status, value, reason, response) {
   this.status = status;
   this.value = value;
   this.reason = reason;
   this._response = response;
 }
-Chunk.prototype = Object.create(Promise.prototype);
-Chunk.prototype.then = function (resolve, reject) {
+ReactPromise.prototype = Object.create(Promise.prototype);
+ReactPromise.prototype.then = function (resolve, reject) {
   switch (this.status) {
     case "resolved_model":
       initializeModelChunk(this);
@@ -626,7 +663,6 @@ Chunk.prototype.then = function (resolve, reject) {
       break;
     case "pending":
     case "blocked":
-    case "cyclic":
       resolve &&
         (null === this.value && (this.value = []), this.value.push(resolve));
       reject &&
@@ -649,14 +685,13 @@ function readChunk(chunk) {
       return chunk.value;
     case "pending":
     case "blocked":
-    case "cyclic":
       throw chunk;
     default:
       throw chunk.reason;
   }
 }
 function createPendingChunk(response) {
-  return new Chunk("pending", null, null, response);
+  return new ReactPromise("pending", null, null, response);
 }
 function wakeChunk(listeners, value) {
   for (var i = 0; i < listeners.length; i++) (0, listeners[i])(value);
@@ -668,7 +703,6 @@ function wakeChunkIfInitialized(chunk, resolveListeners, rejectListeners) {
       break;
     case "pending":
     case "blocked":
-    case "cyclic":
       if (chunk.value)
         for (var i = 0; i < resolveListeners.length; i++)
           chunk.value.push(resolveListeners[i]);
@@ -698,7 +732,7 @@ function triggerErrorOnChunk(chunk, error) {
   }
 }
 function createResolvedIteratorResultChunk(response, value, done) {
-  return new Chunk(
+  return new ReactPromise(
     "resolved_model",
     (done ? '{"done":true,"value":' : '{"done":false,"value":') + value + "}",
     null,
@@ -734,51 +768,42 @@ function resolveModuleChunk(chunk, value) {
       wakeChunkIfInitialized(chunk, resolveListeners, rejectListeners));
   }
 }
-var initializingChunk = null,
-  initializingChunkBlockedModel = null;
+var initializingHandler = null;
 function initializeModelChunk(chunk) {
-  var prevChunk = initializingChunk,
-    prevBlocked = initializingChunkBlockedModel;
-  initializingChunk = chunk;
-  initializingChunkBlockedModel = null;
+  var prevHandler = initializingHandler;
+  initializingHandler = null;
   var resolvedModel = chunk.value;
-  chunk.status = "cyclic";
+  chunk.status = "blocked";
   chunk.value = null;
   chunk.reason = null;
   try {
-    var value = JSON.parse(resolvedModel, chunk._response._fromJSON);
-    if (
-      null !== initializingChunkBlockedModel &&
-      0 < initializingChunkBlockedModel.deps
-    )
-      (initializingChunkBlockedModel.value = value), (chunk.status = "blocked");
-    else {
-      var resolveListeners = chunk.value;
-      chunk.status = "fulfilled";
-      chunk.value = value;
-      null !== resolveListeners && wakeChunk(resolveListeners, value);
+    var value = JSON.parse(resolvedModel, chunk._response._fromJSON),
+      resolveListeners = chunk.value;
+    null !== resolveListeners &&
+      ((chunk.value = null),
+      (chunk.reason = null),
+      wakeChunk(resolveListeners, value));
+    if (null !== initializingHandler) {
+      if (initializingHandler.errored) throw initializingHandler.value;
+      if (0 < initializingHandler.deps) {
+        initializingHandler.value = value;
+        initializingHandler.chunk = chunk;
+        return;
+      }
     }
+    chunk.status = "fulfilled";
+    chunk.value = value;
   } catch (error) {
     (chunk.status = "rejected"), (chunk.reason = error);
   } finally {
-    (initializingChunk = prevChunk),
-      (initializingChunkBlockedModel = prevBlocked);
+    initializingHandler = prevHandler;
   }
 }
 function initializeModuleChunk(chunk) {
   try {
-    var metadata = chunk.value,
-      promise = asyncModuleCache.get(metadata.specifier);
-    if ("fulfilled" === promise.status) var moduleExports = promise.value;
-    else throw promise.reason;
-    var JSCompiler_inline_result =
-      "*" === metadata.name
-        ? moduleExports
-        : "" === metadata.name
-        ? moduleExports.default
-        : moduleExports[metadata.name];
+    var value = requireModule(chunk.value);
     chunk.status = "fulfilled";
-    chunk.value = JSCompiler_inline_result;
+    chunk.value = value;
   } catch (error) {
     (chunk.status = "rejected"), (chunk.reason = error);
   }
@@ -788,62 +813,151 @@ function reportGlobalError(response, error) {
     "pending" === chunk.status && triggerErrorOnChunk(chunk, error);
   });
 }
+function createLazyChunkWrapper(chunk) {
+  return { $$typeof: REACT_LAZY_TYPE, _payload: chunk, _init: readChunk };
+}
 function getChunk(response, id) {
   var chunks = response._chunks,
     chunk = chunks.get(id);
   chunk || ((chunk = createPendingChunk(response)), chunks.set(id, chunk));
   return chunk;
 }
-function createModelResolver(
-  chunk,
+function waitForReference(
+  referencedChunk,
   parentObject,
   key,
-  cyclic,
   response,
   map,
   path
 ) {
-  if (initializingChunkBlockedModel) {
-    var blocked = initializingChunkBlockedModel;
-    cyclic || blocked.deps++;
+  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
+    )
+      switch (((value = handler.value), key)) {
+        case "3":
+          value.props = 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) {
+      handler.errored = !0;
+      handler.value = error;
+      var chunk = handler.chunk;
+      null !== chunk &&
+        "blocked" === chunk.status &&
+        triggerErrorOnChunk(chunk, error);
+    }
+  }
+  if (initializingHandler) {
+    var handler = initializingHandler;
+    handler.deps++;
   } else
-    blocked = initializingChunkBlockedModel = {
-      deps: cyclic ? 0 : 1,
-      value: null
+    handler = initializingHandler = {
+      parent: null,
+      chunk: null,
+      value: null,
+      deps: 1,
+      errored: !1
     };
-  return function (value) {
-    for (var i = 1; i < path.length; i++) value = value[path[i]];
-    parentObject[key] = map(response, value);
-    "" === key && null === blocked.value && (blocked.value = parentObject[key]);
-    blocked.deps--;
-    0 === blocked.deps &&
-      "blocked" === chunk.status &&
-      ((value = chunk.value),
-      (chunk.status = "fulfilled"),
-      (chunk.value = blocked.value),
-      null !== value && wakeChunk(value, blocked.value));
-  };
+  referencedChunk.then(fulfill, reject);
+  return null;
 }
-function createModelReject(chunk) {
-  return function (error) {
-    return triggerErrorOnChunk(chunk, error);
-  };
-}
-function createServerReferenceProxy(response, metaData) {
-  function proxy() {
-    var args = Array.prototype.slice.call(arguments),
-      p = metaData.bound;
-    return p
-      ? "fulfilled" === p.status
-        ? callServer(metaData.id, p.value.concat(args))
-        : Promise.resolve(p).then(function (bound) {
-            return callServer(metaData.id, bound.concat(args));
-          })
-      : callServer(metaData.id, args);
-  }
-  var callServer = response._callServer;
-  registerServerReference(proxy, metaData, response._encodeFormAction);
-  return proxy;
+function loadServerReference(response, metaData, parentObject, key) {
+  if (!response._serverReferenceConfig)
+    return createBoundServerReference(
+      metaData,
+      response._callServer,
+      response._encodeFormAction
+    );
+  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);
+  else return requireModule(serverReference);
+  if (initializingHandler) {
+    var handler = initializingHandler;
+    handler.deps++;
+  } else
+    handler = initializingHandler = {
+      parent: null,
+      chunk: null,
+      value: null,
+      deps: 1,
+      errored: !1
+    };
+  response.then(
+    function () {
+      var resolvedValue = requireModule(serverReference);
+      if (metaData.bound) {
+        var boundArgs = metaData.bound.value.slice(0);
+        boundArgs.unshift(null);
+        resolvedValue = resolvedValue.bind.apply(resolvedValue, boundArgs);
+      }
+      parentObject[key] = resolvedValue;
+      "" === key && null === handler.value && (handler.value = resolvedValue);
+      if (
+        parentObject[0] === REACT_ELEMENT_TYPE &&
+        "object" === typeof handler.value &&
+        null !== handler.value &&
+        handler.value.$$typeof === REACT_ELEMENT_TYPE
+      )
+        switch (((boundArgs = handler.value), key)) {
+          case "3":
+            boundArgs.props = resolvedValue;
+        }
+      handler.deps--;
+      0 === handler.deps &&
+        ((resolvedValue = handler.chunk),
+        null !== resolvedValue &&
+          "blocked" === resolvedValue.status &&
+          ((boundArgs = resolvedValue.value),
+          (resolvedValue.status = "fulfilled"),
+          (resolvedValue.value = handler.value),
+          null !== boundArgs && wakeChunk(boundArgs, handler.value)));
+    },
+    function (error) {
+      if (!handler.errored) {
+        handler.errored = !0;
+        handler.value = error;
+        var chunk = handler.chunk;
+        null !== chunk &&
+          "blocked" === chunk.status &&
+          triggerErrorOnChunk(chunk, error);
+      }
+    }
+  );
+  return null;
 }
 function getOutlinedModel(response, reference, parentObject, key, map) {
   reference = reference.split(":");
@@ -858,29 +972,40 @@ function getOutlinedModel(response, reference, parentObject, key, map) {
   }
   switch (id.status) {
     case "fulfilled":
-      parentObject = id.value;
-      for (key = 1; key < reference.length; key++)
-        parentObject = parentObject[reference[key]];
-      return map(response, parentObject);
+      var value = id.value;
+      for (id = 1; id < reference.length; id++) {
+        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(id - 1)
+            );
+        value = value[reference[id]];
+      }
+      return map(response, value, parentObject, key);
     case "pending":
     case "blocked":
-    case "cyclic":
-      var parentChunk = initializingChunk;
-      id.then(
-        createModelResolver(
-          parentChunk,
-          parentObject,
-          key,
-          "cyclic" === id.status,
-          response,
-          map,
-          reference
-        ),
-        createModelReject(parentChunk)
-      );
-      return null;
+      return waitForReference(id, parentObject, key, response, map, reference);
     default:
-      throw id.reason;
+      return (
+        initializingHandler
+          ? ((initializingHandler.errored = !0),
+            (initializingHandler.value = id.reason))
+          : (initializingHandler = {
+              parent: null,
+              chunk: null,
+              value: id.reason,
+              deps: 0,
+              errored: !0
+            }),
+        null
+      );
   }
 }
 function createMap(response, model) {
@@ -906,7 +1031,19 @@ function createModel(response, model) {
 }
 function parseModelString(response, parentObject, key, value) {
   if ("$" === value[0]) {
-    if ("$" === value) return REACT_ELEMENT_TYPE;
+    if ("$" === value)
+      return (
+        null !== initializingHandler &&
+          "0" === key &&
+          (initializingHandler = {
+            parent: initializingHandler,
+            chunk: null,
+            value: null,
+            deps: 0,
+            errored: !1
+          }),
+        REACT_ELEMENT_TYPE
+      );
     switch (value[1]) {
       case "$":
         return value.slice(1);
@@ -914,7 +1051,7 @@ function parseModelString(response, parentObject, key, value) {
         return (
           (parentObject = parseInt(value.slice(2), 16)),
           (response = getChunk(response, parentObject)),
-          { $$typeof: REACT_LAZY_TYPE, _payload: response, _init: readChunk }
+          createLazyChunkWrapper(response)
         );
       case "@":
         if (2 === value.length) return new Promise(function () {});
@@ -930,7 +1067,7 @@ function parseModelString(response, parentObject, key, value) {
             value,
             parentObject,
             key,
-            createServerReferenceProxy
+            loadServerReference
           )
         );
       case "T":
@@ -961,6 +1098,8 @@ function parseModelString(response, parentObject, key, value) {
           (value = value.slice(2)),
           getOutlinedModel(response, value, parentObject, key, createFormData)
         );
+      case "Z":
+        return resolveErrorProd();
       case "i":
         return (
           (value = value.slice(2)),
@@ -992,8 +1131,9 @@ function missingCall() {
     'Trying to call a function from "use server" but the callServer option was not implemented in your router runtime.'
   );
 }
-function createResponse(
+function ResponseInstance(
   bundlerConfig,
+  serverReferenceConfig,
   moduleLoading,
   callServer,
   encodeFormAction,
@@ -1001,31 +1141,26 @@ function createResponse(
   temporaryReferences
 ) {
   var chunks = new Map();
-  bundlerConfig = {
-    _bundlerConfig: bundlerConfig,
-    _moduleLoading: moduleLoading,
-    _callServer: void 0 !== callServer ? callServer : missingCall,
-    _encodeFormAction: encodeFormAction,
-    _nonce: nonce,
-    _chunks: chunks,
-    _stringDecoder: new util.TextDecoder(),
-    _fromJSON: null,
-    _rowState: 0,
-    _rowID: 0,
-    _rowTag: 0,
-    _rowLength: 0,
-    _buffer: [],
-    _tempRefs: temporaryReferences
-  };
-  bundlerConfig._fromJSON = createFromJSONCallback(bundlerConfig);
-  return bundlerConfig;
+  this._bundlerConfig = bundlerConfig;
+  this._serverReferenceConfig = serverReferenceConfig;
+  this._moduleLoading = moduleLoading;
+  this._callServer = void 0 !== callServer ? callServer : missingCall;
+  this._encodeFormAction = encodeFormAction;
+  this._nonce = nonce;
+  this._chunks = chunks;
+  this._stringDecoder = new util.TextDecoder();
+  this._fromJSON = null;
+  this._rowLength = this._rowTag = this._rowID = this._rowState = 0;
+  this._buffer = [];
+  this._tempRefs = temporaryReferences;
+  this._fromJSON = createFromJSONCallback(this);
 }
 function resolveBuffer(response, id, buffer) {
   var chunks = response._chunks,
     chunk = chunks.get(id);
   chunk && "pending" !== chunk.status
     ? chunk.reason.enqueueValue(buffer)
-    : chunks.set(id, new Chunk("fulfilled", buffer, null, response));
+    : chunks.set(id, new ReactPromise("fulfilled", buffer, null, response));
 }
 function resolveModule(response, id, model) {
   var chunks = response._chunks,
@@ -1042,7 +1177,7 @@ function resolveModule(response, id, model) {
       var blockedChunk = chunk;
       blockedChunk.status = "blocked";
     } else
-      (blockedChunk = new Chunk("blocked", null, null, response)),
+      (blockedChunk = new ReactPromise("blocked", null, null, response)),
         chunks.set(id, blockedChunk);
     model.then(
       function () {
@@ -1057,7 +1192,7 @@ function resolveModule(response, id, model) {
       ? resolveModuleChunk(chunk, clientReference)
       : chunks.set(
           id,
-          new Chunk("resolved_module", clientReference, null, response)
+          new ReactPromise("resolved_module", clientReference, null, response)
         );
 }
 function resolveStream(response, id, stream, controller) {
@@ -1070,7 +1205,10 @@ function resolveStream(response, id, stream, controller) {
       (chunk.value = stream),
       (chunk.reason = controller),
       null !== response && wakeChunk(response, chunk.value))
-    : chunks.set(id, new Chunk("fulfilled", stream, controller, response));
+    : chunks.set(
+        id,
+        new ReactPromise("fulfilled", stream, controller, response)
+      );
 }
 function startReadableStream(response, id, type) {
   var controller = null;
@@ -1091,7 +1229,7 @@ function startReadableStream(response, id, type) {
     },
     enqueueModel: function (json) {
       if (null === previousBlockedChunk) {
-        var chunk = new Chunk("resolved_model", json, null, response);
+        var chunk = new ReactPromise("resolved_model", json, null, response);
         initializeModelChunk(chunk);
         "fulfilled" === chunk.status
           ? controller.enqueue(chunk.value)
@@ -1106,8 +1244,8 @@ function startReadableStream(response, id, type) {
             (previousBlockedChunk = chunk));
       } else {
         chunk = previousBlockedChunk;
-        var chunk$51 = createPendingChunk(response);
-        chunk$51.then(
+        var chunk$52 = createPendingChunk(response);
+        chunk$52.then(
           function (v) {
             return controller.enqueue(v);
           },
@@ -1115,10 +1253,10 @@ function startReadableStream(response, id, type) {
             return controller.error(e);
           }
         );
-        previousBlockedChunk = chunk$51;
+        previousBlockedChunk = chunk$52;
         chunk.then(function () {
-          previousBlockedChunk === chunk$51 && (previousBlockedChunk = null);
-          resolveModelChunk(chunk$51, json);
+          previousBlockedChunk === chunk$52 && (previousBlockedChunk = null);
+          resolveModelChunk(chunk$52, json);
         });
       }
     },
@@ -1167,7 +1305,7 @@ function startAsyncIterable(response, id, iterator) {
           );
         if (nextReadIndex === buffer.length) {
           if (closed)
-            return new Chunk(
+            return new ReactPromise(
               "fulfilled",
               { done: !0, value: void 0 },
               null,
@@ -1186,7 +1324,7 @@ function startAsyncIterable(response, id, iterator) {
     {
       enqueueValue: function (value) {
         if (nextWriteIndex === buffer.length)
-          buffer[nextWriteIndex] = new Chunk(
+          buffer[nextWriteIndex] = new ReactPromise(
             "fulfilled",
             { done: !1, value: value },
             null,
@@ -1242,12 +1380,19 @@ function startAsyncIterable(response, id, iterator) {
     }
   );
 }
+function resolveErrorProd() {
+  var error = Error(
+    "An error occurred in the Server Components render. The specific message is omitted in production builds to avoid leaking sensitive details. A digest property is included on this error instance which may provide additional details about the nature of the error."
+  );
+  error.stack = "Error: " + error.message;
+  return error;
+}
 function mergeBuffer(buffer, lastChunk) {
   for (var l = buffer.length, byteLength = lastChunk.length, i = 0; i < l; i++)
     byteLength += buffer[i].byteLength;
   byteLength = new Uint8Array(byteLength);
-  for (var i$52 = (i = 0); i$52 < l; i$52++) {
-    var chunk = buffer[i$52];
+  for (var i$53 = (i = 0); i$53 < l; i$53++) {
+    var chunk = buffer[i$53];
     byteLength.set(chunk, i);
     i += chunk.byteLength;
   }
@@ -1273,7 +1418,7 @@ function resolveTypedArray(
   );
   resolveBuffer(response, id, constructor);
 }
-function processFullRow(response, id, tag, buffer, chunk) {
+function processFullBinaryRow(response, id, tag, buffer, chunk) {
   switch (tag) {
     case 65:
       resolveBuffer(response, id, mergeBuffer(buffer, chunk).buffer);
@@ -1326,6 +1471,9 @@ function processFullRow(response, id, tag, buffer, chunk) {
   )
     row += stringDecoder.decode(buffer[i], decoderOptions);
   row += stringDecoder.decode(chunk);
+  processFullStringRow(response, id, tag, row);
+}
+function processFullStringRow(response, id, tag, row) {
   switch (tag) {
     case 73:
       resolveModule(response, id, row);
@@ -1375,22 +1523,20 @@ function processFullRow(response, id, tag, buffer, chunk) {
       }
       break;
     case 69:
-      tag = JSON.parse(row).digest;
-      row = Error(
-        "An error occurred in the Server Components render. The specific message is omitted in production builds to avoid leaking sensitive details. A digest property is included on this error instance which may provide additional details about the nature of the error."
-      );
-      row.stack = "Error: " + row.message;
-      row.digest = tag;
+      tag = JSON.parse(row);
+      row = resolveErrorProd();
+      row.digest = tag.digest;
       tag = response._chunks;
-      (buffer = tag.get(id))
-        ? triggerErrorOnChunk(buffer, row)
-        : tag.set(id, new Chunk("rejected", null, row, response));
+      var chunk = tag.get(id);
+      chunk
+        ? triggerErrorOnChunk(chunk, row)
+        : tag.set(id, new ReactPromise("rejected", null, row, response));
       break;
     case 84:
       tag = response._chunks;
-      (buffer = tag.get(id)) && "pending" !== buffer.status
-        ? buffer.reason.enqueueValue(row)
-        : tag.set(id, new Chunk("fulfilled", row, null, response));
+      (chunk = tag.get(id)) && "pending" !== chunk.status
+        ? chunk.reason.enqueueValue(row)
+        : tag.set(id, new ReactPromise("fulfilled", row, null, response));
       break;
     case 68:
     case 87:
@@ -1416,28 +1562,52 @@ function processFullRow(response, id, tag, buffer, chunk) {
       break;
     default:
       (tag = response._chunks),
-        (buffer = tag.get(id))
-          ? resolveModelChunk(buffer, row)
-          : tag.set(id, new Chunk("resolved_model", row, null, response));
+        (chunk = tag.get(id))
+          ? resolveModelChunk(chunk, row)
+          : tag.set(
+              id,
+              new ReactPromise("resolved_model", row, null, response)
+            );
   }
 }
 function createFromJSONCallback(response) {
   return function (key, value) {
-    return "string" === typeof value
-      ? parseModelString(response, this, key, value)
-      : "object" === typeof value && null !== value
-      ? ((key =
-          value[0] === REACT_ELEMENT_TYPE
-            ? {
-                $$typeof: REACT_ELEMENT_TYPE,
-                type: value[1],
-                key: value[2],
-                ref: null,
-                props: value[3]
-              }
-            : value),
-        key)
-      : value;
+    if ("string" === typeof value)
+      return parseModelString(response, this, key, value);
+    if ("object" === typeof value && null !== value) {
+      if (value[0] === REACT_ELEMENT_TYPE) {
+        if (
+          ((key = {
+            $$typeof: REACT_ELEMENT_TYPE,
+            type: value[1],
+            key: value[2],
+            ref: null,
+            props: value[3]
+          }),
+          null !== initializingHandler)
+        )
+          if (
+            ((value = initializingHandler),
+            (initializingHandler = value.parent),
+            value.errored)
+          )
+            (key = new ReactPromise("rejected", null, value.value, response)),
+              (key = createLazyChunkWrapper(key));
+          else if (0 < value.deps) {
+            var blockedChunk = new ReactPromise(
+              "blocked",
+              null,
+              null,
+              response
+            );
+            value.value = key;
+            value.chunk = blockedChunk;
+            key = createLazyChunkWrapper(blockedChunk);
+          }
+      } else key = value;
+      return key;
+    }
+    return value;
   };
 }
 function noServerCall() {
@@ -1445,92 +1615,191 @@ function noServerCall() {
     "Server Functions cannot be called during initial render. This would create a fetch waterfall. Try to use a Server Component to pass data to Client Components instead."
   );
 }
-exports.createFromNodeStream = function (stream, ssrManifest, options) {
-  var response = createResponse(
-    ssrManifest.moduleMap,
-    ssrManifest.moduleLoading,
+exports.createFromNodeStream = function (
+  stream,
+  serverConsumerManifest,
+  options
+) {
+  var response = new ResponseInstance(
+    serverConsumerManifest.moduleMap,
+    serverConsumerManifest.serverModuleMap,
+    serverConsumerManifest.moduleLoading,
     noServerCall,
     options ? options.encodeFormAction : void 0,
     options && "string" === typeof options.nonce ? options.nonce : void 0,
     void 0
   );
   stream.on("data", function (chunk) {
-    for (
-      var i = 0,
-        rowState = response._rowState,
-        rowID = response._rowID,
-        rowTag = response._rowTag,
-        rowLength = response._rowLength,
-        buffer = response._buffer,
-        chunkLength = chunk.length;
-      i < chunkLength;
+    if ("string" === typeof chunk) {
+      for (
+        var i = 0,
+          rowState = response._rowState,
+          rowID = response._rowID,
+          rowTag = response._rowTag,
+          rowLength = response._rowLength,
+          buffer = response._buffer,
+          chunkLength = chunk.length;
+        i < chunkLength;
 
-    ) {
-      var lastIdx = -1;
-      switch (rowState) {
-        case 0:
-          lastIdx = chunk[i++];
-          58 === lastIdx
-            ? (rowState = 1)
-            : (rowID =
-                (rowID << 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) ||
-              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 lastIdx = -1;
+        switch (rowState) {
+          case 0:
+            lastIdx = chunk.charCodeAt(i++);
+            58 === lastIdx
+              ? (rowState = 1)
+              : (rowID =
+                  (rowID << 4) | (96 < lastIdx ? lastIdx - 87 : lastIdx - 48));
+            continue;
+          case 1:
+            rowState = chunk.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 = chunk.charCodeAt(i++);
+            44 === lastIdx
+              ? (rowState = 4)
+              : (rowLength =
+                  (rowLength << 4) |
+                  (96 < lastIdx ? lastIdx - 87 : lastIdx - 48));
+            continue;
+          case 3:
+            lastIdx = chunk.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 < chunk.length || chunk.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 = chunk.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 = chunk.slice(i, lastIdx);
+          processFullStringRow(response, rowID, rowTag, i);
+          i = lastIdx;
+          3 === rowState && i++;
+          rowLength = rowID = rowTag = rowState = 0;
+          buffer.length = 0;
+        } else if (chunk.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."
+          );
       }
-      var offset = chunk.byteOffset + i;
-      if (-1 < lastIdx)
-        (rowLength = new Uint8Array(chunk.buffer, offset, lastIdx - i)),
-          processFullRow(response, rowID, rowTag, buffer, rowLength),
-          (i = lastIdx),
-          3 === rowState && i++,
-          (rowLength = rowID = rowTag = rowState = 0),
-          (buffer.length = 0);
-      else {
-        chunk = new Uint8Array(chunk.buffer, offset, chunk.byteLength - i);
-        buffer.push(chunk);
-        rowLength -= chunk.byteLength;
-        break;
+      response._rowState = rowState;
+      response._rowID = rowID;
+      response._rowTag = rowTag;
+      response._rowLength = rowLength;
+    } else {
+      rowLength = 0;
+      chunkLength = response._rowState;
+      rowID = response._rowID;
+      i = response._rowTag;
+      rowState = response._rowLength;
+      buffer = response._buffer;
+      for (rowTag = chunk.length; rowLength < rowTag; ) {
+        lastIdx = -1;
+        switch (chunkLength) {
+          case 0:
+            lastIdx = chunk[rowLength++];
+            58 === lastIdx
+              ? (chunkLength = 1)
+              : (rowID =
+                  (rowID << 4) | (96 < lastIdx ? lastIdx - 87 : lastIdx - 48));
+            continue;
+          case 1:
+            chunkLength = chunk[rowLength];
+            84 === chunkLength ||
+            65 === chunkLength ||
+            79 === chunkLength ||
+            111 === chunkLength ||
+            85 === chunkLength ||
+            83 === chunkLength ||
+            115 === chunkLength ||
+            76 === chunkLength ||
+            108 === chunkLength ||
+            71 === chunkLength ||
+            103 === chunkLength ||
+            77 === chunkLength ||
+            109 === chunkLength ||
+            86 === chunkLength
+              ? ((i = chunkLength), (chunkLength = 2), rowLength++)
+              : (64 < chunkLength && 91 > chunkLength) ||
+                  35 === chunkLength ||
+                  114 === chunkLength ||
+                  120 === chunkLength
+                ? ((i = chunkLength), (chunkLength = 3), rowLength++)
+                : ((i = 0), (chunkLength = 3));
+            continue;
+          case 2:
+            lastIdx = chunk[rowLength++];
+            44 === lastIdx
+              ? (chunkLength = 4)
+              : (rowState =
+                  (rowState << 4) |
+                  (96 < lastIdx ? lastIdx - 87 : lastIdx - 48));
+            continue;
+          case 3:
+            lastIdx = chunk.indexOf(10, rowLength);
+            break;
+          case 4:
+            (lastIdx = rowLength + rowState),
+              lastIdx > chunk.length && (lastIdx = -1);
+        }
+        var offset = chunk.byteOffset + rowLength;
+        if (-1 < lastIdx)
+          (rowState = new Uint8Array(
+            chunk.buffer,
+            offset,
+            lastIdx - rowLength
+          )),
+            processFullBinaryRow(response, rowID, i, buffer, rowState),
+            (rowLength = lastIdx),
+            3 === chunkLength && rowLength++,
+            (rowState = rowID = i = chunkLength = 0),
+            (buffer.length = 0);
+        else {
+          chunk = new Uint8Array(
+            chunk.buffer,
+            offset,
+            chunk.byteLength - rowLength
+          );
+          buffer.push(chunk);
+          rowState -= chunk.byteLength;
+          break;
+        }
       }
+      response._rowState = chunkLength;
+      response._rowID = rowID;
+      response._rowTag = i;
+      response._rowLength = rowState;
     }
-    response._rowState = rowState;
-    response._rowID = rowID;
-    response._rowTag = rowTag;
-    response._rowLength = rowLength;
   });
   stream.on("error", function (error) {
     reportGlobalError(response, error);