react-server-dom-webpack 18.3.0-canary-b7972822b-20230503 → 18.3.0-canary-b00e27342-20230505

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

@@ -214,19 +214,43 @@ function dispatchHint(code, model) {
   }
 }
 
-var knownServerReferences = new WeakMap();
-function createServerReference(id, callServer) {
-  var proxy = function () {
-    // $FlowFixMe[method-unbinding]
-    var args = Array.prototype.slice.call(arguments);
-    return callServer(id, args);
-  };
+var ReactSharedInternals = React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
 
-  knownServerReferences.set(proxy, {
-    id: id,
-    bound: null
-  });
-  return proxy;
+function error(format) {
+  {
+    {
+      for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
+        args[_key2 - 1] = arguments[_key2];
+      }
+
+      printWarning('error', format, args);
+    }
+  }
+}
+
+function printWarning(level, format, args) {
+  // When changing this logic, you might want to also
+  // update consoleWithStackDev.www.js as well.
+  {
+    var ReactDebugCurrentFrame = ReactSharedInternals.ReactDebugCurrentFrame;
+    var stack = ReactDebugCurrentFrame.getStackAddendum();
+
+    if (stack !== '') {
+      format += '%s';
+      args = args.concat([stack]);
+    } // eslint-disable-next-line react-internal/safe-string-coercion
+
+
+    var argsWithFormat = args.map(function (item) {
+      return String(item);
+    }); // Careful: RN currently depends on this prefix
+
+    argsWithFormat.unshift('Warning: ' + format); // We intentionally don't use spread (or .apply) directly because it
+    // breaks IE9: https://github.com/facebook/react/issues/13610
+    // eslint-disable-next-line react-internal/no-production-logging
+
+    Function.prototype.apply.call(console[level], console, argsWithFormat);
+  }
 }
 
 // ATTENTION
@@ -257,1394 +281,1454 @@ function getIteratorFn(maybeIterable) {
   return null;
 }
 
-var ReactSharedInternals = React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
-
-var ContextRegistry = ReactSharedInternals.ContextRegistry;
-function getOrCreateServerContext(globalName) {
-  if (!ContextRegistry[globalName]) {
-    ContextRegistry[globalName] = React.createServerContext(globalName, // $FlowFixMe[incompatible-call] function signature doesn't reflect the symbol value
-    REACT_SERVER_CONTEXT_DEFAULT_VALUE_NOT_LOADED);
-  }
+var isArrayImpl = Array.isArray; // eslint-disable-next-line no-redeclare
 
-  return ContextRegistry[globalName];
+function isArray(a) {
+  return isArrayImpl(a);
 }
 
-var PENDING = 'pending';
-var BLOCKED = 'blocked';
-var RESOLVED_MODEL = 'resolved_model';
-var RESOLVED_MODULE = 'resolved_module';
-var INITIALIZED = 'fulfilled';
-var ERRORED = 'rejected'; // $FlowFixMe[missing-this-annot]
-
-function Chunk(status, value, reason, response) {
-  this.status = status;
-  this.value = value;
-  this.reason = reason;
-  this._response = response;
-} // We subclass Promise.prototype so that we get other methods like .catch
-
-
-Chunk.prototype = Object.create(Promise.prototype); // TODO: This doesn't return a new Promise chain unlike the real .then
-
-Chunk.prototype.then = function (resolve, reject) {
-  var chunk = this; // If we have resolved content, we try to initialize it first which
-  // might put us back into one of the other states.
+// in case they error.
 
-  switch (chunk.status) {
-    case RESOLVED_MODEL:
-      initializeModelChunk(chunk);
-      break;
+var jsxPropsParents = new WeakMap();
+var jsxChildrenParents = new WeakMap();
 
-    case RESOLVED_MODULE:
-      initializeModuleChunk(chunk);
-      break;
-  } // The status might have changed after initialization.
+function isObjectPrototype(object) {
+  if (!object) {
+    return false;
+  }
 
+  var ObjectPrototype = Object.prototype;
 
-  switch (chunk.status) {
-    case INITIALIZED:
-      resolve(chunk.value);
-      break;
+  if (object === ObjectPrototype) {
+    return true;
+  } // It might be an object from a different Realm which is
+  // still just a plain simple object.
 
-    case PENDING:
-    case BLOCKED:
-      if (resolve) {
-        if (chunk.value === null) {
-          chunk.value = [];
-        }
 
-        chunk.value.push(resolve);
-      }
+  if (Object.getPrototypeOf(object)) {
+    return false;
+  }
 
-      if (reject) {
-        if (chunk.reason === null) {
-          chunk.reason = [];
-        }
+  var names = Object.getOwnPropertyNames(object);
 
-        chunk.reason.push(reject);
-      }
+  for (var i = 0; i < names.length; i++) {
+    if (!(names[i] in ObjectPrototype)) {
+      return false;
+    }
+  }
 
-      break;
+  return true;
+}
 
-    default:
-      reject(chunk.reason);
-      break;
+function isSimpleObject(object) {
+  if (!isObjectPrototype(Object.getPrototypeOf(object))) {
+    return false;
   }
-};
-
-function readChunk(chunk) {
-  // If we have resolved content, we try to initialize it first which
-  // might put us back into one of the other states.
-  switch (chunk.status) {
-    case RESOLVED_MODEL:
-      initializeModelChunk(chunk);
-      break;
 
-    case RESOLVED_MODULE:
-      initializeModuleChunk(chunk);
-      break;
-  } // The status might have changed after initialization.
+  var names = Object.getOwnPropertyNames(object);
 
+  for (var i = 0; i < names.length; i++) {
+    var descriptor = Object.getOwnPropertyDescriptor(object, names[i]);
 
-  switch (chunk.status) {
-    case INITIALIZED:
-      return chunk.value;
+    if (!descriptor) {
+      return false;
+    }
 
-    case PENDING:
-    case BLOCKED:
-      // eslint-disable-next-line no-throw-literal
-      throw chunk;
+    if (!descriptor.enumerable) {
+      if ((names[i] === 'key' || names[i] === 'ref') && typeof descriptor.get === 'function') {
+        // React adds key and ref getters to props objects to issue warnings.
+        // Those getters will not be transferred to the client, but that's ok,
+        // so we'll special case them.
+        continue;
+      }
 
-    default:
-      throw chunk.reason;
+      return false;
+    }
   }
-}
 
-function getRoot(response) {
-  var chunk = getChunk(response, 0);
-  return chunk;
+  return true;
 }
-
-function createPendingChunk(response) {
-  // $FlowFixMe[invalid-constructor] Flow doesn't support functions as constructors
-  return new Chunk(PENDING, null, null, response);
+function objectName(object) {
+  // $FlowFixMe[method-unbinding]
+  var name = Object.prototype.toString.call(object);
+  return name.replace(/^\[object (.*)\]$/, function (m, p0) {
+    return p0;
+  });
 }
 
-function createBlockedChunk(response) {
-  // $FlowFixMe[invalid-constructor] Flow doesn't support functions as constructors
-  return new Chunk(BLOCKED, null, null, response);
+function describeKeyForErrorMessage(key) {
+  var encodedKey = JSON.stringify(key);
+  return '"' + key + '"' === encodedKey ? key : encodedKey;
 }
 
-function createErrorChunk(response, error) {
-  // $FlowFixMe[invalid-constructor] Flow doesn't support functions as constructors
-  return new Chunk(ERRORED, null, error, response);
-}
+function describeValueForErrorMessage(value) {
+  switch (typeof value) {
+    case 'string':
+      {
+        return JSON.stringify(value.length <= 10 ? value : value.slice(0, 10) + '...');
+      }
 
-function wakeChunk(listeners, value) {
-  for (var i = 0; i < listeners.length; i++) {
-    var listener = listeners[i];
-    listener(value);
-  }
-}
+    case 'object':
+      {
+        if (isArray(value)) {
+          return '[...]';
+        }
 
-function wakeChunkIfInitialized(chunk, resolveListeners, rejectListeners) {
-  switch (chunk.status) {
-    case INITIALIZED:
-      wakeChunk(resolveListeners, chunk.value);
-      break;
+        var name = objectName(value);
 
-    case PENDING:
-    case BLOCKED:
-      chunk.value = resolveListeners;
-      chunk.reason = rejectListeners;
-      break;
+        if (name === 'Object') {
+          return '{...}';
+        }
 
-    case ERRORED:
-      if (rejectListeners) {
-        wakeChunk(rejectListeners, chunk.reason);
+        return name;
       }
 
-      break;
+    case 'function':
+      return 'function';
+
+    default:
+      // eslint-disable-next-line react-internal/safe-string-coercion
+      return String(value);
   }
 }
 
-function triggerErrorOnChunk(chunk, error) {
-  if (chunk.status !== PENDING && chunk.status !== BLOCKED) {
-    // We already resolved. We didn't expect to see this.
-    return;
+function describeElementType(type) {
+  if (typeof type === 'string') {
+    return type;
   }
 
-  var listeners = chunk.reason;
-  var erroredChunk = chunk;
-  erroredChunk.status = ERRORED;
-  erroredChunk.reason = error;
+  switch (type) {
+    case REACT_SUSPENSE_TYPE:
+      return 'Suspense';
 
-  if (listeners !== null) {
-    wakeChunk(listeners, error);
-  }
-}
-
-function createResolvedModelChunk(response, value) {
-  // $FlowFixMe[invalid-constructor] Flow doesn't support functions as constructors
-  return new Chunk(RESOLVED_MODEL, value, null, response);
-}
-
-function createResolvedModuleChunk(response, value) {
-  // $FlowFixMe[invalid-constructor] Flow doesn't support functions as constructors
-  return new Chunk(RESOLVED_MODULE, value, null, response);
-}
-
-function resolveModelChunk(chunk, value) {
-  if (chunk.status !== PENDING) {
-    // We already resolved. We didn't expect to see this.
-    return;
+    case REACT_SUSPENSE_LIST_TYPE:
+      return 'SuspenseList';
   }
 
-  var resolveListeners = chunk.value;
-  var rejectListeners = chunk.reason;
-  var resolvedChunk = chunk;
-  resolvedChunk.status = RESOLVED_MODEL;
-  resolvedChunk.value = value;
+  if (typeof type === 'object') {
+    switch (type.$$typeof) {
+      case REACT_FORWARD_REF_TYPE:
+        return describeElementType(type.render);
 
-  if (resolveListeners !== null) {
-    // This is unfortunate that we're reading this eagerly if
-    // we already have listeners attached since they might no
-    // longer be rendered or might not be the highest pri.
-    initializeModelChunk(resolvedChunk); // The status might have changed after initialization.
+      case REACT_MEMO_TYPE:
+        return describeElementType(type.type);
 
-    wakeChunkIfInitialized(chunk, resolveListeners, rejectListeners);
-  }
-}
+      case REACT_LAZY_TYPE:
+        {
+          var lazyComponent = type;
+          var payload = lazyComponent._payload;
+          var init = lazyComponent._init;
 
-function resolveModuleChunk(chunk, value) {
-  if (chunk.status !== PENDING && chunk.status !== BLOCKED) {
-    // We already resolved. We didn't expect to see this.
-    return;
+          try {
+            // Lazy may contain any component type so we recursively resolve it.
+            return describeElementType(init(payload));
+          } catch (x) {}
+        }
+    }
   }
 
-  var resolveListeners = chunk.value;
-  var rejectListeners = chunk.reason;
-  var resolvedChunk = chunk;
-  resolvedChunk.status = RESOLVED_MODULE;
-  resolvedChunk.value = value;
-
-  if (resolveListeners !== null) {
-    initializeModuleChunk(resolvedChunk);
-    wakeChunkIfInitialized(chunk, resolveListeners, rejectListeners);
-  }
+  return '';
 }
 
-var initializingChunk = null;
-var initializingChunkBlockedModel = null;
+function describeObjectForErrorMessage(objectOrArray, expandedName) {
+  var objKind = objectName(objectOrArray);
 
-function initializeModelChunk(chunk) {
-  var prevChunk = initializingChunk;
-  var prevBlocked = initializingChunkBlockedModel;
-  initializingChunk = chunk;
-  initializingChunkBlockedModel = null;
+  if (objKind !== 'Object' && objKind !== 'Array') {
+    return objKind;
+  }
 
-  try {
-    var value = parseModel(chunk._response, chunk.value);
+  var str = '';
+  var start = -1;
+  var length = 0;
 
-    if (initializingChunkBlockedModel !== null && initializingChunkBlockedModel.deps > 0) {
-      initializingChunkBlockedModel.value = value; // We discovered new dependencies on modules that are not yet resolved.
-      // We have to go the BLOCKED state until they're resolved.
+  if (isArray(objectOrArray)) {
+    if (jsxChildrenParents.has(objectOrArray)) {
+      // Print JSX Children
+      var type = jsxChildrenParents.get(objectOrArray);
+      str = '<' + describeElementType(type) + '>';
+      var array = objectOrArray;
 
-      var blockedChunk = chunk;
-      blockedChunk.status = BLOCKED;
-      blockedChunk.value = null;
-      blockedChunk.reason = null;
-    } else {
-      var initializedChunk = chunk;
-      initializedChunk.status = INITIALIZED;
-      initializedChunk.value = value;
-    }
-  } catch (error) {
-    var erroredChunk = chunk;
-    erroredChunk.status = ERRORED;
-    erroredChunk.reason = error;
-  } finally {
-    initializingChunk = prevChunk;
-    initializingChunkBlockedModel = prevBlocked;
-  }
-}
+      for (var i = 0; i < array.length; i++) {
+        var value = array[i];
+        var substr = void 0;
 
-function initializeModuleChunk(chunk) {
-  try {
-    var value = requireModule(chunk.value);
-    var initializedChunk = chunk;
-    initializedChunk.status = INITIALIZED;
-    initializedChunk.value = value;
-  } catch (error) {
-    var erroredChunk = chunk;
-    erroredChunk.status = ERRORED;
-    erroredChunk.reason = error;
-  }
-} // Report that any missing chunks in the model is now going to throw this
-// error upon read. Also notify any pending promises.
+        if (typeof value === 'string') {
+          substr = value;
+        } else if (typeof value === 'object' && value !== null) {
+          // $FlowFixMe[incompatible-call] found when upgrading Flow
+          substr = '{' + describeObjectForErrorMessage(value) + '}';
+        } else {
+          substr = '{' + describeValueForErrorMessage(value) + '}';
+        }
 
+        if ('' + i === expandedName) {
+          start = str.length;
+          length = substr.length;
+          str += substr;
+        } else if (substr.length < 15 && str.length + substr.length < 40) {
+          str += substr;
+        } else {
+          str += '{...}';
+        }
+      }
 
-function reportGlobalError(response, error) {
-  response._chunks.forEach(function (chunk) {
-    // If this chunk was already resolved or errored, it won't
-    // trigger an error but if it wasn't then we need to
-    // because we won't be getting any new data to resolve it.
-    if (chunk.status === PENDING) {
-      triggerErrorOnChunk(chunk, error);
-    }
-  });
-}
+      str += '</' + describeElementType(type) + '>';
+    } else {
+      // Print Array
+      str = '[';
+      var _array = objectOrArray;
 
-function createElement(type, key, props) {
-  var element = {
-    // This tag allows us to uniquely identify this as a React Element
-    $$typeof: REACT_ELEMENT_TYPE,
-    // Built-in properties that belong on the element
-    type: type,
-    key: key,
-    ref: null,
-    props: props,
-    // Record the component responsible for creating this element.
-    _owner: null
-  };
+      for (var _i = 0; _i < _array.length; _i++) {
+        if (_i > 0) {
+          str += ', ';
+        }
 
-  {
-    // We don't really need to add any of these but keeping them for good measure.
-    // Unfortunately, _store is enumerable in jest matchers so for equality to
-    // work, I need to keep it or make _store non-enumerable in the other file.
-    element._store = {};
-    Object.defineProperty(element._store, 'validated', {
-      configurable: false,
-      enumerable: false,
-      writable: true,
-      value: true // This element has already been validated on the server.
+        var _value = _array[_i];
 
-    });
-    Object.defineProperty(element, '_self', {
-      configurable: false,
-      enumerable: false,
-      writable: false,
-      value: null
-    });
-    Object.defineProperty(element, '_source', {
-      configurable: false,
-      enumerable: false,
-      writable: false,
-      value: null
-    });
-  }
+        var _substr = void 0;
 
-  return element;
-}
+        if (typeof _value === 'object' && _value !== null) {
+          // $FlowFixMe[incompatible-call] found when upgrading Flow
+          _substr = describeObjectForErrorMessage(_value);
+        } else {
+          _substr = describeValueForErrorMessage(_value);
+        }
 
-function createLazyChunkWrapper(chunk) {
-  var lazyType = {
-    $$typeof: REACT_LAZY_TYPE,
-    _payload: chunk,
-    _init: readChunk
-  };
-  return lazyType;
-}
+        if ('' + _i === expandedName) {
+          start = str.length;
+          length = _substr.length;
+          str += _substr;
+        } else if (_substr.length < 10 && str.length + _substr.length < 40) {
+          str += _substr;
+        } else {
+          str += '...';
+        }
+      }
 
-function getChunk(response, id) {
-  var chunks = response._chunks;
-  var chunk = chunks.get(id);
+      str += ']';
+    }
+  } else {
+    if (objectOrArray.$$typeof === REACT_ELEMENT_TYPE) {
+      str = '<' + describeElementType(objectOrArray.type) + '/>';
+    } else if (jsxPropsParents.has(objectOrArray)) {
+      // Print JSX
+      var _type = jsxPropsParents.get(objectOrArray);
 
-  if (!chunk) {
-    chunk = createPendingChunk(response);
-    chunks.set(id, chunk);
-  }
+      str = '<' + (describeElementType(_type) || '...');
+      var object = objectOrArray;
+      var names = Object.keys(object);
 
-  return chunk;
-}
+      for (var _i2 = 0; _i2 < names.length; _i2++) {
+        str += ' ';
+        var name = names[_i2];
+        str += describeKeyForErrorMessage(name) + '=';
+        var _value2 = object[name];
 
-function createModelResolver(chunk, parentObject, key) {
-  var blocked;
+        var _substr2 = void 0;
 
-  if (initializingChunkBlockedModel) {
-    blocked = initializingChunkBlockedModel;
-    blocked.deps++;
-  } else {
-    blocked = initializingChunkBlockedModel = {
-      deps: 1,
-      value: null
-    };
-  }
+        if (name === expandedName && typeof _value2 === 'object' && _value2 !== null) {
+          // $FlowFixMe[incompatible-call] found when upgrading Flow
+          _substr2 = describeObjectForErrorMessage(_value2);
+        } else {
+          _substr2 = describeValueForErrorMessage(_value2);
+        }
 
-  return function (value) {
-    parentObject[key] = value;
-    blocked.deps--;
+        if (typeof _value2 !== 'string') {
+          _substr2 = '{' + _substr2 + '}';
+        }
 
-    if (blocked.deps === 0) {
-      if (chunk.status !== BLOCKED) {
-        return;
+        if (name === expandedName) {
+          start = str.length;
+          length = _substr2.length;
+          str += _substr2;
+        } else if (_substr2.length < 10 && str.length + _substr2.length < 40) {
+          str += _substr2;
+        } else {
+          str += '...';
+        }
       }
 
-      var resolveListeners = chunk.value;
-      var initializedChunk = chunk;
-      initializedChunk.status = INITIALIZED;
-      initializedChunk.value = blocked.value;
-
-      if (resolveListeners !== null) {
-        wakeChunk(resolveListeners, blocked.value);
-      }
-    }
-  };
-}
+      str += '>';
+    } else {
+      // Print Object
+      str = '{';
+      var _object = objectOrArray;
 
-function createModelReject(chunk) {
-  return function (error) {
-    return triggerErrorOnChunk(chunk, error);
-  };
-}
+      var _names = Object.keys(_object);
 
-function createServerReferenceProxy(response, metaData) {
-  var callServer = response._callServer;
+      for (var _i3 = 0; _i3 < _names.length; _i3++) {
+        if (_i3 > 0) {
+          str += ', ';
+        }
 
-  var proxy = function () {
-    // $FlowFixMe[method-unbinding]
-    var args = Array.prototype.slice.call(arguments);
-    var p = metaData.bound;
+        var _name = _names[_i3];
+        str += describeKeyForErrorMessage(_name) + ': ';
+        var _value3 = _object[_name];
 
-    if (!p) {
-      return callServer(metaData.id, args);
-    }
+        var _substr3 = void 0;
 
-    if (p.status === INITIALIZED) {
-      var bound = p.value;
-      return callServer(metaData.id, bound.concat(args));
-    } // Since this is a fake Promise whose .then doesn't chain, we have to wrap it.
-    // TODO: Remove the wrapper once that's fixed.
+        if (typeof _value3 === 'object' && _value3 !== null) {
+          // $FlowFixMe[incompatible-call] found when upgrading Flow
+          _substr3 = describeObjectForErrorMessage(_value3);
+        } else {
+          _substr3 = describeValueForErrorMessage(_value3);
+        }
 
+        if (_name === expandedName) {
+          start = str.length;
+          length = _substr3.length;
+          str += _substr3;
+        } else if (_substr3.length < 10 && str.length + _substr3.length < 40) {
+          str += _substr3;
+        } else {
+          str += '...';
+        }
+      }
 
-    return Promise.resolve(p).then(function (bound) {
-      return callServer(metaData.id, bound.concat(args));
-    });
-  };
+      str += '}';
+    }
+  }
 
-  knownServerReferences.set(proxy, metaData);
-  return proxy;
-}
+  if (expandedName === undefined) {
+    return str;
+  }
 
-function parseModelString(response, parentObject, key, value) {
-  if (value[0] === '$') {
-    if (value === '$') {
-      // A very common symbol.
-      return REACT_ELEMENT_TYPE;
-    }
+  if (start > -1 && length > 0) {
+    var highlight = ' '.repeat(start) + '^'.repeat(length);
+    return '\n  ' + str + '\n  ' + highlight;
+  }
 
-    switch (value[1]) {
-      case '$':
-        {
-          // This was an escaped string value.
-          return value.slice(1);
-        }
+  return '\n  ' + str;
+}
 
-      case 'L':
-        {
-          // Lazy node
-          var id = parseInt(value.slice(2), 16);
-          var chunk = getChunk(response, id); // We create a React.lazy wrapper around any lazy values.
-          // When passed into React, we'll know how to suspend on this.
+var knownServerReferences = new WeakMap(); // Serializable values
+// Thenable<ReactServerValue>
+// function serializeByValueID(id: number): string {
+//   return '$' + id.toString(16);
+// }
 
-          return createLazyChunkWrapper(chunk);
-        }
+function serializePromiseID(id) {
+  return '$@' + id.toString(16);
+}
 
-      case '@':
-        {
-          // Promise
-          var _id = parseInt(value.slice(2), 16);
+function serializeServerReferenceID(id) {
+  return '$F' + id.toString(16);
+}
 
-          var _chunk = getChunk(response, _id);
+function serializeSymbolReference(name) {
+  return '$S' + name;
+}
 
-          return _chunk;
-        }
+function serializeFormDataReference(id) {
+  // Why K? F is "Function". D is "Date". What else?
+  return '$K' + id.toString(16);
+}
 
-      case 'S':
-        {
-          // Symbol
-          return Symbol.for(value.slice(2));
-        }
+function serializeNumber(number) {
+  if (Number.isFinite(number)) {
+    if (number === 0 && 1 / number === -Infinity) {
+      return '$-0';
+    } else {
+      return number;
+    }
+  } else {
+    if (number === Infinity) {
+      return '$Infinity';
+    } else if (number === -Infinity) {
+      return '$-Infinity';
+    } else {
+      return '$NaN';
+    }
+  }
+}
 
-      case 'P':
-        {
-          // Server Context Provider
-          return getOrCreateServerContext(value.slice(2)).Provider;
-        }
+function serializeUndefined() {
+  return '$undefined';
+}
 
-      case 'F':
-        {
-          // Server Reference
-          var _id2 = parseInt(value.slice(2), 16);
+function serializeDateFromDateJSON(dateJSON) {
+  // JSON.stringify automatically calls Date.prototype.toJSON which calls toISOString.
+  // We need only tack on a $D prefix.
+  return '$D' + dateJSON;
+}
 
-          var _chunk2 = getChunk(response, _id2);
+function serializeBigInt(n) {
+  return '$n' + n.toString(10);
+}
 
-          switch (_chunk2.status) {
-            case RESOLVED_MODEL:
-              initializeModelChunk(_chunk2);
-              break;
-          } // The status might have changed after initialization.
+function escapeStringValue(value) {
+  if (value[0] === '$') {
+    // We need to escape $ prefixed strings since we use those to encode
+    // references to IDs and as special symbol values.
+    return '$' + value;
+  } else {
+    return value;
+  }
+}
 
+function processReply(root, formFieldPrefix, resolve, reject) {
+  var nextPartId = 1;
+  var pendingParts = 0;
+  var formData = null;
 
-          switch (_chunk2.status) {
-            case INITIALIZED:
-              {
-                var metadata = _chunk2.value;
-                return createServerReferenceProxy(response, metadata);
-              }
-            // We always encode it first in the stream so it won't be pending.
+  function resolveToJSON(key, value) {
+    var parent = this; // Make sure that `parent[key]` wasn't JSONified before `value` was passed to us
 
-            default:
-              throw _chunk2.reason;
-          }
-        }
+    {
+      // $FlowFixMe[incompatible-use]
+      var originalValue = parent[key];
 
-      case 'I':
-        {
-          // $Infinity
-          return Infinity;
+      if (typeof originalValue === 'object' && originalValue !== value && !(originalValue instanceof Date)) {
+        if (objectName(originalValue) !== 'Object') {
+          error('Only plain objects can be passed to Server Functions from the Client. ' + '%s objects are not supported.%s', objectName(originalValue), describeObjectForErrorMessage(parent, key));
+        } else {
+          error('Only plain objects can be passed to Server Functions from the Client. ' + 'Objects with toJSON methods are not supported. Convert it manually ' + 'to a simple value before passing it to props.%s', describeObjectForErrorMessage(parent, key));
         }
+      }
+    }
 
-      case '-':
-        {
-          // $-0 or $-Infinity
-          if (value === '$-0') {
-            return -0;
-          } else {
-            return -Infinity;
-          }
-        }
+    if (value === null) {
+      return null;
+    }
 
-      case 'N':
-        {
-          // $NaN
-          return NaN;
+    if (typeof value === 'object') {
+      // $FlowFixMe[method-unbinding]
+      if (typeof value.then === 'function') {
+        // We assume that any object with a .then property is a "Thenable" type,
+        // or a Promise type. Either of which can be represented by a Promise.
+        if (formData === null) {
+          // Upgrade to use FormData to allow us to stream this value.
+          formData = new FormData();
         }
 
-      case 'u':
-        {
-          // matches "$undefined"
-          // Special encoding for `undefined` which can't be serialized as JSON otherwise.
-          return undefined;
-        }
+        pendingParts++;
+        var promiseId = nextPartId++;
+        var thenable = value;
+        thenable.then(function (partValue) {
+          var partJSON = JSON.stringify(partValue, resolveToJSON); // $FlowFixMe[incompatible-type] We know it's not null because we assigned it above.
 
-      case 'D':
-        {
-          // Date
-          return new Date(Date.parse(value.slice(2)));
-        }
+          var data = formData; // eslint-disable-next-line react-internal/safe-string-coercion
 
-      case 'n':
-        {
-          // BigInt
-          return BigInt(value.slice(2));
-        }
+          data.append(formFieldPrefix + promiseId, partJSON);
+          pendingParts--;
 
-      default:
-        {
-          // We assume that anything else is a reference ID.
-          var _id3 = parseInt(value.slice(1), 16);
+          if (pendingParts === 0) {
+            resolve(data);
+          }
+        }, function (reason) {
+          // In the future we could consider serializing this as an error
+          // that throws on the server instead.
+          reject(reason);
+        });
+        return serializePromiseID(promiseId);
+      } // TODO: Should we the Object.prototype.toString.call() to test for cross-realm objects?
 
-          var _chunk3 = getChunk(response, _id3);
 
-          switch (_chunk3.status) {
-            case RESOLVED_MODEL:
-              initializeModelChunk(_chunk3);
-              break;
+      if (value instanceof FormData) {
+        if (formData === null) {
+          // Upgrade to use FormData to allow us to use rich objects as its values.
+          formData = new FormData();
+        }
 
-            case RESOLVED_MODULE:
-              initializeModuleChunk(_chunk3);
-              break;
-          } // The status might have changed after initialization.
+        var data = formData;
+        var refId = nextPartId++; // Copy all the form fields with a prefix for this reference.
+        // These must come first in the form order because we assume that all the
+        // fields are available before this is referenced.
 
+        var prefix = formFieldPrefix + refId + '_'; // $FlowFixMe[prop-missing]: FormData has forEach.
 
-          switch (_chunk3.status) {
-            case INITIALIZED:
-              return _chunk3.value;
+        value.forEach(function (originalValue, originalKey) {
+          data.append(prefix + originalKey, originalValue);
+        });
+        return serializeFormDataReference(refId);
+      }
 
-            case PENDING:
-            case BLOCKED:
-              var parentChunk = initializingChunk;
+      if (!isArray(value)) {
+        var iteratorFn = getIteratorFn(value);
 
-              _chunk3.then(createModelResolver(parentChunk, parentObject, key), createModelReject(parentChunk));
+        if (iteratorFn) {
+          return Array.from(value);
+        }
+      }
 
-              return null;
+      {
+        if (value !== null && !isArray(value)) {
+          // Verify that this is a simple plain object.
+          if (value.$$typeof === REACT_ELEMENT_TYPE) {
+            error('React Element cannot be passed to Server Functions from the Client.%s', describeObjectForErrorMessage(parent, key));
+          } else if (value.$$typeof === REACT_LAZY_TYPE) {
+            error('React Lazy cannot be passed to Server Functions from the Client.%s', describeObjectForErrorMessage(parent, key));
+          } else if (value.$$typeof === REACT_PROVIDER_TYPE) {
+            error('React Context Providers cannot be passed to Server Functions from the Client.%s', describeObjectForErrorMessage(parent, key));
+          } else if (objectName(value) !== 'Object') {
+            error('Only plain objects can be passed to Client Components from Server Components. ' + '%s objects are not supported.%s', objectName(value), describeObjectForErrorMessage(parent, key));
+          } else if (!isSimpleObject(value)) {
+            error('Only plain objects can be passed to Client Components from Server Components. ' + 'Classes or other objects with methods are not supported.%s', describeObjectForErrorMessage(parent, key));
+          } else if (Object.getOwnPropertySymbols) {
+            var symbols = Object.getOwnPropertySymbols(value);
 
-            default:
-              throw _chunk3.reason;
+            if (symbols.length > 0) {
+              error('Only plain objects can be passed to Client Components from Server Components. ' + 'Objects with symbol properties like %s are not supported.%s', symbols[0].description, describeObjectForErrorMessage(parent, key));
+            }
           }
         }
-    }
-  }
-
-  return value;
-}
-function parseModelTuple(response, value) {
-  var tuple = value;
-
-  if (tuple[0] === REACT_ELEMENT_TYPE) {
-    // TODO: Consider having React just directly accept these arrays as elements.
-    // Or even change the ReactElement type to be an array.
-    return createElement(tuple[1], tuple[2], tuple[3]);
-  }
+      } // $FlowFixMe[incompatible-return]
 
-  return value;
-}
 
-function missingCall() {
-  throw new Error('Trying to call a function from "use server" but the callServer option ' + 'was not implemented in your router runtime.');
-}
+      return value;
+    }
 
-function createResponse$1(bundlerConfig, callServer) {
-  var chunks = new Map();
-  var response = {
-    _bundlerConfig: bundlerConfig,
-    _callServer: callServer !== undefined ? callServer : missingCall,
-    _chunks: chunks
-  };
-  return response;
-}
-function resolveModel(response, id, model) {
-  var chunks = response._chunks;
-  var chunk = chunks.get(id);
+    if (typeof value === 'string') {
+      // TODO: Maybe too clever. If we support URL there's no similar trick.
+      if (value[value.length - 1] === 'Z') {
+        // Possibly a Date, whose toJSON automatically calls toISOString
+        // $FlowFixMe[incompatible-use]
+        var _originalValue = parent[key]; // $FlowFixMe[method-unbinding]
 
-  if (!chunk) {
-    chunks.set(id, createResolvedModelChunk(response, model));
-  } else {
-    resolveModelChunk(chunk, model);
-  }
-}
-function resolveModule(response, id, model) {
-  var chunks = response._chunks;
-  var chunk = chunks.get(id);
-  var clientReferenceMetadata = parseModel(response, model);
-  var clientReference = resolveClientReference(response._bundlerConfig, clientReferenceMetadata); // TODO: Add an option to encode modules that are lazy loaded.
-  // For now we preload all modules as early as possible since it's likely
-  // that we'll need them.
+        if (_originalValue instanceof Date) {
+          return serializeDateFromDateJSON(value);
+        }
+      }
 
-  var promise = preloadModule(clientReference);
+      return escapeStringValue(value);
+    }
 
-  if (promise) {
-    var blockedChunk;
+    if (typeof value === 'boolean') {
+      return value;
+    }
 
-    if (!chunk) {
-      // Technically, we should just treat promise as the chunk in this
-      // case. Because it'll just behave as any other promise.
-      blockedChunk = createBlockedChunk(response);
-      chunks.set(id, blockedChunk);
-    } else {
-      // This can't actually happen because we don't have any forward
-      // references to modules.
-      blockedChunk = chunk;
-      blockedChunk.status = BLOCKED;
+    if (typeof value === 'number') {
+      return serializeNumber(value);
     }
 
-    promise.then(function () {
-      return resolveModuleChunk(blockedChunk, clientReference);
-    }, function (error) {
-      return triggerErrorOnChunk(blockedChunk, error);
-    });
-  } else {
-    if (!chunk) {
-      chunks.set(id, createResolvedModuleChunk(response, clientReference));
-    } else {
-      // This can't actually happen because we don't have any forward
-      // references to modules.
-      resolveModuleChunk(chunk, clientReference);
+    if (typeof value === 'undefined') {
+      return serializeUndefined();
     }
-  }
-}
-function resolveErrorDev(response, id, digest, message, stack) {
 
+    if (typeof value === 'function') {
+      var metaData = knownServerReferences.get(value);
 
-  var error = new Error(message || 'An error occurred in the Server Components render but no message was provided');
-  error.stack = stack;
-  error.digest = digest;
-  var errorWithDigest = error;
-  var chunks = response._chunks;
-  var chunk = chunks.get(id);
+      if (metaData !== undefined) {
+        var metaDataJSON = JSON.stringify(metaData, resolveToJSON);
 
-  if (!chunk) {
-    chunks.set(id, createErrorChunk(response, errorWithDigest));
-  } else {
-    triggerErrorOnChunk(chunk, errorWithDigest);
-  }
-}
-function resolveHint(response, code, model) {
-  var hintModel = parseModel(response, model);
-  dispatchHint(code, hintModel);
-}
-function close(response) {
-  // In case there are any remaining unresolved chunks, they won't
-  // be resolved now. So we need to issue an error to those.
-  // Ideally we should be able to early bail out if we kept a
-  // ref count of pending chunks.
-  reportGlobalError(response, new Error('Connection closed.'));
-}
+        if (formData === null) {
+          // Upgrade to use FormData to allow us to stream this value.
+          formData = new FormData();
+        } // The reference to this function came from the same client so we can pass it back.
 
-function processFullRow(response, row) {
-  if (row === '') {
-    return;
-  }
 
-  var colon = row.indexOf(':', 0);
-  var id = parseInt(row.slice(0, colon), 16);
-  var tag = row[colon + 1]; // When tags that are not text are added, check them here before
-  // parsing the row as text.
-  // switch (tag) {
-  // }
+        var _refId = nextPartId++; // eslint-disable-next-line react-internal/safe-string-coercion
 
-  switch (tag) {
-    case 'I':
-      {
-        resolveModule(response, id, row.slice(colon + 2));
-        return;
-      }
 
-    case 'H':
-      {
-        var code = row[colon + 2];
-        resolveHint(response, code, row.slice(colon + 3));
-        return;
+        formData.set(formFieldPrefix + _refId, metaDataJSON);
+        return serializeServerReferenceID(_refId);
       }
 
-    case 'E':
-      {
-        var errorInfo = JSON.parse(row.slice(colon + 2));
+      throw new Error('Client Functions cannot be passed directly to Server Functions. ' + 'Only Functions passed from the Server can be passed back again.');
+    }
 
-        {
-          resolveErrorDev(response, id, errorInfo.digest, errorInfo.message, errorInfo.stack);
-        }
+    if (typeof value === 'symbol') {
+      // $FlowFixMe[incompatible-type] `description` might be undefined
+      var name = value.description;
 
-        return;
+      if (Symbol.for(name) !== value) {
+        throw new Error('Only global symbols received from Symbol.for(...) can be passed to Server Functions. ' + ("The symbol Symbol.for(" + // $FlowFixMe[incompatible-type] `description` might be undefined
+        value.description + ") cannot be found among global symbols."));
       }
 
-    default:
-      {
-        // We assume anything else is JSON.
-        resolveModel(response, id, row.slice(colon + 1));
-        return;
-      }
-  }
-}
+      return serializeSymbolReference(name);
+    }
 
-function processStringChunk(response, chunk, offset) {
-  var linebreak = chunk.indexOf('\n', offset);
+    if (typeof value === 'bigint') {
+      return serializeBigInt(value);
+    }
 
-  while (linebreak > -1) {
-    var fullrow = response._partialRow + chunk.slice(offset, linebreak);
-    processFullRow(response, fullrow);
-    response._partialRow = '';
-    offset = linebreak + 1;
-    linebreak = chunk.indexOf('\n', offset);
-  }
+    throw new Error("Type " + typeof value + " is not supported as an argument to a Server Function.");
+  } // $FlowFixMe[incompatible-type] it's not going to be undefined because we'll encode it.
 
-  response._partialRow += chunk.slice(offset);
-}
-function processBinaryChunk(response, chunk) {
 
-  var stringDecoder = response._stringDecoder;
-  var linebreak = chunk.indexOf(10); // newline
+  var json = JSON.stringify(root, resolveToJSON);
 
-  while (linebreak > -1) {
-    var fullrow = response._partialRow + readFinalStringChunk(stringDecoder, chunk.subarray(0, linebreak));
-    processFullRow(response, fullrow);
-    response._partialRow = '';
-    chunk = chunk.subarray(linebreak + 1);
-    linebreak = chunk.indexOf(10); // newline
-  }
+  if (formData === null) {
+    // If it's a simple data structure, we just use plain JSON.
+    resolve(json);
+  } else {
+    // Otherwise, we use FormData to let us stream in the result.
+    formData.set(formFieldPrefix + '0', json);
 
-  response._partialRow += readPartialStringChunk(stringDecoder, chunk);
+    if (pendingParts === 0) {
+      // $FlowFixMe[incompatible-call] this has already been refined.
+      resolve(formData);
+    }
+  }
 }
+var boundCache = new WeakMap();
 
-function createFromJSONCallback(response) {
-  // $FlowFixMe[missing-this-annot]
-  return function (key, value) {
-    if (typeof value === 'string') {
-      // We can't use .bind here because we need the "this" value.
-      return parseModelString(response, this, key, value);
-    }
+function encodeFormData(reference) {
+  var resolve, reject; // We need to have a handle on the thenable so that we can synchronously set
+  // its status from processReply, when it can complete synchronously.
 
-    if (typeof value === 'object' && value !== null) {
-      return parseModelTuple(response, value);
+  var thenable = new Promise(function (res, rej) {
+    resolve = res;
+    reject = rej;
+  });
+  processReply(reference, '', function (body) {
+    if (typeof body === 'string') {
+      var data = new FormData();
+      data.append('0', body);
+      body = data;
     }
 
-    return value;
-  };
+    var fulfilled = thenable;
+    fulfilled.status = 'fulfilled';
+    fulfilled.value = body;
+    resolve(body);
+  }, function (e) {
+    var rejected = thenable;
+    rejected.status = 'rejected';
+    rejected.reason = e;
+    reject(e);
+  });
+  return thenable;
 }
 
-function createResponse(bundlerConfig, callServer) {
-  // NOTE: CHECK THE COMPILER OUTPUT EACH TIME YOU CHANGE THIS.
-  // It should be inlined to one object literal but minor changes can break it.
-  var stringDecoder = createStringDecoder() ;
-  var response = createResponse$1(bundlerConfig, callServer);
-  response._partialRow = '';
-
-  {
-    response._stringDecoder = stringDecoder;
-  } // Don't inline this call because it causes closure to outline the call above.
+function encodeFormAction(identifierPrefix) {
+  var reference = knownServerReferences.get(this);
 
+  if (!reference) {
+    throw new Error('Tried to encode a Server Action from a different instance than the encoder is from. ' + 'This is a bug in React.');
+  }
 
-  response._fromJSON = createFromJSONCallback(response);
-  return response;
-}
+  var data = null;
+  var name;
+  var boundPromise = reference.bound;
 
-function error(format) {
-  {
-    {
-      for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
-        args[_key2 - 1] = arguments[_key2];
-      }
+  if (boundPromise !== null) {
+    var thenable = boundCache.get(reference);
 
-      printWarning('error', format, args);
+    if (!thenable) {
+      thenable = encodeFormData(reference);
+      boundCache.set(reference, thenable);
     }
-  }
-}
-
-function printWarning(level, format, args) {
-  // When changing this logic, you might want to also
-  // update consoleWithStackDev.www.js as well.
-  {
-    var ReactDebugCurrentFrame = ReactSharedInternals.ReactDebugCurrentFrame;
-    var stack = ReactDebugCurrentFrame.getStackAddendum();
 
-    if (stack !== '') {
-      format += '%s';
-      args = args.concat([stack]);
-    } // eslint-disable-next-line react-internal/safe-string-coercion
+    if (thenable.status === 'rejected') {
+      throw thenable.reason;
+    } else if (thenable.status !== 'fulfilled') {
+      throw thenable;
+    }
 
+    var encodedFormData = thenable.value; // This is hacky but we need the identifier prefix to be added to
+    // all fields but the suspense cache would break since we might get
+    // a new identifier each time. So we just append it at the end instead.
 
-    var argsWithFormat = args.map(function (item) {
-      return String(item);
-    }); // Careful: RN currently depends on this prefix
+    var prefixedData = new FormData(); // $FlowFixMe[prop-missing]
 
-    argsWithFormat.unshift('Warning: ' + format); // We intentionally don't use spread (or .apply) directly because it
-    // breaks IE9: https://github.com/facebook/react/issues/13610
-    // eslint-disable-next-line react-internal/no-production-logging
+    encodedFormData.forEach(function (value, key) {
+      prefixedData.append('$ACTION_' + identifierPrefix + ':' + key, value);
+    });
+    data = prefixedData; // We encode the name of the prefix containing the data.
 
-    Function.prototype.apply.call(console[level], console, argsWithFormat);
+    name = '$ACTION_REF_' + identifierPrefix;
+  } else {
+    // This is the simple case so we can just encode the ID.
+    name = '$ACTION_ID_' + reference.id;
   }
-}
-
-var isArrayImpl = Array.isArray; // eslint-disable-next-line no-redeclare
 
-function isArray(a) {
-  return isArrayImpl(a);
+  return {
+    name: name,
+    method: 'POST',
+    encType: 'multipart/form-data',
+    data: data
+  };
 }
+function createServerReference(id, callServer) {
+  var proxy = function () {
+    // $FlowFixMe[method-unbinding]
+    var args = Array.prototype.slice.call(arguments);
+    return callServer(id, args);
+  }; // Expose encoder for use by SSR.
+  // TODO: Only expose this in SSR builds and not the browser client.
 
-// in case they error.
 
-var jsxPropsParents = new WeakMap();
-var jsxChildrenParents = new WeakMap();
+  proxy.$$FORM_ACTION = encodeFormAction;
+  knownServerReferences.set(proxy, {
+    id: id,
+    bound: null
+  });
+  return proxy;
+}
 
-function isObjectPrototype(object) {
-  if (!object) {
-    return false;
+var ContextRegistry = ReactSharedInternals.ContextRegistry;
+function getOrCreateServerContext(globalName) {
+  if (!ContextRegistry[globalName]) {
+    ContextRegistry[globalName] = React.createServerContext(globalName, // $FlowFixMe[incompatible-call] function signature doesn't reflect the symbol value
+    REACT_SERVER_CONTEXT_DEFAULT_VALUE_NOT_LOADED);
   }
 
-  var ObjectPrototype = Object.prototype;
+  return ContextRegistry[globalName];
+}
 
-  if (object === ObjectPrototype) {
-    return true;
-  } // It might be an object from a different Realm which is
-  // still just a plain simple object.
+var PENDING = 'pending';
+var BLOCKED = 'blocked';
+var RESOLVED_MODEL = 'resolved_model';
+var RESOLVED_MODULE = 'resolved_module';
+var INITIALIZED = 'fulfilled';
+var ERRORED = 'rejected'; // $FlowFixMe[missing-this-annot]
 
+function Chunk(status, value, reason, response) {
+  this.status = status;
+  this.value = value;
+  this.reason = reason;
+  this._response = response;
+} // We subclass Promise.prototype so that we get other methods like .catch
 
-  if (Object.getPrototypeOf(object)) {
-    return false;
-  }
 
-  var names = Object.getOwnPropertyNames(object);
+Chunk.prototype = Object.create(Promise.prototype); // TODO: This doesn't return a new Promise chain unlike the real .then
 
-  for (var i = 0; i < names.length; i++) {
-    if (!(names[i] in ObjectPrototype)) {
-      return false;
-    }
-  }
+Chunk.prototype.then = function (resolve, reject) {
+  var chunk = this; // If we have resolved content, we try to initialize it first which
+  // might put us back into one of the other states.
 
-  return true;
-}
+  switch (chunk.status) {
+    case RESOLVED_MODEL:
+      initializeModelChunk(chunk);
+      break;
 
-function isSimpleObject(object) {
-  if (!isObjectPrototype(Object.getPrototypeOf(object))) {
-    return false;
-  }
+    case RESOLVED_MODULE:
+      initializeModuleChunk(chunk);
+      break;
+  } // The status might have changed after initialization.
 
-  var names = Object.getOwnPropertyNames(object);
 
-  for (var i = 0; i < names.length; i++) {
-    var descriptor = Object.getOwnPropertyDescriptor(object, names[i]);
+  switch (chunk.status) {
+    case INITIALIZED:
+      resolve(chunk.value);
+      break;
 
-    if (!descriptor) {
-      return false;
-    }
+    case PENDING:
+    case BLOCKED:
+      if (resolve) {
+        if (chunk.value === null) {
+          chunk.value = [];
+        }
 
-    if (!descriptor.enumerable) {
-      if ((names[i] === 'key' || names[i] === 'ref') && typeof descriptor.get === 'function') {
-        // React adds key and ref getters to props objects to issue warnings.
-        // Those getters will not be transferred to the client, but that's ok,
-        // so we'll special case them.
-        continue;
+        chunk.value.push(resolve);
       }
 
-      return false;
-    }
-  }
+      if (reject) {
+        if (chunk.reason === null) {
+          chunk.reason = [];
+        }
 
-  return true;
-}
-function objectName(object) {
-  // $FlowFixMe[method-unbinding]
-  var name = Object.prototype.toString.call(object);
-  return name.replace(/^\[object (.*)\]$/, function (m, p0) {
-    return p0;
-  });
-}
+        chunk.reason.push(reject);
+      }
 
-function describeKeyForErrorMessage(key) {
-  var encodedKey = JSON.stringify(key);
-  return '"' + key + '"' === encodedKey ? key : encodedKey;
-}
+      break;
 
-function describeValueForErrorMessage(value) {
-  switch (typeof value) {
-    case 'string':
-      {
-        return JSON.stringify(value.length <= 10 ? value : value.slice(0, 10) + '...');
-      }
+    default:
+      reject(chunk.reason);
+      break;
+  }
+};
 
-    case 'object':
-      {
-        if (isArray(value)) {
-          return '[...]';
-        }
+function readChunk(chunk) {
+  // If we have resolved content, we try to initialize it first which
+  // might put us back into one of the other states.
+  switch (chunk.status) {
+    case RESOLVED_MODEL:
+      initializeModelChunk(chunk);
+      break;
 
-        var name = objectName(value);
+    case RESOLVED_MODULE:
+      initializeModuleChunk(chunk);
+      break;
+  } // The status might have changed after initialization.
 
-        if (name === 'Object') {
-          return '{...}';
-        }
 
-        return name;
-      }
+  switch (chunk.status) {
+    case INITIALIZED:
+      return chunk.value;
 
-    case 'function':
-      return 'function';
+    case PENDING:
+    case BLOCKED:
+      // eslint-disable-next-line no-throw-literal
+      throw chunk;
 
     default:
-      // eslint-disable-next-line react-internal/safe-string-coercion
-      return String(value);
+      throw chunk.reason;
   }
 }
 
-function describeElementType(type) {
-  if (typeof type === 'string') {
-    return type;
-  }
+function getRoot(response) {
+  var chunk = getChunk(response, 0);
+  return chunk;
+}
 
-  switch (type) {
-    case REACT_SUSPENSE_TYPE:
-      return 'Suspense';
+function createPendingChunk(response) {
+  // $FlowFixMe[invalid-constructor] Flow doesn't support functions as constructors
+  return new Chunk(PENDING, null, null, response);
+}
 
-    case REACT_SUSPENSE_LIST_TYPE:
-      return 'SuspenseList';
+function createBlockedChunk(response) {
+  // $FlowFixMe[invalid-constructor] Flow doesn't support functions as constructors
+  return new Chunk(BLOCKED, null, null, response);
+}
+
+function createErrorChunk(response, error) {
+  // $FlowFixMe[invalid-constructor] Flow doesn't support functions as constructors
+  return new Chunk(ERRORED, null, error, response);
+}
+
+function wakeChunk(listeners, value) {
+  for (var i = 0; i < listeners.length; i++) {
+    var listener = listeners[i];
+    listener(value);
   }
+}
 
-  if (typeof type === 'object') {
-    switch (type.$$typeof) {
-      case REACT_FORWARD_REF_TYPE:
-        return describeElementType(type.render);
+function wakeChunkIfInitialized(chunk, resolveListeners, rejectListeners) {
+  switch (chunk.status) {
+    case INITIALIZED:
+      wakeChunk(resolveListeners, chunk.value);
+      break;
 
-      case REACT_MEMO_TYPE:
-        return describeElementType(type.type);
+    case PENDING:
+    case BLOCKED:
+      chunk.value = resolveListeners;
+      chunk.reason = rejectListeners;
+      break;
 
-      case REACT_LAZY_TYPE:
-        {
-          var lazyComponent = type;
-          var payload = lazyComponent._payload;
-          var init = lazyComponent._init;
+    case ERRORED:
+      if (rejectListeners) {
+        wakeChunk(rejectListeners, chunk.reason);
+      }
 
-          try {
-            // Lazy may contain any component type so we recursively resolve it.
-            return describeElementType(init(payload));
-          } catch (x) {}
-        }
-    }
+      break;
   }
-
-  return '';
 }
 
-function describeObjectForErrorMessage(objectOrArray, expandedName) {
-  var objKind = objectName(objectOrArray);
-
-  if (objKind !== 'Object' && objKind !== 'Array') {
-    return objKind;
+function triggerErrorOnChunk(chunk, error) {
+  if (chunk.status !== PENDING && chunk.status !== BLOCKED) {
+    // We already resolved. We didn't expect to see this.
+    return;
   }
 
-  var str = '';
-  var start = -1;
-  var length = 0;
+  var listeners = chunk.reason;
+  var erroredChunk = chunk;
+  erroredChunk.status = ERRORED;
+  erroredChunk.reason = error;
 
-  if (isArray(objectOrArray)) {
-    if (jsxChildrenParents.has(objectOrArray)) {
-      // Print JSX Children
-      var type = jsxChildrenParents.get(objectOrArray);
-      str = '<' + describeElementType(type) + '>';
-      var array = objectOrArray;
+  if (listeners !== null) {
+    wakeChunk(listeners, error);
+  }
+}
 
-      for (var i = 0; i < array.length; i++) {
-        var value = array[i];
-        var substr = void 0;
+function createResolvedModelChunk(response, value) {
+  // $FlowFixMe[invalid-constructor] Flow doesn't support functions as constructors
+  return new Chunk(RESOLVED_MODEL, value, null, response);
+}
 
-        if (typeof value === 'string') {
-          substr = value;
-        } else if (typeof value === 'object' && value !== null) {
-          // $FlowFixMe[incompatible-call] found when upgrading Flow
-          substr = '{' + describeObjectForErrorMessage(value) + '}';
-        } else {
-          substr = '{' + describeValueForErrorMessage(value) + '}';
-        }
+function createResolvedModuleChunk(response, value) {
+  // $FlowFixMe[invalid-constructor] Flow doesn't support functions as constructors
+  return new Chunk(RESOLVED_MODULE, value, null, response);
+}
 
-        if ('' + i === expandedName) {
-          start = str.length;
-          length = substr.length;
-          str += substr;
-        } else if (substr.length < 15 && str.length + substr.length < 40) {
-          str += substr;
-        } else {
-          str += '{...}';
-        }
-      }
+function resolveModelChunk(chunk, value) {
+  if (chunk.status !== PENDING) {
+    // We already resolved. We didn't expect to see this.
+    return;
+  }
 
-      str += '</' + describeElementType(type) + '>';
-    } else {
-      // Print Array
-      str = '[';
-      var _array = objectOrArray;
+  var resolveListeners = chunk.value;
+  var rejectListeners = chunk.reason;
+  var resolvedChunk = chunk;
+  resolvedChunk.status = RESOLVED_MODEL;
+  resolvedChunk.value = value;
 
-      for (var _i = 0; _i < _array.length; _i++) {
-        if (_i > 0) {
-          str += ', ';
-        }
+  if (resolveListeners !== null) {
+    // This is unfortunate that we're reading this eagerly if
+    // we already have listeners attached since they might no
+    // longer be rendered or might not be the highest pri.
+    initializeModelChunk(resolvedChunk); // The status might have changed after initialization.
 
-        var _value = _array[_i];
+    wakeChunkIfInitialized(chunk, resolveListeners, rejectListeners);
+  }
+}
 
-        var _substr = void 0;
+function resolveModuleChunk(chunk, value) {
+  if (chunk.status !== PENDING && chunk.status !== BLOCKED) {
+    // We already resolved. We didn't expect to see this.
+    return;
+  }
 
-        if (typeof _value === 'object' && _value !== null) {
-          // $FlowFixMe[incompatible-call] found when upgrading Flow
-          _substr = describeObjectForErrorMessage(_value);
-        } else {
-          _substr = describeValueForErrorMessage(_value);
-        }
+  var resolveListeners = chunk.value;
+  var rejectListeners = chunk.reason;
+  var resolvedChunk = chunk;
+  resolvedChunk.status = RESOLVED_MODULE;
+  resolvedChunk.value = value;
 
-        if ('' + _i === expandedName) {
-          start = str.length;
-          length = _substr.length;
-          str += _substr;
-        } else if (_substr.length < 10 && str.length + _substr.length < 40) {
-          str += _substr;
-        } else {
-          str += '...';
-        }
-      }
+  if (resolveListeners !== null) {
+    initializeModuleChunk(resolvedChunk);
+    wakeChunkIfInitialized(chunk, resolveListeners, rejectListeners);
+  }
+}
 
-      str += ']';
-    }
-  } else {
-    if (objectOrArray.$$typeof === REACT_ELEMENT_TYPE) {
-      str = '<' + describeElementType(objectOrArray.type) + '/>';
-    } else if (jsxPropsParents.has(objectOrArray)) {
-      // Print JSX
-      var _type = jsxPropsParents.get(objectOrArray);
+var initializingChunk = null;
+var initializingChunkBlockedModel = null;
 
-      str = '<' + (describeElementType(_type) || '...');
-      var object = objectOrArray;
-      var names = Object.keys(object);
+function initializeModelChunk(chunk) {
+  var prevChunk = initializingChunk;
+  var prevBlocked = initializingChunkBlockedModel;
+  initializingChunk = chunk;
+  initializingChunkBlockedModel = null;
 
-      for (var _i2 = 0; _i2 < names.length; _i2++) {
-        str += ' ';
-        var name = names[_i2];
-        str += describeKeyForErrorMessage(name) + '=';
-        var _value2 = object[name];
+  try {
+    var value = parseModel(chunk._response, chunk.value);
 
-        var _substr2 = void 0;
+    if (initializingChunkBlockedModel !== null && initializingChunkBlockedModel.deps > 0) {
+      initializingChunkBlockedModel.value = value; // We discovered new dependencies on modules that are not yet resolved.
+      // We have to go the BLOCKED state until they're resolved.
 
-        if (name === expandedName && typeof _value2 === 'object' && _value2 !== null) {
-          // $FlowFixMe[incompatible-call] found when upgrading Flow
-          _substr2 = describeObjectForErrorMessage(_value2);
-        } else {
-          _substr2 = describeValueForErrorMessage(_value2);
-        }
+      var blockedChunk = chunk;
+      blockedChunk.status = BLOCKED;
+      blockedChunk.value = null;
+      blockedChunk.reason = null;
+    } else {
+      var initializedChunk = chunk;
+      initializedChunk.status = INITIALIZED;
+      initializedChunk.value = value;
+    }
+  } catch (error) {
+    var erroredChunk = chunk;
+    erroredChunk.status = ERRORED;
+    erroredChunk.reason = error;
+  } finally {
+    initializingChunk = prevChunk;
+    initializingChunkBlockedModel = prevBlocked;
+  }
+}
 
-        if (typeof _value2 !== 'string') {
-          _substr2 = '{' + _substr2 + '}';
-        }
+function initializeModuleChunk(chunk) {
+  try {
+    var value = requireModule(chunk.value);
+    var initializedChunk = chunk;
+    initializedChunk.status = INITIALIZED;
+    initializedChunk.value = value;
+  } catch (error) {
+    var erroredChunk = chunk;
+    erroredChunk.status = ERRORED;
+    erroredChunk.reason = error;
+  }
+} // Report that any missing chunks in the model is now going to throw this
+// error upon read. Also notify any pending promises.
 
-        if (name === expandedName) {
-          start = str.length;
-          length = _substr2.length;
-          str += _substr2;
-        } else if (_substr2.length < 10 && str.length + _substr2.length < 40) {
-          str += _substr2;
-        } else {
-          str += '...';
-        }
-      }
 
-      str += '>';
-    } else {
-      // Print Object
-      str = '{';
-      var _object = objectOrArray;
+function reportGlobalError(response, error) {
+  response._chunks.forEach(function (chunk) {
+    // If this chunk was already resolved or errored, it won't
+    // trigger an error but if it wasn't then we need to
+    // because we won't be getting any new data to resolve it.
+    if (chunk.status === PENDING) {
+      triggerErrorOnChunk(chunk, error);
+    }
+  });
+}
 
-      var _names = Object.keys(_object);
+function createElement(type, key, props) {
+  var element = {
+    // This tag allows us to uniquely identify this as a React Element
+    $$typeof: REACT_ELEMENT_TYPE,
+    // Built-in properties that belong on the element
+    type: type,
+    key: key,
+    ref: null,
+    props: props,
+    // Record the component responsible for creating this element.
+    _owner: null
+  };
 
-      for (var _i3 = 0; _i3 < _names.length; _i3++) {
-        if (_i3 > 0) {
-          str += ', ';
-        }
+  {
+    // We don't really need to add any of these but keeping them for good measure.
+    // Unfortunately, _store is enumerable in jest matchers so for equality to
+    // work, I need to keep it or make _store non-enumerable in the other file.
+    element._store = {};
+    Object.defineProperty(element._store, 'validated', {
+      configurable: false,
+      enumerable: false,
+      writable: true,
+      value: true // This element has already been validated on the server.
 
-        var _name = _names[_i3];
-        str += describeKeyForErrorMessage(_name) + ': ';
-        var _value3 = _object[_name];
+    });
+    Object.defineProperty(element, '_self', {
+      configurable: false,
+      enumerable: false,
+      writable: false,
+      value: null
+    });
+    Object.defineProperty(element, '_source', {
+      configurable: false,
+      enumerable: false,
+      writable: false,
+      value: null
+    });
+  }
 
-        var _substr3 = void 0;
+  return element;
+}
 
-        if (typeof _value3 === 'object' && _value3 !== null) {
-          // $FlowFixMe[incompatible-call] found when upgrading Flow
-          _substr3 = describeObjectForErrorMessage(_value3);
-        } else {
-          _substr3 = describeValueForErrorMessage(_value3);
-        }
+function createLazyChunkWrapper(chunk) {
+  var lazyType = {
+    $$typeof: REACT_LAZY_TYPE,
+    _payload: chunk,
+    _init: readChunk
+  };
+  return lazyType;
+}
 
-        if (_name === expandedName) {
-          start = str.length;
-          length = _substr3.length;
-          str += _substr3;
-        } else if (_substr3.length < 10 && str.length + _substr3.length < 40) {
-          str += _substr3;
-        } else {
-          str += '...';
-        }
-      }
+function getChunk(response, id) {
+  var chunks = response._chunks;
+  var chunk = chunks.get(id);
 
-      str += '}';
-    }
+  if (!chunk) {
+    chunk = createPendingChunk(response);
+    chunks.set(id, chunk);
   }
 
-  if (expandedName === undefined) {
-    return str;
-  }
+  return chunk;
+}
 
-  if (start > -1 && length > 0) {
-    var highlight = ' '.repeat(start) + '^'.repeat(length);
-    return '\n  ' + str + '\n  ' + highlight;
+function createModelResolver(chunk, parentObject, key) {
+  var blocked;
+
+  if (initializingChunkBlockedModel) {
+    blocked = initializingChunkBlockedModel;
+    blocked.deps++;
+  } else {
+    blocked = initializingChunkBlockedModel = {
+      deps: 1,
+      value: null
+    };
   }
 
-  return '\n  ' + str;
-}
+  return function (value) {
+    parentObject[key] = value;
+    blocked.deps--;
 
-// Thenable<ReactServerValue>
-// function serializeByValueID(id: number): string {
-//   return '$' + id.toString(16);
-// }
+    if (blocked.deps === 0) {
+      if (chunk.status !== BLOCKED) {
+        return;
+      }
 
-function serializePromiseID(id) {
-  return '$@' + id.toString(16);
+      var resolveListeners = chunk.value;
+      var initializedChunk = chunk;
+      initializedChunk.status = INITIALIZED;
+      initializedChunk.value = blocked.value;
+
+      if (resolveListeners !== null) {
+        wakeChunk(resolveListeners, blocked.value);
+      }
+    }
+  };
 }
 
-function serializeServerReferenceID(id) {
-  return '$F' + id.toString(16);
+function createModelReject(chunk) {
+  return function (error) {
+    return triggerErrorOnChunk(chunk, error);
+  };
 }
 
-function serializeSymbolReference(name) {
-  return '$S' + name;
-}
+function createServerReferenceProxy(response, metaData) {
+  var callServer = response._callServer;
 
-function serializeFormDataReference(id) {
-  // Why K? F is "Function". D is "Date". What else?
-  return '$K' + id.toString(16);
-}
+  var proxy = function () {
+    // $FlowFixMe[method-unbinding]
+    var args = Array.prototype.slice.call(arguments);
+    var p = metaData.bound;
 
-function serializeNumber(number) {
-  if (Number.isFinite(number)) {
-    if (number === 0 && 1 / number === -Infinity) {
-      return '$-0';
-    } else {
-      return number;
-    }
-  } else {
-    if (number === Infinity) {
-      return '$Infinity';
-    } else if (number === -Infinity) {
-      return '$-Infinity';
-    } else {
-      return '$NaN';
+    if (!p) {
+      return callServer(metaData.id, args);
     }
-  }
-}
 
-function serializeUndefined() {
-  return '$undefined';
-}
+    if (p.status === INITIALIZED) {
+      var bound = p.value;
+      return callServer(metaData.id, bound.concat(args));
+    } // Since this is a fake Promise whose .then doesn't chain, we have to wrap it.
+    // TODO: Remove the wrapper once that's fixed.
 
-function serializeDateFromDateJSON(dateJSON) {
-  // JSON.stringify automatically calls Date.prototype.toJSON which calls toISOString.
-  // We need only tack on a $D prefix.
-  return '$D' + dateJSON;
-}
 
-function serializeBigInt(n) {
-  return '$n' + n.toString(10);
+    return Promise.resolve(p).then(function (bound) {
+      return callServer(metaData.id, bound.concat(args));
+    });
+  }; // Expose encoder for use by SSR.
+  // TODO: Only expose this in SSR builds and not the browser client.
+
+
+  proxy.$$FORM_ACTION = encodeFormAction;
+  knownServerReferences.set(proxy, metaData);
+  return proxy;
 }
 
-function escapeStringValue(value) {
+function parseModelString(response, parentObject, key, value) {
   if (value[0] === '$') {
-    // We need to escape $ prefixed strings since we use those to encode
-    // references to IDs and as special symbol values.
-    return '$' + value;
-  } else {
-    return value;
-  }
-}
+    if (value === '$') {
+      // A very common symbol.
+      return REACT_ELEMENT_TYPE;
+    }
 
-function processReply(root, formFieldPrefix, resolve, reject) {
-  var nextPartId = 1;
-  var pendingParts = 0;
-  var formData = null;
+    switch (value[1]) {
+      case '$':
+        {
+          // This was an escaped string value.
+          return value.slice(1);
+        }
 
-  function resolveToJSON(key, value) {
-    var parent = this; // Make sure that `parent[key]` wasn't JSONified before `value` was passed to us
+      case 'L':
+        {
+          // Lazy node
+          var id = parseInt(value.slice(2), 16);
+          var chunk = getChunk(response, id); // We create a React.lazy wrapper around any lazy values.
+          // When passed into React, we'll know how to suspend on this.
 
-    {
-      // $FlowFixMe[incompatible-use]
-      var originalValue = parent[key];
+          return createLazyChunkWrapper(chunk);
+        }
 
-      if (typeof originalValue === 'object' && originalValue !== value && !(originalValue instanceof Date)) {
-        if (objectName(originalValue) !== 'Object') {
-          error('Only plain objects can be passed to Server Functions from the Client. ' + '%s objects are not supported.%s', objectName(originalValue), describeObjectForErrorMessage(parent, key));
-        } else {
-          error('Only plain objects can be passed to Server Functions from the Client. ' + 'Objects with toJSON methods are not supported. Convert it manually ' + 'to a simple value before passing it to props.%s', describeObjectForErrorMessage(parent, key));
+      case '@':
+        {
+          // Promise
+          var _id = parseInt(value.slice(2), 16);
+
+          var _chunk = getChunk(response, _id);
+
+          return _chunk;
         }
-      }
-    }
 
-    if (value === null) {
-      return null;
-    }
+      case 'S':
+        {
+          // Symbol
+          return Symbol.for(value.slice(2));
+        }
 
-    if (typeof value === 'object') {
-      // $FlowFixMe[method-unbinding]
-      if (typeof value.then === 'function') {
-        // We assume that any object with a .then property is a "Thenable" type,
-        // or a Promise type. Either of which can be represented by a Promise.
-        if (formData === null) {
-          // Upgrade to use FormData to allow us to stream this value.
-          formData = new FormData();
+      case 'P':
+        {
+          // Server Context Provider
+          return getOrCreateServerContext(value.slice(2)).Provider;
         }
 
-        pendingParts++;
-        var promiseId = nextPartId++;
-        var thenable = value;
-        thenable.then(function (partValue) {
-          var partJSON = JSON.stringify(partValue, resolveToJSON); // $FlowFixMe[incompatible-type] We know it's not null because we assigned it above.
+      case 'F':
+        {
+          // Server Reference
+          var _id2 = parseInt(value.slice(2), 16);
 
-          var data = formData; // eslint-disable-next-line react-internal/safe-string-coercion
+          var _chunk2 = getChunk(response, _id2);
 
-          data.append(formFieldPrefix + promiseId, partJSON);
-          pendingParts--;
+          switch (_chunk2.status) {
+            case RESOLVED_MODEL:
+              initializeModelChunk(_chunk2);
+              break;
+          } // The status might have changed after initialization.
 
-          if (pendingParts === 0) {
-            resolve(data);
-          }
-        }, function (reason) {
-          // In the future we could consider serializing this as an error
-          // that throws on the server instead.
-          reject(reason);
-        });
-        return serializePromiseID(promiseId);
-      } // TODO: Should we the Object.prototype.toString.call() to test for cross-realm objects?
 
+          switch (_chunk2.status) {
+            case INITIALIZED:
+              {
+                var metadata = _chunk2.value;
+                return createServerReferenceProxy(response, metadata);
+              }
+            // We always encode it first in the stream so it won't be pending.
 
-      if (value instanceof FormData) {
-        if (formData === null) {
-          // Upgrade to use FormData to allow us to use rich objects as its values.
-          formData = new FormData();
+            default:
+              throw _chunk2.reason;
+          }
         }
 
-        var data = formData;
-        var refId = nextPartId++; // Copy all the form fields with a prefix for this reference.
-        // These must come first in the form order because we assume that all the
-        // fields are available before this is referenced.
+      case 'I':
+        {
+          // $Infinity
+          return Infinity;
+        }
 
-        var prefix = formFieldPrefix + refId + '_'; // $FlowFixMe[prop-missing]: FormData has forEach.
+      case '-':
+        {
+          // $-0 or $-Infinity
+          if (value === '$-0') {
+            return -0;
+          } else {
+            return -Infinity;
+          }
+        }
 
-        value.forEach(function (originalValue, originalKey) {
-          data.append(prefix + originalKey, originalValue);
-        });
-        return serializeFormDataReference(refId);
-      }
+      case 'N':
+        {
+          // $NaN
+          return NaN;
+        }
 
-      if (!isArray(value)) {
-        var iteratorFn = getIteratorFn(value);
+      case 'u':
+        {
+          // matches "$undefined"
+          // Special encoding for `undefined` which can't be serialized as JSON otherwise.
+          return undefined;
+        }
 
-        if (iteratorFn) {
-          return Array.from(value);
+      case 'D':
+        {
+          // Date
+          return new Date(Date.parse(value.slice(2)));
         }
-      }
 
-      {
-        if (value !== null && !isArray(value)) {
-          // Verify that this is a simple plain object.
-          if (value.$$typeof === REACT_ELEMENT_TYPE) {
-            error('React Element cannot be passed to Server Functions from the Client.%s', describeObjectForErrorMessage(parent, key));
-          } else if (value.$$typeof === REACT_LAZY_TYPE) {
-            error('React Lazy cannot be passed to Server Functions from the Client.%s', describeObjectForErrorMessage(parent, key));
-          } else if (value.$$typeof === REACT_PROVIDER_TYPE) {
-            error('React Context Providers cannot be passed to Server Functions from the Client.%s', describeObjectForErrorMessage(parent, key));
-          } else if (objectName(value) !== 'Object') {
-            error('Only plain objects can be passed to Client Components from Server Components. ' + '%s objects are not supported.%s', objectName(value), describeObjectForErrorMessage(parent, key));
-          } else if (!isSimpleObject(value)) {
-            error('Only plain objects can be passed to Client Components from Server Components. ' + 'Classes or other objects with methods are not supported.%s', describeObjectForErrorMessage(parent, key));
-          } else if (Object.getOwnPropertySymbols) {
-            var symbols = Object.getOwnPropertySymbols(value);
+      case 'n':
+        {
+          // BigInt
+          return BigInt(value.slice(2));
+        }
+
+      default:
+        {
+          // We assume that anything else is a reference ID.
+          var _id3 = parseInt(value.slice(1), 16);
+
+          var _chunk3 = getChunk(response, _id3);
+
+          switch (_chunk3.status) {
+            case RESOLVED_MODEL:
+              initializeModelChunk(_chunk3);
+              break;
+
+            case RESOLVED_MODULE:
+              initializeModuleChunk(_chunk3);
+              break;
+          } // The status might have changed after initialization.
+
+
+          switch (_chunk3.status) {
+            case INITIALIZED:
+              return _chunk3.value;
 
-            if (symbols.length > 0) {
-              error('Only plain objects can be passed to Client Components from Server Components. ' + 'Objects with symbol properties like %s are not supported.%s', symbols[0].description, describeObjectForErrorMessage(parent, key));
-            }
+            case PENDING:
+            case BLOCKED:
+              var parentChunk = initializingChunk;
+
+              _chunk3.then(createModelResolver(parentChunk, parentObject, key), createModelReject(parentChunk));
+
+              return null;
+
+            default:
+              throw _chunk3.reason;
           }
         }
-      } // $FlowFixMe[incompatible-return]
+    }
+  }
 
+  return value;
+}
+function parseModelTuple(response, value) {
+  var tuple = value;
 
-      return value;
-    }
+  if (tuple[0] === REACT_ELEMENT_TYPE) {
+    // TODO: Consider having React just directly accept these arrays as elements.
+    // Or even change the ReactElement type to be an array.
+    return createElement(tuple[1], tuple[2], tuple[3]);
+  }
 
-    if (typeof value === 'string') {
-      // TODO: Maybe too clever. If we support URL there's no similar trick.
-      if (value[value.length - 1] === 'Z') {
-        // Possibly a Date, whose toJSON automatically calls toISOString
-        // $FlowFixMe[incompatible-use]
-        var _originalValue = parent[key]; // $FlowFixMe[method-unbinding]
+  return value;
+}
 
-        if (_originalValue instanceof Date) {
-          return serializeDateFromDateJSON(value);
-        }
-      }
+function missingCall() {
+  throw new Error('Trying to call a function from "use server" but the callServer option ' + 'was not implemented in your router runtime.');
+}
 
-      return escapeStringValue(value);
-    }
+function createResponse$1(bundlerConfig, callServer) {
+  var chunks = new Map();
+  var response = {
+    _bundlerConfig: bundlerConfig,
+    _callServer: callServer !== undefined ? callServer : missingCall,
+    _chunks: chunks
+  };
+  return response;
+}
+function resolveModel(response, id, model) {
+  var chunks = response._chunks;
+  var chunk = chunks.get(id);
 
-    if (typeof value === 'boolean') {
-      return value;
-    }
+  if (!chunk) {
+    chunks.set(id, createResolvedModelChunk(response, model));
+  } else {
+    resolveModelChunk(chunk, model);
+  }
+}
+function resolveModule(response, id, model) {
+  var chunks = response._chunks;
+  var chunk = chunks.get(id);
+  var clientReferenceMetadata = parseModel(response, model);
+  var clientReference = resolveClientReference(response._bundlerConfig, clientReferenceMetadata); // TODO: Add an option to encode modules that are lazy loaded.
+  // For now we preload all modules as early as possible since it's likely
+  // that we'll need them.
 
-    if (typeof value === 'number') {
-      return serializeNumber(value);
+  var promise = preloadModule(clientReference);
+
+  if (promise) {
+    var blockedChunk;
+
+    if (!chunk) {
+      // Technically, we should just treat promise as the chunk in this
+      // case. Because it'll just behave as any other promise.
+      blockedChunk = createBlockedChunk(response);
+      chunks.set(id, blockedChunk);
+    } else {
+      // This can't actually happen because we don't have any forward
+      // references to modules.
+      blockedChunk = chunk;
+      blockedChunk.status = BLOCKED;
     }
 
-    if (typeof value === 'undefined') {
-      return serializeUndefined();
+    promise.then(function () {
+      return resolveModuleChunk(blockedChunk, clientReference);
+    }, function (error) {
+      return triggerErrorOnChunk(blockedChunk, error);
+    });
+  } else {
+    if (!chunk) {
+      chunks.set(id, createResolvedModuleChunk(response, clientReference));
+    } else {
+      // This can't actually happen because we don't have any forward
+      // references to modules.
+      resolveModuleChunk(chunk, clientReference);
     }
+  }
+}
+function resolveErrorDev(response, id, digest, message, stack) {
 
-    if (typeof value === 'function') {
-      var metaData = knownServerReferences.get(value);
 
-      if (metaData !== undefined) {
-        var metaDataJSON = JSON.stringify(metaData, resolveToJSON);
+  var error = new Error(message || 'An error occurred in the Server Components render but no message was provided');
+  error.stack = stack;
+  error.digest = digest;
+  var errorWithDigest = error;
+  var chunks = response._chunks;
+  var chunk = chunks.get(id);
 
-        if (formData === null) {
-          // Upgrade to use FormData to allow us to stream this value.
-          formData = new FormData();
-        } // The reference to this function came from the same client so we can pass it back.
+  if (!chunk) {
+    chunks.set(id, createErrorChunk(response, errorWithDigest));
+  } else {
+    triggerErrorOnChunk(chunk, errorWithDigest);
+  }
+}
+function resolveHint(response, code, model) {
+  var hintModel = parseModel(response, model);
+  dispatchHint(code, hintModel);
+}
+function close(response) {
+  // In case there are any remaining unresolved chunks, they won't
+  // be resolved now. So we need to issue an error to those.
+  // Ideally we should be able to early bail out if we kept a
+  // ref count of pending chunks.
+  reportGlobalError(response, new Error('Connection closed.'));
+}
 
+function processFullRow(response, row) {
+  if (row === '') {
+    return;
+  }
 
-        var _refId = nextPartId++; // eslint-disable-next-line react-internal/safe-string-coercion
+  var colon = row.indexOf(':', 0);
+  var id = parseInt(row.slice(0, colon), 16);
+  var tag = row[colon + 1]; // When tags that are not text are added, check them here before
+  // parsing the row as text.
+  // switch (tag) {
+  // }
 
+  switch (tag) {
+    case 'I':
+      {
+        resolveModule(response, id, row.slice(colon + 2));
+        return;
+      }
 
-        formData.set(formFieldPrefix + _refId, metaDataJSON);
-        return serializeServerReferenceID(_refId);
+    case 'H':
+      {
+        var code = row[colon + 2];
+        resolveHint(response, code, row.slice(colon + 3));
+        return;
       }
 
-      throw new Error('Client Functions cannot be passed directly to Server Functions. ' + 'Only Functions passed from the Server can be passed back again.');
-    }
+    case 'E':
+      {
+        var errorInfo = JSON.parse(row.slice(colon + 2));
 
-    if (typeof value === 'symbol') {
-      // $FlowFixMe[incompatible-type] `description` might be undefined
-      var name = value.description;
+        {
+          resolveErrorDev(response, id, errorInfo.digest, errorInfo.message, errorInfo.stack);
+        }
 
-      if (Symbol.for(name) !== value) {
-        throw new Error('Only global symbols received from Symbol.for(...) can be passed to Server Functions. ' + ("The symbol Symbol.for(" + // $FlowFixMe[incompatible-type] `description` might be undefined
-        value.description + ") cannot be found among global symbols."));
+        return;
       }
 
-      return serializeSymbolReference(name);
+    default:
+      {
+        // We assume anything else is JSON.
+        resolveModel(response, id, row.slice(colon + 1));
+        return;
+      }
+  }
+}
+
+function processStringChunk(response, chunk, offset) {
+  var linebreak = chunk.indexOf('\n', offset);
+
+  while (linebreak > -1) {
+    var fullrow = response._partialRow + chunk.slice(offset, linebreak);
+    processFullRow(response, fullrow);
+    response._partialRow = '';
+    offset = linebreak + 1;
+    linebreak = chunk.indexOf('\n', offset);
+  }
+
+  response._partialRow += chunk.slice(offset);
+}
+function processBinaryChunk(response, chunk) {
+
+  var stringDecoder = response._stringDecoder;
+  var linebreak = chunk.indexOf(10); // newline
+
+  while (linebreak > -1) {
+    var fullrow = response._partialRow + readFinalStringChunk(stringDecoder, chunk.subarray(0, linebreak));
+    processFullRow(response, fullrow);
+    response._partialRow = '';
+    chunk = chunk.subarray(linebreak + 1);
+    linebreak = chunk.indexOf(10); // newline
+  }
+
+  response._partialRow += readPartialStringChunk(stringDecoder, chunk);
+}
+
+function createFromJSONCallback(response) {
+  // $FlowFixMe[missing-this-annot]
+  return function (key, value) {
+    if (typeof value === 'string') {
+      // We can't use .bind here because we need the "this" value.
+      return parseModelString(response, this, key, value);
     }
 
-    if (typeof value === 'bigint') {
-      return serializeBigInt(value);
+    if (typeof value === 'object' && value !== null) {
+      return parseModelTuple(response, value);
     }
 
-    throw new Error("Type " + typeof value + " is not supported as an argument to a Server Function.");
-  } // $FlowFixMe[incompatible-type] it's not going to be undefined because we'll encode it.
+    return value;
+  };
+}
 
+function createResponse(bundlerConfig, callServer) {
+  // NOTE: CHECK THE COMPILER OUTPUT EACH TIME YOU CHANGE THIS.
+  // It should be inlined to one object literal but minor changes can break it.
+  var stringDecoder = createStringDecoder() ;
+  var response = createResponse$1(bundlerConfig, callServer);
+  response._partialRow = '';
 
-  var json = JSON.stringify(root, resolveToJSON);
+  {
+    response._stringDecoder = stringDecoder;
+  } // Don't inline this call because it causes closure to outline the call above.
 
-  if (formData === null) {
-    // If it's a simple data structure, we just use plain JSON.
-    resolve(json);
-  } else {
-    // Otherwise, we use FormData to let us stream in the result.
-    formData.set(formFieldPrefix + '0', json);
 
-    if (pendingParts === 0) {
-      // $FlowFixMe[incompatible-call] this has already been refined.
-      resolve(formData);
-    }
-  }
+  response._fromJSON = createFromJSONCallback(response);
+  return response;
 }
 
 function createResponseFromOptions(options) {