Server Architecture

Copyexport class NextServer implements NextWrapperServer {
  private serverPromise?: Promise<NextNodeServer>
  private server?: NextNodeServer
  private reqHandler?: NodeRequestHandler
  private reqHandlerPromise?: Promise<NodeRequestHandler>
  private preparedAssetPrefix?: string
 
  public options: NextServerOptions
 
  constructor(options: NextServerOptions) {
    this.options = options
  }

Copyprivate async [SYMBOL_LOAD_CONFIG]() {
  const dir = path.resolve(
    /* turbopackIgnore: true */ this.options.dir || '.'
  )
 
  const config = await loadConfig(
    this.options.dev ? PHASE_DEVELOPMENT_SERVER : PHASE_PRODUCTION_SERVER,
    dir,
    {
      customConfig: this.options.conf,
      silent: true,
    }
  )
 

Copyif (!this.options.dev) {
  if (conf.output === 'standalone') {
    if (!process.env.__NEXT_PRIVATE_STANDALONE_CONFIG) {
      log.warn(
        `"next start" does not work with "output: standalone" configuration. Use "node .next/standalone/server.js" instead.`
      )
    }
  } else if (conf.output === 'export') {
    throw new Error(
      `"next start" does not work with "output: export" configuration. Use "npx serve@latest out" instead.`
    )
  }
}

Copyconst DEPRECATED_CUSTOM_SERVER_METHOD_GUIDANCE: Record<
  DeprecatedCustomServerMethod,
  string
> = {
  setAssetPrefix: 'Please configure `assetPrefix` in `next.config.js` instead.',
  logError: 'Please use application logging instead.',
  logErrorWithOriginalStack: 'Please use application logging instead.',
  revalidate: 'Please use documented application revalidation APIs instead.',
  render:
    'Please use `app.getRequestHandler()` with an adjusted parsed URL instead.',
  renderToHTML:
    'Please use `app.getRequestHandler()` with an adjusted parsed URL instead.',
  renderError:
    'Please use `app.getRequestHandler()` with an adjusted parsed URL instead.',
  renderErrorToHTML:
    'Please use `app.getRequestHandler()` with an adjusted parsed URL instead.',
  render404:
    'Please use `app.getRequestHandler()` with an adjusted parsed URL instead.',
}

Copyif (typeof (globalThis as any).AsyncLocalStorage !== 'function') {
  const { AsyncLocalStorage } =
    require('async_hooks') as typeof import('async_hooks')
  ;(globalThis as any).AsyncLocalStorage = AsyncLocalStorage
}
 
if (typeof (globalThis as any).WebSocket !== 'function') {
  Object.defineProperty(globalThis, 'WebSocket', {
    configurable: true,
    get() {
      return (
        require('next/dist/compiled/ws') as typeof import('next/dist/compiled/ws')
      ).WebSocket
    },
    set(value) {
      Object.defineProperty(globalThis, 'WebSocket', {
        configurable: true,
        writable: true,
        value,
      })
    },
  })

Copylet { port } = serverOptions
 
process.title = `next-server (v${process.env.__NEXT_VERSION})`
let handlersReady = () => {}
let handlersError = () => {}
 
let handlersPromise: Promise<void> | undefined = new Promise<void>(
  (resolve, reject) => {
    handlersReady = resolve
    handlersError = reject
  }
)
let requestHandler: WorkerRequestHandler = async (
  req: IncomingMessage,
  res: ServerResponse
): Promise<void> => {
  if (handlersPromise) {
    await handlersPromise
    return requestHandler(req, res)
  }
  throw new Error('Invariant request handler was not setup')
}
let upgradeHandler: WorkerUpgradeHandler = async (
  req,
  socket,
  head
): Promise<void> => {
  if (handlersPromise) {
    await handlersPromise
    return upgradeHandler(req, socket, head)
  }
  throw new Error('Invariant upgrade handler was not setup')
}
 
let nextServer: NextServer | undefined
let devMemoryThresholdRestart = true
 
// setup server listener as fast as possible
if (selfSignedCertificate && !isDev) {
  throw new Error(
    'Using a self signed certificate is only supported with `next dev`.'
  )
}
 
async function requestListener(req: IncomingMessage, res: ServerResponse) {
  try {
    if (handlersPromise) {
      await handlersPromise
      handlersPromise = undefined
    }
    await requestHandler(req, res)
  } catch (err) {
    res.statusCode = 500
    res.end('Internal Server Error')
    Log.error(`Failed to handle request for ${req.url}`)
    console.error(err)
  } finally {
    const memoryRestartStats = getMemoryRestartStats(
      isDev,
      devMemoryThresholdRestart,
      v8.getHeapStatistics
    )
    if (memoryRestartStats) {
      Log.warn(
        `Server is approaching the used memory threshold, restarting...`
      )
      trace('server-restart-close-to-memory-threshold', undefined, {
        'memory.heapSizeLimit': String(memoryRestartStats.heap_size_limit),
        'memory.heapUsed': String(memoryRestartStats.used_heap_size),
      }).stop()
      flushAllTraces()
      process.exit(RESTART_EXIT_CODE)
    }
  }
}
 
const server = selfSignedCertificate
  ? https.createServer(
      {
        key: fs.readFileSync(selfSignedCertificate.key),

Copyif (selfSignedCertificate && !isDev) {
  throw new Error(
    'Using a self signed certificate is only supported with `next dev`.'
  )
}

Copyif (keepAliveTimeout) {
  server.keepAliveTimeout = keepAliveTimeout
}
server.on('upgrade', async (req, socket, head) => {
  try {
    await upgradeHandler(req, socket, head)
  } catch (err) {
    socket.destroy()
    Log.error(`Failed to handle request for ${req.url}`)
    console.error(err)
  }
})
 
let portRetryCount = 0
const originalPort = port
 
server.on('error', (err: NodeJS.ErrnoException) => {
  if (
    allowRetry &&
    port &&
    isDev &&
    err.code === 'EADDRINUSE' &&
    portRetryCount < 10
  ) {
    port += 1
    portRetryCount += 1
    server.listen(port, hostname)
  } else {
    Log.error(`Failed to start server`)
    console.error(err)
    process.exit(1)
  }
})

Copy    switch (signal) {
      case 'SIGINT':
        process.exit(130)
        break
      case 'SIGTERM':
        process.exit(143)
        break
      default:
        // Make sure all handled signals have explicit exit codes.
        // This is just a fallback to guard against unsound types.
        signal satisfies never
        process.exit(128)
    }
  })()
}
 
// Make sure commands gracefully respect termination signals (e.g. from Docker)
// Allow the graceful termination to be manually configurable
if (!process.env.NEXT_MANUAL_SIG_HANDLE) {
  process.on('SIGINT', cleanup)
  process.on('SIGTERM', cleanup)
}

Copypublic constructor(options: ServerOptions) {
  const {
    dir = '.',
    quiet = false,
    conf,
    dev = false,
    minimalMode = false,
    hostname,
    port,
    experimentalTestProxy,
  } = options
 
  this.dev = dev
  this.experimentalTestProxy = experimentalTestProxy
  this.serverOptions = options
 
  this.dir = path.resolve(/* turbopackIgnore: true */ dir)
 
  this.quiet = quiet
  this.loadEnvConfig({ dev, forceReload: false })
 
  // TODO: should conf be normalized to prevent missing
  // values from causing issues as this can be user provided
  this.nextConfig = conf as NextConfigRuntime
  if (
    (dev || process.env.__NEXT_DEV_SERVER) &&
    this.nextConfig.experimental.requestInsights
  ) {
    process.env.__NEXT_REQUEST_INSIGHTS = 'true'
  }
 
  if (this.nextConfig.experimental.runtimeServerDeploymentId) {
    if (!process.env.NEXT_DEPLOYMENT_ID) {
      throw new Error(
        'process.env.NEXT_DEPLOYMENT_ID is missing but runtimeServerDeploymentId is enabled'
      )
    }
    this.deploymentId = process.env.NEXT_DEPLOYMENT_ID
  } else {
    let id = this.nextConfig.experimental.useSkewCookie
      ? ''
      : this.nextConfig.deploymentId || ''
 
    this.deploymentId = id
    process.env.NEXT_DEPLOYMENT_ID = id
  }
  ;(globalThis as any).NEXT_CLIENT_ASSET_SUFFIX =
    this.nextConfig.supportsImmutableAssets || !this.deploymentId
      ? ''
      : `?dpl=${this.deploymentId}`
 
  this.hostname = hostname
  if (this.hostname) {
    // we format the hostname so that it can be fetched
    this.fetchHostname = formatHostname(this.hostname)
  }
  this.port = port
  this.distDir = path.join(
    /* turbopackIgnore: true */ this.dir,
    this.nextConfig.distDir
  )
  this.pagesNormalizers = new PagesNormalizers(this.distDir)
  this.appNormalizers = new AppNormalizers(this.distDir)
  this.publicDir = this.getPublicDir()
  this.hasStaticDir = !minimalMode && this.getHasStaticDir()
 
  this.i18nProvider = this.nextConfig.i18n?.locales
    ? new I18NProvider(this.nextConfig.i18n)
    : undefined
 
  // Configure the locale normalizer, it's used for routes inside `pages/`.
  this.localeNormalizer = this.i18nProvider
    ? new LocaleRouteNormalizer(this.i18nProvider)
    : undefined
 
  const { assetPrefix, generateEtags } = this.nextConfig
 
  this.buildId = this.getBuildId()
  // this is a hack to avoid Webpack knowing this is equal to this.minimalMode
  // because we replace this.minimalMode to true in production bundles.

Copythis.dir = path.resolve(/* turbopackIgnore: true */ dir)
 
this.quiet = quiet
this.loadEnvConfig({ dev, forceReload: false })
 
// TODO: should conf be normalized to prevent missing
// values from causing issues as this can be user provided
this.nextConfig = conf as NextConfigRuntime
if (
  (dev || process.env.__NEXT_DEV_SERVER) &&
  this.nextConfig.experimental.requestInsights
) {
  process.env.__NEXT_REQUEST_INSIGHTS = 'true'
}
 
if (this.nextConfig.experimental.runtimeServerDeploymentId) {
  if (!process.env.NEXT_DEPLOYMENT_ID) {
    throw new Error(
      'process.env.NEXT_DEPLOYMENT_ID is missing but runtimeServerDeploymentId is enabled'
    )
  }
  this.deploymentId = process.env.NEXT_DEPLOYMENT_ID
} else {
  let id = this.nextConfig.experimental.useSkewCookie
    ? ''
    : this.nextConfig.deploymentId || ''
 
  this.deploymentId = id
  process.env.NEXT_DEPLOYMENT_ID = id
}
;(globalThis as any).NEXT_CLIENT_ASSET_SUFFIX =
  this.nextConfig.supportsImmutableAssets || !this.deploymentId
    ? ''
    : `?dpl=${this.deploymentId}`
 
this.hostname = hostname
if (this.hostname) {
  // we format the hostname so that it can be fetched
  this.fetchHostname = formatHostname(this.hostname)
}
this.port = port
this.distDir = path.join(
  /* turbopackIgnore: true */ this.dir,
  this.nextConfig.distDir
)
this.pagesNormalizers = new PagesNormalizers(this.distDir)
this.appNormalizers = new AppNormalizers(this.distDir)
this.publicDir = this.getPublicDir()
this.hasStaticDir = !minimalMode && this.getHasStaticDir()

Copyif (this.nextConfig.experimental.runtimeServerDeploymentId) {
  if (!process.env.NEXT_DEPLOYMENT_ID) {
    throw new Error(
      'process.env.NEXT_DEPLOYMENT_ID is missing but runtimeServerDeploymentId is enabled'
    )
  }
  this.deploymentId = process.env.NEXT_DEPLOYMENT_ID

Copythis.normalizers = {
  // We should normalize the pathname from the RSC prefix only in minimal
  // mode as otherwise that route is not exposed external to the server as
  // we instead only rely on the headers.
  rsc:
    this.enabledDirectories.app && this.minimalMode
      ? new RSCPathnameNormalizer()
      : undefined,
  segmentPrefetchRSC: this.minimalMode
    ? new SegmentPrefixRSCPathnameNormalizer()
    : undefined,
  data: this.enabledDirectories.pages
    ? new NextDataPathnameNormalizer(this.buildId)
    : undefined,
}

Copythis.renderOpts = {
  dir: this.dir,
  supportsDynamicResponse: true,
  trailingSlash: this.nextConfig.trailingSlash,
  poweredByHeader: this.nextConfig.poweredByHeader,
  generateEtags,
  previewProps: this.getPreviewProps(),
  basePath: this.nextConfig.basePath,
  images: this.nextConfig.images,
  optimizeCss: this.nextConfig.experimental.optimizeCss,
  nextConfigOutput: this.nextConfig.output,
  nextScriptWorkers: this.nextConfig.experimental.nextScriptWorkers,
  disableOptimizedLoading:
    this.nextConfig.experimental.disableOptimizedLoading,
  domainLocales: this.nextConfig.i18n?.domains,
  distDir: this.distDir,
  serverComponents: this.enabledDirectories.app,
  cacheLifeProfiles: this.nextConfig.cacheLife,
  staticPageGenerationTimeout: this.nextConfig.staticPageGenerationTimeout,
  enableTainting: this.nextConfig.experimental.taint,
  crossOrigin: this.nextConfig.crossOrigin
    ? this.nextConfig.crossOrigin
    : undefined,
  largePageDataBytes: this.nextConfig.experimental.largePageDataBytes,
 
  isExperimentalCompile: options.compileMode
    ? options.compileMode.isExperimentalCompile
    : this.nextConfig.experimental.isExperimentalCompile,

Copyprotected normalizeReq(
  req: NodeNextRequest | IncomingMessage
): NodeNextRequest {
  return !(req instanceof NodeNextRequest) ? new NodeNextRequest(req) : req
}
 
protected normalizeRes(
  res: NodeNextResponse | ServerResponse
): NodeNextResponse {
  return !(res instanceof NodeNextResponse) ? new NodeNextResponse(res) : res
}

Copypublic getRequestHandler(): NodeRequestHandler {
  const handler = this.makeRequestHandler()
  if (this.serverOptions.experimentalTestProxy) {
    const { wrapRequestHandlerNode } =
      // eslint-disable-next-line @next/internal/typechecked-require -- experimental/testmode is not built ins next/dist/esm
      require('next/dist/experimental/testmode/server') as typeof import('../experimental/testmode/server')
    return wrapRequestHandlerNode(handler)
  }
  return handler
}
 
/**
 * @internal - this method is internal to Next.js and should not be used directly by end-users
 */
public getRequestHandlerWithMetadata(meta: RequestMeta): NodeRequestHandler {
  const handler = this.makeRequestHandler()
  return (req, res, parsedUrl) => {
    setRequestMeta(req, meta)
    return handler(req, res, parsedUrl)
  }
}

Copy  throw new Error(
    'Invariant: ensurePage can only be called on the development server'
  )
}

Copy  const { cacheMaxMemorySize, cacheHandlers } = this.nextConfig
  if (!cacheHandlers) return
 
  initializeCacheHandlers(cacheMaxMemorySize)
  await registerCustomCacheHandlers(async () => {
    for (const [kind, handler] of Object.entries(cacheHandlers)) {
      if (!handler) continue
 
      setCacheHandler(
        kind,
        interopDefault(
          await dynamicImportEsmDefault(
            formatDynamicImportPath(this.distDir, handler)
          )
        )
      )
    }
  })
}

Copyprotected async getIncrementalCache({
  requestHeaders,
}: {
  requestHeaders: IncrementalCache['requestHeaders']
}) {
  const dev = !!this.dev
  let CacheHandler: any
  const { cacheHandler } = this.nextConfig
 
  if (cacheHandler) {
    CacheHandler = interopDefault(
      await dynamicImportEsmDefault(
        formatDynamicImportPath(this.distDir, cacheHandler)
      )
    )
  }
 
  await this.loadCustomCacheHandlers()

Copyprotected async handleApiRequest(
  req: NodeNextRequest,
  res: NodeNextResponse,
  query: ParsedUrlQuery,
  match: PagesAPIRouteMatch
): Promise<boolean> {
  return this.runApi(req, res, query, match)
}
 
protected getCacheFilesystem(): CacheFs {
  return nodeFs
}

Copyexport abstract class BaseNextRequest<Body = any> {
  protected _cookies: NextApiRequestCookies | undefined
  public abstract headers: IncomingHttpHeaders
  public abstract fetchMetrics: FetchMetric[] | undefined
 
  constructor(
    public method: string,
    public url: string,
    public body: Body
  ) {}
 
  // Utils implemented using the abstract methods above
 
  public get cookies() {
    if (this._cookies) return this._cookies
    return (this._cookies = getCookieParser(this.headers)())
  }
}

Copyexport abstract class BaseNextResponse<Destination = any> {
  abstract statusCode: number | undefined
  abstract statusMessage: string | undefined
  abstract get sent(): boolean
 
  constructor(public destination: Destination) {}
 
  /**
   * Sets a value for the header overwriting existing values
   */
  abstract setHeader(name: string, value: string | string[]): this
 
  /**
   * Removes a header
   */
  abstract removeHeader(name: string): this
 
  /**
   * Appends value for the given header name
   */
  abstract appendHeader(name: string, value: string): this
 
  /**
   * Get all values for a header as an array or undefined if no value is present
   */
  abstract getHeaderValues(name: string): string[] | undefined
 
  abstract hasHeader(name: string): boolean
 
  /**
   * Get values for a header concatenated using `,` or undefined if no value is present
   */
  abstract getHeader(name: string): string | undefined
 
  abstract getHeaders(): OutgoingHttpHeaders
 
  abstract body(value: string): this
 
  abstract send(): void
 
  abstract onClose(callback: () => void): void
 
  // Utils implemented using the abstract methods above
 
  public redirect(destination: string, statusCode: number) {
    this.setHeader('Location', destination)
    this.statusCode = statusCode
 
    // Since IE11 doesn't support the 308 header add backwards
    // compatibility using refresh header
    if (statusCode === RedirectStatusCode.PermanentRedirect) {
      this.setHeader('Refresh', `0;url=${destination}`)
    }
 
    return this
  }

Copyexport class NodeNextRequest extends BaseNextRequest<Readable> {
  public headers = this._req.headers
  public fetchMetrics: FetchMetric[] | undefined = this._req?.fetchMetrics;
 
  [NEXT_REQUEST_META]: RequestMeta = this._req[NEXT_REQUEST_META] || {}
 
  constructor(private _req: Req) {
    super(_req.method!.toUpperCase(), _req.url!, _req)
  }
 
  get originalRequest() {
    // Need to mimic these changes to the original req object for places where we use it:
    // render.tsx, api/ssg requests
    this._req[NEXT_REQUEST_META] = this[NEXT_REQUEST_META]
    this._req.url = this.url
    this._req.cookies = this.cookies
    return this._req
  }
 
  set originalRequest(value: Req) {
    this._req = value
  }
 
  private streaming = false
 
  /**
   * Returns the request body as a Web Readable Stream. The body here can only
   * be read once as the body will start flowing as soon as the data handler
   * is attached.
   *
   * @internal
   */
  public stream() {
    if (this.streaming) {
      throw new Error(
        'Invariant: NodeNextRequest.stream() can only be called once'
      )
    }
    this.streaming = true
 
    return new ReadableStream({
      start: (controller) => {
        this._req.on('data', (chunk) => {
          controller.enqueue(new Uint8Array(chunk))
        })
        this._req.on('end', () => {
          controller.close()
        })
        this._req.on('error', (err) => {
          controller.error(err)
        })
      },
    })
  }
}

Copypublic stream() {
  if (this.streaming) {
    throw new Error(
      'Invariant: NodeNextRequest.stream() can only be called once'
    )
  }
  this.streaming = true

Copyexport class NodeNextResponse extends BaseNextResponse<Writable> {
  private textBody: string | undefined = undefined
 
  public [SYMBOL_CLEARED_COOKIES]?: boolean
 
  get originalResponse() {
    if (SYMBOL_CLEARED_COOKIES in this) {
      this._res[SYMBOL_CLEARED_COOKIES] = this[SYMBOL_CLEARED_COOKIES]
    }
 
    return this._res
  }
 
  constructor(
    private _res: ServerResponse & { [SYMBOL_CLEARED_COOKIES]?: boolean }
  ) {
    super(_res)
  }
 
  get sent() {
    return this._res.finished || this._res.headersSent
  }
 
  get statusCode() {
    return this._res.statusCode
  }
 
  set statusCode(value: number) {
    this._res.statusCode = value
  }
 
  get statusMessage() {
    return this._res.statusMessage
  }
 
  set statusMessage(value: string) {
    this._res.statusMessage = value
  }
 
  setHeader(name: string, value: string | string[]): this {
    this._res.setHeader(name, value)
    return this
  }
 
  removeHeader(name: string): this {
    this._res.removeHeader(name)
    return this
  }
 
  getHeaderValues(name: string): string[] | undefined {
    const values = this._res.getHeader(name)
 
    if (values === undefined) return undefined
 
    return (Array.isArray(values) ? values : [values]).map((value) =>
      value.toString()
    )
  }
 
  hasHeader(name: string): boolean {
    return this._res.hasHeader(name)
  }
 
  getHeader(name: string): string | undefined {
    const values = this.getHeaderValues(name)
    return Array.isArray(values) ? values.join(',') : undefined
  }
 
  getHeaders(): OutgoingHttpHeaders {
    return this._res.getHeaders()
  }
 
  appendHeader(name: string, value: string): this {
    const currentValues = this.getHeaderValues(name) ?? []
 
    if (!currentValues.includes(value)) {
      this._res.setHeader(name, [...currentValues, value])
    }
 
    return this

Copyexport class NextRequestAdapter {
  public static fromBaseNextRequest(
    request: BaseNextRequest,
    signal: AbortSignal
  ): NextRequest {
    if (
      // The type check here ensures that `req` is correctly typed, and the
      // environment variable check provides dead code elimination.
      process.env.NEXT_RUNTIME === 'edge' &&
      isWebNextRequest(request)
    ) {
      return NextRequestAdapter.fromWebNextRequest(request)
    } else if (
      // The type check here ensures that `req` is correctly typed, and the
      // environment variable check provides dead code elimination.
      process.env.NEXT_RUNTIME !== 'edge' &&
      isNodeNextRequest(request)
    ) {
      return NextRequestAdapter.fromNodeNextRequest(request, signal)
    } else {
      throw new Error('Invariant: Unsupported NextRequest type')
    }
  }
 
  public static fromNodeNextRequest(
    request: NodeNextRequest,
    signal: AbortSignal
  ): NextRequest {
    // HEAD and GET requests can not have a body.
    let body: BodyInit | null = null
    if (request.method !== 'GET' && request.method !== 'HEAD' && request.body) {
      // @ts-expect-error - this is handled by undici, when streams/web land use it instead
      body = request.body
    }
 
    let url: URL
    if (request.url.startsWith('http')) {
      url = new URL(request.url)
    } else {
      // Grab the full URL from the request metadata.
      const base = getRequestMeta(request, 'initURL')
      if (!base || !base.startsWith('http')) {
        // Because the URL construction relies on the fact that the URL provided
        // is absolute, we need to provide a base URL. We can't use the request
        // URL because it's relative, so we use a dummy URL instead.
        url = new URL(request.url, 'http://n')
      } else {
        url = new URL(request.url, base)
      }
    }
 
    return new NextRequest(url, {
      method: request.method,
      headers: fromNodeOutgoingHttpHeaders(request.headers),
      duplex: 'half',
      signal,
      // geo
      // ip
      // nextConfig
 
      // body can not be passed if request was aborted
      // or we get a Request body was disturbed error
      ...(signal.aborted
        ? {}
        : {
            body,
          }),
    })
  }

Copy  // body can not be passed if request was aborted
  // or we get a Request body was disturbed error
  ...(signal.aborted
    ? {}
    : {
        body,
      }),
})

Copyexport class NextRequestAdapter {
  public static fromBaseNextRequest(
    request: BaseNextRequest,
    signal: AbortSignal
  ): NextRequest {
    if (
      // The type check here ensures that `req` is correctly typed, and the
      // environment variable check provides dead code elimination.
      process.env.NEXT_RUNTIME === 'edge' &&
      isWebNextRequest(request)
    ) {
      return NextRequestAdapter.fromWebNextRequest(request)
    } else if (
      // The type check here ensures that `req` is correctly typed, and the
      // environment variable check provides dead code elimination.
      process.env.NEXT_RUNTIME !== 'edge' &&
      isNodeNextRequest(request)
    ) {
      return NextRequestAdapter.fromNodeNextRequest(request, signal)
    } else {
      throw new Error('Invariant: Unsupported NextRequest type')
    }
  }

Copyexport interface NextError extends Error {
  type?: string
  page?: string
  code?: string | number
  cancelled?: boolean
  digest?: string
}

Copyexport default function isError(err: unknown): err is NextError {
  return (
    typeof err === 'object' && err !== null && 'name' in err && 'message' in err
  )
}

Copyfunction safeStringifyLite(obj: any) {
  const seen = new WeakSet()
 
  return JSON.stringify(obj, (_key, value) => {
    // If value is an object and already seen, replace with "[Circular]"
    if (typeof value === 'object' && value !== null) {
      if (seen.has(value)) {
        return '[Circular]'
      }
      seen.add(value)
    }
    return value
  })
}

Copyexport function getProperError(err: unknown): Error {
  if (isError(err)) {
    return err
  }
 
  if (process.env.NODE_ENV === 'development') {
    // provide better error for case where `throw undefined`
    // is called in development
    if (typeof err === 'undefined') {
      return new Error(
        'An undefined error was thrown, ' +
          'see here for more info: https://nextjs.org/docs/messages/threw-undefined'
      )
    }
 
    if (err === null) {
      return new Error(
        'A null error was thrown, ' +
          'see here for more info: https://nextjs.org/docs/messages/threw-undefined'
      )
    }
  }

Copyreturn new Error(isPlainObject(err) ? safeStringifyLite(err) : err + '')

Copyfunction safeStringifyLite(obj: any) {
  const seen = new WeakSet()
 
  return JSON.stringify(obj, (_key, value) => {
    // If value is an object and already seen, replace with "[Circular]"
    if (typeof value === 'object' && value !== null) {
      if (seen.has(value)) {
        return '[Circular]'
      }
      seen.add(value)
    }
    return value
  })
}
 
/**
 * Checks whether the given value is a NextError.
 * This can be used to print a more detailed error message with properties like `code` & `digest`.
 */
export default function isError(err: unknown): err is NextError {
  return (
    typeof err === 'object' && err !== null && 'name' in err && 'message' in err
  )
}