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

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

@@ -14,15 +14,15 @@ var ReactDOM = require("react-dom"),
 function resolveClientReference(bundlerConfig, metadata) {
   if (bundlerConfig) {
     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,26 @@ function resolveClientReference(bundlerConfig, metadata) {
   }
   return metadata;
 }
+function resolveServerReference(bundlerConfig, id) {
+  var name = "",
+    resolvedModuleData = bundlerConfig[id];
+  if (resolvedModuleData) name = resolvedModuleData.name;
+  else {
+    var idx = id.lastIndexOf("#");
+    -1 !== idx &&
+      ((name = id.slice(idx + 1)),
+      (resolvedModuleData = bundlerConfig[id.slice(0, idx)]));
+    if (!resolvedModuleData)
+      throw Error(
+        'Could not find the module "' +
+          id +
+          '" in the React Server Manifest. This is probably a bug in the React Server Components bundler.'
+      );
+  }
+  return resolvedModuleData.async
+    ? [resolvedModuleData.id, resolvedModuleData.chunks, name, 1]
+    : [resolvedModuleData.id, resolvedModuleData.chunks, name];
+}
 var chunkCache = new Map();
 function requireAsyncModule(id) {
   var promise = __webpack_require__(id);
@@ -70,8 +90,22 @@ function preloadModule(metadata) {
           return requireAsyncModule(metadata[0]);
         })
     : 0 < promises.length
-    ? Promise.all(promises)
-    : null;
+      ? Promise.all(promises)
+      : null;
+}
+function requireModule(metadata) {
+  var moduleExports = __webpack_require__(metadata[0]);
+  if (4 === metadata.length && "function" === typeof moduleExports.then)
+    if ("fulfilled" === moduleExports.status)
+      moduleExports = moduleExports.value;
+    else throw moduleExports.reason;
+  return "*" === metadata[2]
+    ? moduleExports
+    : "" === metadata[2]
+      ? moduleExports.__esModule
+        ? moduleExports.default
+        : moduleExports
+      : moduleExports[metadata[2]];
 }
 function prepareDestinationWithChunks(moduleLoading, chunks, nonce$jscomp$0) {
   if (null !== moduleLoading)
@@ -117,10 +151,10 @@ function serializeNumber(number) {
       ? "$-0"
       : number
     : Infinity === number
-    ? "$Infinity"
-    : -Infinity === number
-    ? "$-Infinity"
-    : "$NaN";
+      ? "$Infinity"
+      : -Infinity === number
+        ? "$-Infinity"
+        : "$NaN";
 }
 function processReply(
   root,
@@ -469,12 +503,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) {
@@ -613,22 +652,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);
@@ -642,7 +697,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 &&
@@ -665,14 +719,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);
@@ -684,7 +737,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]);
@@ -714,7 +766,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,
@@ -750,55 +802,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,
-      moduleExports = __webpack_require__(metadata[0]);
-    if (4 === metadata.length && "function" === typeof moduleExports.then)
-      if ("fulfilled" === moduleExports.status)
-        moduleExports = moduleExports.value;
-      else throw moduleExports.reason;
-    var JSCompiler_inline_result =
-      "*" === metadata[2]
-        ? moduleExports
-        : "" === metadata[2]
-        ? moduleExports.__esModule
-          ? moduleExports.default
-          : moduleExports
-        : moduleExports[metadata[2]];
+    var value = requireModule(chunk.value);
     chunk.status = "fulfilled";
-    chunk.value = JSCompiler_inline_result;
+    chunk.value = value;
   } catch (error) {
     (chunk.status = "rejected"), (chunk.reason = error);
   }
@@ -808,62 +847,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(":");
@@ -878,29 +1006,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) {
@@ -926,7 +1065,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);
@@ -934,7 +1085,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 () {});
@@ -950,7 +1101,7 @@ function parseModelString(response, parentObject, key, value) {
             value,
             parentObject,
             key,
-            createServerReferenceProxy
+            loadServerReference
           )
         );
       case "T":
@@ -981,6 +1132,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)),
@@ -1012,12 +1165,36 @@ function missingCall() {
     'Trying to call a function from "use server" but the callServer option was not implemented in your router runtime.'
   );
 }
+function ResponseInstance(
+  bundlerConfig,
+  serverReferenceConfig,
+  moduleLoading,
+  callServer,
+  encodeFormAction,
+  nonce,
+  temporaryReferences
+) {
+  var chunks = new Map();
+  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 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,
@@ -1034,7 +1211,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 () {
@@ -1049,7 +1226,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) {
@@ -1062,7 +1239,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;
@@ -1083,7 +1263,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)
@@ -1098,8 +1278,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);
           },
@@ -1107,10 +1287,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);
         });
       }
     },
@@ -1159,7 +1339,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,
@@ -1178,7 +1358,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,
@@ -1234,12 +1414,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;
   }
@@ -1265,7 +1452,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);
@@ -1317,44 +1504,46 @@ function processFullRow(response, id, tag, buffer, chunk) {
     i++
   )
     row += stringDecoder.decode(buffer[i], decoderOptions);
-  row += stringDecoder.decode(chunk);
+  buffer = row += stringDecoder.decode(chunk);
   switch (tag) {
     case 73:
-      resolveModule(response, id, row);
+      resolveModule(response, id, buffer);
       break;
     case 72:
-      id = row[0];
-      row = row.slice(1);
-      response = JSON.parse(row, response._fromJSON);
-      row = ReactDOMSharedInternals.d;
+      id = buffer[0];
+      buffer = buffer.slice(1);
+      response = JSON.parse(buffer, response._fromJSON);
+      buffer = ReactDOMSharedInternals.d;
       switch (id) {
         case "D":
-          row.D(response);
+          buffer.D(response);
           break;
         case "C":
           "string" === typeof response
-            ? row.C(response)
-            : row.C(response[0], response[1]);
+            ? buffer.C(response)
+            : buffer.C(response[0], response[1]);
           break;
         case "L":
           id = response[0];
           tag = response[1];
-          3 === response.length ? row.L(id, tag, response[2]) : row.L(id, tag);
+          3 === response.length
+            ? buffer.L(id, tag, response[2])
+            : buffer.L(id, tag);
           break;
         case "m":
           "string" === typeof response
-            ? row.m(response)
-            : row.m(response[0], response[1]);
+            ? buffer.m(response)
+            : buffer.m(response[0], response[1]);
           break;
         case "X":
           "string" === typeof response
-            ? row.X(response)
-            : row.X(response[0], response[1]);
+            ? buffer.X(response)
+            : buffer.X(response[0], response[1]);
           break;
         case "S":
           "string" === typeof response
-            ? row.S(response)
-            : row.S(
+            ? buffer.S(response)
+            : buffer.S(
                 response[0],
                 0 === response[1] ? void 0 : response[1],
                 3 === response.length ? response[2] : void 0
@@ -1362,27 +1551,24 @@ function processFullRow(response, id, tag, buffer, chunk) {
           break;
         case "M":
           "string" === typeof response
-            ? row.M(response)
-            : row.M(response[0], response[1]);
+            ? buffer.M(response)
+            : buffer.M(response[0], response[1]);
       }
       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(buffer);
+      buffer = resolveErrorProd();
+      buffer.digest = tag.digest;
       tag = response._chunks;
-      (buffer = tag.get(id))
-        ? triggerErrorOnChunk(buffer, row)
-        : tag.set(id, new Chunk("rejected", null, row, response));
+      (chunk = tag.get(id))
+        ? triggerErrorOnChunk(chunk, buffer)
+        : tag.set(id, new ReactPromise("rejected", null, buffer, 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(buffer)
+        : tag.set(id, new ReactPromise("fulfilled", buffer, null, response));
       break;
     case 68:
     case 87:
@@ -1404,32 +1590,56 @@ function processFullRow(response, id, tag, buffer, chunk) {
     case 67:
       (response = response._chunks.get(id)) &&
         "fulfilled" === response.status &&
-        response.reason.close("" === row ? '"$undefined"' : row);
+        response.reason.close("" === buffer ? '"$undefined"' : buffer);
       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, buffer)
+          : tag.set(
+              id,
+              new ReactPromise("resolved_model", buffer, 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() {
@@ -1438,33 +1648,17 @@ function noServerCall() {
   );
 }
 function createResponseFromOptions(options) {
-  var bundlerConfig = options.ssrManifest.moduleMap,
-    moduleLoading = options.ssrManifest.moduleLoading,
-    encodeFormAction = options.encodeFormAction,
-    nonce = "string" === typeof options.nonce ? options.nonce : void 0;
-  options =
+  return new ResponseInstance(
+    options.serverConsumerManifest.moduleMap,
+    options.serverConsumerManifest.serverModuleMap,
+    options.serverConsumerManifest.moduleLoading,
+    noServerCall,
+    options.encodeFormAction,
+    "string" === typeof options.nonce ? options.nonce : void 0,
     options && options.temporaryReferences
       ? options.temporaryReferences
-      : void 0;
-  var chunks = new Map();
-  bundlerConfig = {
-    _bundlerConfig: bundlerConfig,
-    _moduleLoading: moduleLoading,
-    _callServer: void 0 !== noServerCall ? noServerCall : missingCall,
-    _encodeFormAction: encodeFormAction,
-    _nonce: nonce,
-    _chunks: chunks,
-    _stringDecoder: new TextDecoder(),
-    _fromJSON: null,
-    _rowState: 0,
-    _rowID: 0,
-    _rowTag: 0,
-    _rowLength: 0,
-    _buffer: [],
-    _tempRefs: options
-  };
-  bundlerConfig._fromJSON = createFromJSONCallback(bundlerConfig);
-  return bundlerConfig;
+      : void 0
+  );
 }
 function startReadingFromStream(response, stream) {
   function progress(_ref) {
@@ -1509,10 +1703,11 @@ function startReadingFromStream(response, stream) {
             86 === rowState
               ? ((rowTag = rowState), (rowState = 2), i++)
               : (64 < rowState && 91 > rowState) ||
-                114 === rowState ||
-                120 === rowState
-              ? ((rowTag = rowState), (rowState = 3), i++)
-              : ((rowTag = 0), (rowState = 3));
+                  35 === rowState ||
+                  114 === rowState ||
+                  120 === rowState
+                ? ((rowTag = rowState), (rowState = 3), i++)
+                : ((rowTag = 0), (rowState = 3));
             continue;
           case 2:
             lastIdx = value[i++];
@@ -1531,7 +1726,7 @@ function startReadingFromStream(response, stream) {
         var offset = value.byteOffset + i;
         if (-1 < lastIdx)
           (rowLength = new Uint8Array(value.buffer, offset, lastIdx - i)),
-            processFullRow(response, _ref, rowTag, buffer, rowLength),
+            processFullBinaryRow(response, _ref, rowTag, buffer, rowLength),
             (i = lastIdx),
             3 === rowState && i++,
             (rowLength = _ref = rowTag = rowState = 0),
@@ -1581,7 +1776,7 @@ exports.createTemporaryReferenceSet = function () {
 };
 exports.encodeReply = function (value, options) {
   return new Promise(function (resolve, reject) {
-    processReply(
+    var abort = processReply(
       value,
       "",
       options && options.temporaryReferences
@@ -1590,5 +1785,16 @@ exports.encodeReply = function (value, options) {
       resolve,
       reject
     );
+    if (options && options.signal) {
+      var signal = options.signal;
+      if (signal.aborted) abort(signal.reason);
+      else {
+        var listener = function () {
+          abort(signal.reason);
+          signal.removeEventListener("abort", listener);
+        };
+        signal.addEventListener("abort", listener);
+      }
+    }
   });
 };