Overview

Copyexport type NextServerOptions = Omit<
  ServerOptions | DevServerOptions,
  // This is assigned in this server abstraction.
  'conf' | 'compileMode'
> &
  Partial<Pick<ServerOptions | DevServerOptions, 'conf'>>
 
export type NextBundlerOptions = {
  /** @deprecated Use `turbopack` instead */
  turbo?: boolean
  /** Selects Turbopack as the bundler */
  turbopack?: boolean
  /** Selects Webpack as the bundler */
  webpack?: boolean
}
 
export type RequestHandler = (
  req: IncomingMessage,
  res: ServerResponse,
  parsedUrl?: NextUrlWithParsedQuery | undefined
) => Promise<void>
 
export type UpgradeHandler = (
  req: IncomingMessage,
  socket: Duplex,
  head: Buffer
) => Promise<void>

Copytype DeprecatedCustomServerMethod =
  | 'setAssetPrefix'
  | 'logError'
  | 'logErrorWithOriginalStack'
  | 'revalidate'
  | 'render'
  | 'renderToHTML'
  | 'renderError'
  | 'renderErrorToHTML'
  | 'render404'
 
const 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.',
}
 
function warnDeprecatedCustomServerMethod(
  method: DeprecatedCustomServerMethod
) {
  log.warnOnce(
    `The \`app.${method}()\` method is deprecated in custom servers. ${DEPRECATED_CUSTOM_SERVER_METHOD_GUIDANCE[method]}`
  )
}

Copyinterface NextWrapperServer {
  // NOTE: the methods/properties here are the public API for custom servers.
  // Consider backwards compatibilty when changing something here!
 
  options: NextServerOptions
  hostname: string | undefined
  port: number | undefined
 
  getRequestHandler(): RequestHandler
  prepare(serverFields?: ServerFields): Promise<void>
  /** @deprecated Configure `assetPrefix` in `next.config.js` instead. */
  setAssetPrefix(assetPrefix: string): void
  close(): Promise<void>
 
  // used internally
  getUpgradeHandler(): UpgradeHandler
 
  // legacy methods that we left exposed in the past
 
  /** @deprecated Use application logging instead. */
  logError(...args: Parameters<NextNodeServer['logError']>): void
 
  /** @deprecated Use documented application revalidation APIs instead. */
  revalidate(
    ...args: Parameters<NextNodeServer['revalidate']>
  ): ReturnType<NextNodeServer['revalidate']>
 
  /** @deprecated Use application logging instead. */
  logErrorWithOriginalStack(err: unknown, type: string): void
 
  /**
   * @deprecated Use `app.getRequestHandler()` with an adjusted parsed URL instead.
   */
  render(
    ...args: Parameters<NextNodeServer['render']>
  ): ReturnType<NextNodeServer['render']>
 
  /**
   * @deprecated Use `app.getRequestHandler()` with an adjusted parsed URL instead.
   */
  renderToHTML(
    ...args: Parameters<NextNodeServer['renderToHTML']>
  ): ReturnType<NextNodeServer['renderToHTML']>
 
  /**
   * @deprecated Use `app.getRequestHandler()` with an adjusted parsed URL instead.
   */
  renderError(
    ...args: Parameters<NextNodeServer['renderError']>
  ): ReturnType<NextNodeServer['renderError']>
 
  /**
   * @deprecated Use `app.getRequestHandler()` with an adjusted parsed URL instead.
   */
  renderErrorToHTML(
    ...args: Parameters<NextNodeServer['renderErrorToHTML']>
  ): ReturnType<NextNodeServer['renderErrorToHTML']>
 
  /**
   * @deprecated Use `app.getRequestHandler()` with an adjusted parsed URL instead.
   */
  render404(
    ...args: Parameters<NextNodeServer['render404']>
  ): ReturnType<NextNodeServer['render404']>
}

Copy"script.js",
"script.d.ts",
"server.js",
"server.d.ts",
"head.js",
"head.d.ts",
"image.js",
"image.d.ts",
"image-optimizer-transform.js",
"image-optimizer-transform.d.ts",
"link.js",
"link.d.ts",
"offline.js",
"offline.d.ts",
"form.js",
"form.d.ts",
"router.js",
"router.d.ts",

Copymodule.exports = require('./dist/client/script')

Copymodule.exports = require('./dist/client/router')

Copymodule.exports = require('./dist/pages/_app')

Copyexport { default } from '../client/router'
export * from '../client/router'

Copyexport * from '../server/web/exports/index'

Copyexport * from '../client/components/navigation.react-server'

Copy"files": [
  "AGENTS.md",
  "analyze",
  "dist",
  "app.js",
  "app.d.ts",
]

Copyif (process.env.NEXT_RUNTIME === 'edge') {
  module.exports = require('next/dist/server/route-modules/pages/module.js')
} else {
  if (process.env.NODE_ENV === 'development') {
    if (process.env.TURBOPACK) {
      module.exports = require('next/dist/compiled/next-server/pages-turbo.runtime.dev.js')
    } else {
      module.exports = require('next/dist/compiled/next-server/pages.runtime.dev.js')
    }
  } else {
    if (process.env.TURBOPACK) {
      module.exports = require('next/dist/compiled/next-server/pages-turbo.runtime.prod.js')
    } else {
      module.exports = require('next/dist/compiled/next-server/pages.runtime.prod.js')
    }
  }
}

Copyif (process.env.NEXT_RUNTIME === 'edge') {
  module.exports = require('next/dist/server/route-modules/app-page/module.js')
} else {
  if (process.env.__NEXT_EXPERIMENTAL_REACT) {
    if (process.env.NODE_ENV === 'development') {
      if (process.env.TURBOPACK) {
        module.exports = require('next/dist/compiled/next-server/app-page-turbo-experimental.runtime.dev.js')
      } else {
        module.exports = require('next/dist/compiled/next-server/app-page-experimental.runtime.dev.js')
      }
    } else {
      if (process.env.TURBOPACK) {
        module.exports = require('next/dist/compiled/next-server/app-page-turbo-experimental.runtime.prod.js')
      } else {
        module.exports = require('next/dist/compiled/next-server/app-page-experimental.runtime.prod.js')
      }
    }
  } else {
    if (process.env.NODE_ENV === 'development') {
      if (process.env.TURBOPACK) {
        module.exports = require('next/dist/compiled/next-server/app-page-turbo.runtime.dev.js')
      } else {
        module.exports = require('next/dist/compiled/next-server/app-page.runtime.dev.js')
      }
    } else {
      if (process.env.TURBOPACK) {
        module.exports = require('next/dist/compiled/next-server/app-page-turbo.runtime.prod.js')
      } else {
        module.exports = require('next/dist/compiled/next-server/app-page.runtime.prod.js')
      }
    }
  }
}

Copyif (process.env.NEXT_RUNTIME === 'edge') {
  module.exports = require('next/dist/server/route-modules/app-route/module.js')
} else {
  if (process.env.__NEXT_EXPERIMENTAL_REACT) {
    if (process.env.NODE_ENV === 'development') {
      if (process.env.TURBOPACK) {
        module.exports = require('next/dist/compiled/next-server/app-route-turbo-experimental.runtime.dev.js')
      } else {
        module.exports = require('next/dist/compiled/next-server/app-route-experimental.runtime.dev.js')
      }
    } else {
      if (process.env.TURBOPACK) {
        module.exports = require('next/dist/compiled/next-server/app-route-turbo-experimental.runtime.prod.js')
      } else {
        module.exports = require('next/dist/compiled/next-server/app-route-experimental.runtime.prod.js')
      }
    }
  } else {
    if (process.env.NODE_ENV === 'development') {
      if (process.env.TURBOPACK) {
        module.exports = require('next/dist/compiled/next-server/app-route-turbo.runtime.dev.js')
      } else {
        module.exports = require('next/dist/compiled/next-server/app-route.runtime.dev.js')
      }
    } else {
      if (process.env.TURBOPACK) {
        module.exports = require('next/dist/compiled/next-server/app-route-turbo.runtime.prod.js')
      } else {
        module.exports = require('next/dist/compiled/next-server/app-route.runtime.prod.js')
      }
    }
  }
}

Copyimport '../../server/web/globals'
import {
  adapter,
  type EdgeHandler,
  type NextRequestHint,
} from '../../server/web/adapter'
import { IncrementalCache } from '../../server/lib/incremental-cache'
import * as cacheHandlers from '../../server/use-cache/handlers'
 
import Document from 'VAR_MODULE_DOCUMENT'
import * as appMod from 'VAR_MODULE_APP'
import * as userlandPage from 'VAR_USERLAND'
import * as userlandErrorPage from 'VAR_MODULE_GLOBAL_ERROR'
 
declare const userland500Page: any
declare const incrementalCacheHandler: any
// OPTIONAL_IMPORT:* as userland500Page
// OPTIONAL_IMPORT:incrementalCacheHandler
 
import RouteModule, {
  type PagesRouteHandlerContext,
} from '../../server/route-modules/pages/module'
import { WebNextRequest, WebNextResponse } from '../../server/base-http/web'
 
import type { NextFetchEvent } from '../../server/web/spec-extension/fetch-event'
import type RenderResult from '../../server/render-result'
import type { RenderResultMetadata } from '../../server/render-result'
import {
  getTracer,
  SpanKind,
  SpanStatusCode,
  type Span,
} from '../../server/lib/trace/tracer'
import { BaseServerSpan } from '../../server/lib/trace/constants'
import { HTML_CONTENT_TYPE_HEADER } from '../../lib/constants'
import type { RequestMeta } from '../../server/request-meta'
import { toNodeOutgoingHttpHeaders } from '../../server/web/utils'
 
// injected by the loader afterwards.
declare const pageRouteModuleOptions: any
declare const errorRouteModuleOptions: any
declare const user500RouteModuleOptions: any
// INJECT:pageRouteModuleOptions
// INJECT:errorRouteModuleOptions
// INJECT:user500RouteModuleOptions
// INJECT_RAW:cacheHandlerImports
 
const pageMod = {
  ...userlandPage,
  routeModule: new RouteModule({
    ...pageRouteModuleOptions,
    components: {
      App: appMod.default,
      Document,
    },
    userland: userlandPage,
    distDir: process.env.__NEXT_RELATIVE_DIST_DIR || '',
    relativeProjectDir: process.env.__NEXT_RELATIVE_PROJECT_DIR || '',
  }),
}
 
const errorMod = {
  ...userlandErrorPage,
  routeModule: new RouteModule({
    ...errorRouteModuleOptions,
    components: {
      App: appMod.default,
      Document,
    },
    userland: userlandErrorPage,
    distDir: process.env.__NEXT_RELATIVE_DIST_DIR || '',
    relativeProjectDir: process.env.__NEXT_RELATIVE_PROJECT_DIR || '',
  }),
}
 
// FIXME: this needs to be made compatible with the template
const error500Mod = userland500Page
  ? {
      ...userland500Page,
      routeModule: new RouteModule({
        ...user500RouteModuleOptions,
        components: {
          App: appMod.default,
          Document,
        },
        userland: userland500Page,
        distDir: process.env.__NEXT_RELATIVE_DIST_DIR || '',
        relativeProjectDir: process.env.__NEXT_RELATIVE_PROJECT_DIR || '',
      }),
    }
  : null

Copyasync function requestHandler(
  req: NextRequestHint,
  _event: NextFetchEvent
): Promise<Response> {
  let srcPage = 'VAR_DEFINITION_PATHNAME'
 
  const relativeUrl = `${req.nextUrl.pathname}${req.nextUrl.search}`
  const baseReq = new WebNextRequest(req)
  const pageRouteModule = pageMod.routeModule as RouteModule
  const prepareResult = await pageRouteModule.prepare(baseReq, null, {
    srcPage,
    multiZoneDraftMode: false,
  })
 
  if (!prepareResult) {
    return new Response('Bad Request', {
      status: 400,
    })
  }

Copyimport './register-deployment-id-global'
import './webpack'
import '../lib/require-instrumentation-client'
 
import { initialize, hydrate, version, router, emitter } from './'
 
declare global {
  interface Window {
    next: any
  }
}
 
window.next = {
  version,
  // router is initialized later so it has to be live-binded
  get router() {
    return router
  },
  emitter,
}
 
initialize({})
  .then(() => hydrate())
  .catch(console.error)

Copy// TODO: Remove use of `any` type.
import './register-deployment-id-global'
import './webpack'
import { initialize, version, router, emitter } from './'
import initHMR from './dev/hot-middleware-client'
import { pageBootstrap } from './page-bootstrap'
 
window.next = {
  version,
  // router is initialized later so it has to be live-binded
  get router() {
    return router
  },
  emitter,
}
 
const devClient = initHMR()
initialize({ devClient })
  .then(({ assetPrefix }) => {
    return pageBootstrap(assetPrefix)
  })
  .catch((err) => {

Copy// A client-side entry point for Turbopack builds. Includes logic to load chunks,
// but does not include development-time features like hot module reloading.
 
import './register-deployment-id-global'
import '../lib/require-instrumentation-client'
 
// TODO: Remove use of `any` type.
import { initialize, version, router, emitter, hydrate } from './'
 
window.next = {
  version,
  turbopack: true,
  // router is initialized later so it has to be live-binded
  get router() {
    return router
  },
  emitter,
}
;(self as any).__next_set_public_path__ = () => {}
;(self as any).__webpack_hash__ = ''
 
// for the page loader
declare let __turbopack_load__: any
 
initialize({})
  .then(() => {
    // for the page loader
    ;(self as any).__turbopack_load_page_chunks__ = (
      page: string,
      chunksData: any
    ) => {
      const chunkPromises = chunksData.map((c: unknown) =>
        __turbopack_load__(c)
      )
 
      Promise.all(chunkPromises).catch((err) =>
        console.error('failed to load chunks for page ' + page, err)
      )
    }
 
    return hydrate()
  })

Copy// TODO: Remove use of `any` type.
import './register-deployment-id-global'
import { initialize, version, router, emitter } from './'
import initHMR from './dev/hot-middleware-client'
 
import { pageBootstrap } from './page-bootstrap'
//@ts-expect-error requires "moduleResolution": "node16" in tsconfig.json and not .ts extension
import { connect } from '@vercel/turbopack-ecmascript-runtime/browser/dev/hmr-client/hmr-client.ts'
import type { TurbopackMessageSentToBrowser } from '../server/dev/hot-reloader-types'
 
window.next = {
  version,
  turbopack: true,
  // router is initialized later so it has to be live-binded
  get router() {
    return router
  },
  emitter,
}
;(self as any).__next_set_public_path__ = () => {}
;(self as any).__webpack_hash__ = ''
 
// for the page loader
declare let __turbopack_load__: any
 
const devClient = initHMR()
initialize({
  devClient,
})
  .then(({ assetPrefix }) => {
    // for the page loader
    ;(self as any).__turbopack_load_page_chunks__ = (
      page: string,
      chunksData: any
    ) => {
      const chunkPromises = chunksData.map((c: unknown) =>
        __turbopack_load__(c)
      )
 
      Promise.all(chunkPromises).catch((err) =>
        console.error('failed to load chunks for page ' + page, err)
      )
    }
 
    connect({
      addMessageListener(cb: (message: TurbopackMessageSentToBrowser) => void) {
        devClient.addTurbopackMessageListener(cb)
      },
      sendMessage: devClient.sendTurbopackMessage,
      onUpdateError: devClient.handleUpdateError,
      chunkUpdateListenersGlobal:
        process.env.__NEXT_TURBOPACK_CHUNK_UPDATE_LISTENERS_GLOBAL!,
    })
 
    return pageBootstrap(assetPrefix)
  })

Copytype FlightSegment =
  | [isBootStrap: 0]
  | [isNotBootstrap: 1, responsePartial: string]
  | [isFormState: 2, formState: any]
  | [isBinary: 3, responseBase64Partial: string]
 
type NextFlight = Omit<Array<FlightSegment>, 'push'> & {
  push: (seg: FlightSegment) => void
}
 
declare global {
  // If you're working in a browser environment
  interface Window {
    /**
     * request ID, dev-only
     */
    __next_r?: string
    __next_f: NextFlight
  }
}
 
function nextServerDataCallback(seg: FlightSegment): void {
  if (seg[0] === 0) {
    initialServerDataBuffer = []
  } else if (seg[0] === 1) {
    if (!initialServerDataBuffer)
      throw new Error('Unexpected server data: missing bootstrap script.')
 
    if (initialServerDataWriter) {
      initialServerDataWriter.enqueue(encoder.encode(seg[1]))
    } else {
      initialServerDataBuffer.push(seg[1])
    }
  } else if (seg[0] === 2) {
    initialFormStateData = seg[1]
  } else if (seg[0] === 3) {
    if (!initialServerDataBuffer)
      throw new Error('Unexpected server data: missing bootstrap script.')
 
    // Decode the base64 string back to binary data.
    const binaryString = atob(seg[1])
    const decodedChunk = new Uint8Array(binaryString.length)
    for (var i = 0; i < binaryString.length; i++) {
      decodedChunk[i] = binaryString.charCodeAt(i)
    }
 
    if (initialServerDataWriter) {
      initialServerDataWriter.enqueue(decodedChunk)
    } else {
      initialServerDataBuffer.push(decodedChunk)
    }
  }
}

Copyconst nextServerDataLoadingGlobal = (self.__next_f = self.__next_f || [])
 
// Consume all buffered chunks and clear the global data array right after to release memory.
// Otherwise it will be retained indefinitely.
nextServerDataLoadingGlobal.forEach(nextServerDataCallback)
nextServerDataLoadingGlobal.length = 0
 
// Patch its push method so subsequent chunks are handled (but not actually pushed to the array).
nextServerDataLoadingGlobal.push = nextServerDataCallback

Copyfunction nextServerDataRegisterWriter(ctr: ReadableStreamDefaultController) {
  if (initialServerDataBuffer) {
    initialServerDataBuffer.forEach((val) => {
      ctr.enqueue(typeof val === 'string' ? encoder.encode(val) : val)
    })
    if (initialServerDataLoaded && !initialServerDataFlushed) {
      // Instant Navigation Testing API: don't close or error the inline
      // Flight stream. The static shell has no inline Flight data, so the
      // stream is empty. Closing it would cause React to log an error about
      // missing data. Leaving it open lets React treat any holes as
      // "still suspended." Hydration uses the separately fetched RSC payload
      // (self.__next_instant_test), not this stream.
      if (isStreamErrorOrUnfinished(ctr)) {
        if (!instantTestStaticFetch) {
          ctr.error(
            new Error(
              'The connection to the page was unexpectedly closed, possibly due to the stop button being clicked, loss of Wi-Fi, or an unstable internet connection.'
            )
          )
        }
      } else {
        ctr.close()
      }
      initialServerDataFlushed = true
      initialServerDataBuffer = undefined
    }
  }
 
  initialServerDataWriter = ctr
}

Copyexport async function next_compile(task, opts) {
  await task.parallel(
    [
      'cli',
      'copy_bundle_analyzer_ui',
      'bin',
      'server',
      'server_esm',
      'api_esm',
      'nextbuild',
      'nextbuildjest',
      'nextbuildstatic',
      'nextbuildstatic_esm',
      'nextbuild_esm',
      'next_devtools_entrypoint',
      'next_devtools_server',
      'next_devtools_server_esm',
      'next_devtools_shared',
      'next_devtools_shared_esm',
      'next_devtools_userspace',
      'next_devtools_userspace_esm',
      'pages',
      'pages_esm',
      'lib',
      'lib_esm',
      'client',
      'client_esm',
      'diagnostics',
      'telemetry',
      'trace',
      'shared',
      'shared_esm',
      'shared_re_exported',
      'shared_re_exported_esm',
      'server_wasm',
      'experimental_testing',
      'experimental_testmode',
    ],
    opts
  )
}

Copy.source('src/build/**/*.+(js|ts|tsx)', {
  ignore: [
    '**/fixture/**',
    '**/tests/**',
    '**/jest/**',
    '**/*.test.d.ts',
    '**/*.test.+(js|ts|tsx)',
  ],
})