config-shared.ts

import os from 'os'
import type { webpack } from 'next/dist/compiled/webpack/webpack'
import type { Header, Redirect, Rewrite } from '../lib/load-custom-routes'
import { imageConfigDefault } from '../shared/lib/image-config'
import type {
  ImageConfig,
  ImageConfigComplete,
} from '../shared/lib/image-config'
import type { SubresourceIntegrityAlgorithm } from '../build/webpack/plugins/subresource-integrity-plugin'
import type { WEB_VITALS } from '../shared/lib/utils'
import type { NextParsedUrlQuery } from './request-meta'
import type { SizeLimit } from '../types'
import type { SupportedTestRunners } from '../cli/next-test'
import { INFINITE_CACHE } from '../lib/constants'
import { isStableBuild } from '../shared/lib/errors/canary-only-config-error'
import type { FallbackRouteParam } from '../build/static-paths/types'
import type { MemoryEvictionMode } from '../build/swc/types'
import type { CacheLife } from './use-cache/cache-life'

/**
 * The `cacheLife` profiles after config normalization. `config.ts` always
 * backfills the `default` profile so that its `stale`, `revalidate`, and
 * `expire` are all defined, which is why `default` is `Required<CacheLife>`
 * here while other profiles may still be partial. Runtime `"use cache"` code
 * can therefore read `cacheLifeProfiles.default` without re-validating it.
 */
export interface ResolvedCacheLifeProfiles {
  default: Required<CacheLife>
  [profile: string]: CacheLife
}

/**
 * Resolved form of the prefetchInlining config after normalization in
 * config.ts. User input (true, partial objects) is converted to this shape.
 */
export type PrefetchInliningConfig =
  | false
  | { maxSize: number; maxBundleSize: number }

export type NextConfigComplete = Required<
  Omit<
    NextConfig,
    | 'configFile'
    | 'cacheLife'
    | 'expireTime'
    | 'output'
    | 'modularizeImports'
    | 'allowedDevOrigins'
    | 'adapterPath'
  >
> &
  // Don't apply `Required<>` for these properties. They really can be undefined in the finalized config.
  Pick<
    NextConfig,
    | 'cacheLife'
    | 'expireTime'
    | 'output'
    | 'modularizeImports'
    | 'allowedDevOrigins'
    | 'adapterPath'
  > & {
    images: Required<ImageConfigComplete>
    typescript: TypeScriptConfig
    configFile: string | undefined
    configFileName: string
    // Normalized by config.ts: the `default` profile is backfilled to be complete
    // (see `ResolvedCacheLifeProfiles`), unlike the optional/partial user input.
    // Omitted from the base so this is a clean replacement, not an intersection.
    cacheLife: ResolvedCacheLifeProfiles
    // override NextConfigComplete.experimental.htmlLimitedBots to string
    // because it's not defined in NextConfigComplete.experimental
    htmlLimitedBots: string | undefined
    experimental: ExperimentalConfig & {
      // Normalized by config.ts: true and partial objects become resolved objects
      prefetchInlining?: PrefetchInliningConfig
      // Normalized by config.ts: defaulted to 90% of staticPageGenerationTimeout
      useCacheTimeout: number
      // Normalized by config.ts `finalizeConfig`: defaulted to `'warning'`
      instantInsights: { validationLevel: ValidationLevel }
      // Normalized by finalized config with a default and the expected type
      turbopackMemoryEvictionMode: MemoryEvictionMode
    }
    // The root directory of the distDir. In development mode, this is the parent directory of `distDir`
    // since development builds use `{distDir}/dev`. This is used to ensure that the bundler doesn't
    // traverse into the output directory.
    distDirRoot: string
    // The repository root, regardless of overwritten outputFileTracingRoot or turbopack.root.
    repoRoot: string
  }

export type I18NDomains = readonly DomainLocale[]

export interface I18NConfig {
  defaultLocale: string
  domains?: I18NDomains
  localeDetection?: false
  locales: readonly string[]
}

export interface DomainLocale {
  defaultLocale: string
  domain: string
  http?: true
  locales?: readonly string[]
}

export interface TypeScriptConfig {
  /** Do not run TypeScript during production builds (`next build`). */
  ignoreBuildErrors?: boolean
  /** Relative path to a custom tsconfig file */
  tsconfigPath?: string
}

export interface EmotionConfig {
  sourceMap?: boolean
  autoLabel?: 'dev-only' | 'always' | 'never'
  labelFormat?: string
  importMap?: {
    [importName: string]: {
      [exportName: string]: {
        canonicalImport?: [string, string]
        styledBaseImport?: [string, string]
      }
    }
  }
}

export interface StyledComponentsConfig {
  /**
   * Enabled by default in development, disabled in production to reduce file size,
   * setting this will override the default for all environments.
   */
  displayName?: boolean
  topLevelImportPaths?: string[]
  ssr?: boolean
  fileName?: boolean
  meaninglessFileNames?: string[]
  minify?: boolean
  transpileTemplateLiterals?: boolean
  namespace?: string
  pure?: boolean
  cssProp?: boolean
}

export type JSONValue =
  | string
  | number
  | boolean
  | JSONValue[]
  | { [k: string]: JSONValue }

// At the moment, Turbopack options must be JSON-serializable, so restrict values.
export type TurbopackLoaderOptions = Record<string, JSONValue>

export type TurbopackLoaderItem =
  | string
  | {
      loader: string
      options?: TurbopackLoaderOptions
    }

export type TurbopackLoaderBuiltinCondition =
  | 'browser'
  | 'foreign'
  | 'development'
  | 'production'
  | 'node'
  | 'edge-light'

export type TurbopackRuleCondition =
  | { all: TurbopackRuleCondition[] }
  | { any: TurbopackRuleCondition[] }
  | { not: TurbopackRuleCondition }
  | TurbopackLoaderBuiltinCondition
  | {
      path?: string | RegExp
      content?: RegExp
      query?: string | RegExp
      contentType?: string | RegExp
    }

/**
 * The module type to use for matched files. This determines how files are
 * processed without requiring a custom loader.
 *
 * - `'asset'` - Emit the file and return its URL (like webpack's `asset/resource`)
 * - `'ecmascript'` - Process as JavaScript module
 * - `'typescript'` - Process as TypeScript module
 * - `'css'` - Process as CSS file
 * - `'css-module'` - Process as CSS module
 * - `'json'` - Parse as JSON and export it
 * - `'wasm'` - Process as WebAssembly module
 * - `'raw'` - Export file contents as a string (an alias of `'text'`)
 * - `'node'` - Process as native Node.js addon
 * - `'bytes'` - Export file contents as a `Uint8Array`
 * - `'text'` - Export file contents as a string
 *
 * @see [Module Types](https://nextjs.org/docs/app/api-reference/config/next-config-js/turbopack#module-types)
 */
export type TurbopackModuleType =
  | 'asset'
  | 'ecmascript'
  | 'typescript'
  | 'css'
  | 'css-module'
  | 'json'
  | 'wasm'
  | 'raw'
  | 'node'
  | 'bytes'
  | 'text'

export type TurbopackRuleConfigItem = {
  /** Loaders to apply to matched files. */
  loaders?: TurbopackLoaderItem[]
  /** Rename the file extension for loader output (e.g., `'*.js'`). */
  as?: string
  /** Additional conditions for when this rule applies. */
  condition?: TurbopackRuleCondition
  /**
   * Set the module type directly without using a loader.
   * @see [Module Types](https://nextjs.org/docs/app/api-reference/config/next-config-js/turbopack#module-types)
   */
  type?: TurbopackModuleType
}

/**
 * This can be an object representing a single configuration, or a list of
 * loaders and/or rule configuration objects.
 *
 * - A list of loader path strings or objects is the "shorthand" syntax.
 * - A list of rule configuration objects can be useful when each configuration
 *   object has different `condition` fields, but still match the same top-level
 *   path glob.
 */
export type TurbopackRuleConfigCollection =
  | TurbopackRuleConfigItem
  | (TurbopackLoaderItem | TurbopackRuleConfigItem)[]

export interface TurbopackOptions {
  /**
   * (`next --turbopack` only) A mapping of aliased imports to modules to load in their place.
   *
   * @see [Resolve Alias](https://nextjs.org/docs/app/api-reference/config/next-config-js/turbopack#resolving-aliases)
   */
  resolveAlias?: Record<
    string,
    string | string[] | Record<string, string | string[]>
  >

  /**
   * (`next --turbopack` only) A list of extensions to resolve when importing files.
   *
   * @see [Resolve Extensions](https://nextjs.org/docs/app/api-reference/config/next-config-js/turbopack#resolving-custom-extensions)
   */
  resolveExtensions?: string[]

  /**
   * (`next --turbopack` only) A list of webpack loaders to apply when running with Turbopack.
   *
   * @see [Turbopack Loaders](https://nextjs.org/docs/app/api-reference/config/next-config-js/turbopack#configuring-webpack-loaders)
   */
  rules?: Record<string, TurbopackRuleConfigCollection>

  /**
   * This is the repo root usually and only files above this
   * directory can be resolved by turbopack.
   */
  root?: string

  /**
   * Enables generation of debug IDs in JavaScript bundles and source maps.
   * These debug IDs help with debugging and error tracking by providing stable identifiers.
   *
   * @see https://github.com/tc39/ecma426/blob/main/proposals/debug-id.md TC39 Debug ID Proposal
   */
  debugIds?: boolean

  /**
   * An array of issue filter rules to ignore specific Turbopack issues.
   * Each rule must have a `path` field (mandatory) and optionally `title`
   * and `description`. String paths are treated as glob patterns. String
   * titles/descriptions are exact matches. RegExp values match anywhere
   * within the string (use `^` and `$` anchors for full-string matching).
   */
  ignoreIssue?: Array<{
    path: string | RegExp
    title?: string | RegExp
    description?: string | RegExp
  }>

  /**
   * Override the global variable name used for
   * chunk loading. Useful when multiple Turbopack-built apps run on the same
   * page (e.g. horizontal micro-frontends) to avoid `globalThis.TURBOPACK`
   * conflicts.
   *
   * @see https://webpack.js.org/configuration/output/#outputchunkloadingglobal
   */
  chunkLoadingGlobal?: string
}

export interface WebpackConfigContext {
  /** Next.js root directory */
  dir: string
  /** Indicates if the compilation will be done in development */
  dev: boolean
  /** It's `true` for server-side compilation, and `false` for client-side compilation */
  isServer: boolean
  /**  The build id, used as a unique identifier between builds */
  buildId: string
  /** The next.config.js merged with default values */
  config: NextConfigComplete
  /** Default loaders used internally by Next.js */
  defaultLoaders: {
    /** Default babel-loader configuration */
    babel: any
  }
  /** Number of total Next.js pages */
  totalPages: number
  /** The webpack configuration */
  webpack: any
  /** The current server runtime */
  nextRuntime?: 'nodejs' | 'edge'
}

export interface NextJsWebpackConfig {
  (
    /** Existing Webpack config */
    config: any,
    context: WebpackConfigContext
  ): any
}

/**
 * Set of options for React Compiler that Next.js currently supports.
 *
 * These options may be changed in breaking ways at any time without notice
 * while support for React Compiler is experimental.
 *
 * @see https://react.dev/reference/react-compiler/configuration
 */
export interface ReactCompilerOptions {
  /**
   * Controls the strategy for determining which functions the React Compiler
   * will optimize.
   *
   * The default is `'infer'`, which uses intelligent heuristics to identify
   * React components and hooks.
   *
   * When using `infer`, Next.js applies its own heuristics before calling
   * `react-compiler`. This improves compilation performance by avoiding extra
   * invocations of Babel and reducing redundant parsing of code.
   *
   * @see https://react.dev/reference/react-compiler/compilationMode
   */
  compilationMode?: 'infer' | 'annotation' | 'all'
  /**
   * Controls how the React Compiler handles errors during compilation.
   *
   * The default is `'none'`, which skips components which cannot be compiled.
   *
   * @see https://react.dev/reference/react-compiler/panicThreshold
   */
  panicThreshold?: 'none' | 'critical_errors' | 'all_errors'
}

export interface IncomingRequestLoggingConfig {
  /**
   * A regular expression array to match incoming requests that should not be logged.
   * You can specify multiple patterns to match incoming requests that should not be logged.
   */
  ignore?: RegExp[]
}

export interface LoggingConfig {
  fetches?: {
    fullUrl?: boolean
    /**
     * If true, fetch requests that are restored from the HMR cache are logged
     * during an HMR refresh request, i.e. when editing a server component.
     */
    hmrRefreshes?: boolean
  }

  /**
   * If set to false, incoming request logging is disabled.
   * You can specify a pattern to match incoming requests that should not be logged.
   */
  incomingRequests?: boolean | IncomingRequestLoggingConfig

  /**
   * If false, Server Function invocation logging is disabled.
   * @default true
   */
  serverFunctions?: boolean

  /**
   * Forward browser console logs to terminal.
   * - `false`: Disable browser log forwarding
   * - `true`: Forward all browser console output to terminal
   * - `'warn'`: Forward warnings and errors to terminal
   * - `'error'`: Forward only errors to terminal
   */
  browserToTerminal?: boolean | 'error' | 'warn'
}

/**
 * All recognized lightningcss feature names.
 * Individual features map 1:1 to lightningcss `Features` bitflags.
 * Composite names (`selectors`, `media-queries`, `colors`) enable a group of
 * related individual features at once.
 *
 * The name→bitmask mapping is duplicated in:
 * - JS:   `packages/next/src/build/webpack/loaders/lightningcss-loader/src/features.ts`
 * - Rust: `crates/next-core/src/next_config.rs` (`lightningcss_feature_names_to_mask`)
 */
export const LIGHTNINGCSS_FEATURE_NAMES = [
  // Individual features (bit 0–20)
  'nesting',
  'not-selector-list',
  'dir-selector',
  'lang-selector-list',
  'is-selector',
  'text-decoration-thickness-percent',
  'media-interval-syntax',
  'media-range-syntax',
  'custom-media-queries',
  'clamp-function',
  'color-function',
  'oklab-colors',
  'lab-colors',
  'p3-colors',
  'hex-alpha-colors',
  'space-separated-color-notation',
  'font-family-system-ui',
  'double-position-gradients',
  'vendor-prefixes',
  'logical-properties',
  'light-dark',
  // Composite groups
  'selectors',
  'media-queries',
  'colors',
] as const

export type LightningCssFeature = (typeof LIGHTNINGCSS_FEATURE_NAMES)[number]

export interface LightningCssFeatures {
  include?: LightningCssFeature[]
  exclude?: LightningCssFeature[]
}

/**
 * Accepted shapes for `experimental.cssChunking`. See [`ExperimentalConfig.cssChunking`] for the
 * accepted values; use [`resolveCssChunkingMode`] to normalize the value at runtime.
 */
export type CssChunkingConfig =
  | boolean
  | 'strict'
  | 'loose'
  | 'graph'
  | { type: 'strict' }
  | { type: 'loose' }
  | { type: 'graph'; requestCost?: number; weightDistribution?: number }

/**
 * Normalize any [`CssChunkingConfig`] value to one of the four modes the build pipeline cares
 * about:
 *   - `'off'`  — `false`/`undefined`: do not run a CSS chunking plugin.
 *   - `'loose'` — `true` / `'loose'` / `{ type: 'loose' }`: heuristic-based chunking
 *     (the default).
 *   - `'strict'` — `'strict'` / `{ type: 'strict' }`: webpack-only ordered-chunking plugin.
 *   - `'graph'` — `'graph'` / `{ type: 'graph', … }`: Turbopack-only graph algorithm.
 */
export function resolveCssChunkingMode(
  value: CssChunkingConfig | undefined
): 'off' | 'loose' | 'strict' | 'graph' {
  if (value === undefined || value === false) return 'off'
  if (value === true || value === 'loose') return 'loose'
  if (value === 'strict' || value === 'graph') return value
  // Object form. `requestCost` and `weightDistribution` are validated by the schema.
  if (value.type === 'strict') return 'strict'
  if (value.type === 'graph') return 'graph'
  return 'loose'
}

export interface ExperimentalConfig {
  /**
   * @deprecated Use the top-level `outputHashSalt` option instead.
   */
  outputHashSalt?: string

  /**
   * Shows a persistent "Cold cache" badge in the dev overlay after a load that
   * filled an empty cache while streaming. Off by default while the badge's
   * UI/UX is iterated on; the transient "Rendering (cold cache)" pill is shown
   * regardless of this flag.
   */
  coldCacheBadge?: boolean
  useSkewCookie?: boolean
  /** @deprecated use top-level `cacheHandlers` instead */
  cacheHandlers?: NextConfig['cacheHandlers']
  multiZoneDraftMode?: boolean
  appNavFailHandling?: boolean
  prerenderEarlyExit?: boolean
  linkNoTouchStart?: boolean
  caseSensitiveRoutes?: boolean
  /**
   * The origins that are allowed to write the rewritten headers when
   * performing a non-relative rewrite. When undefined, no non-relative
   * rewrites will get the rewrite headers.
   */
  clientParamParsingOrigins?: string[]
  /**
   * Caches subsets of a route, seeded from actual navigations, so subsequent
   * navigations to the same or similar pages can be served instantly. Requires
   * Cache Components.
   */
  cachedNavigations?: boolean
  dynamicOnHover?: boolean
  useOffline?: boolean
  optimisticRouting?: boolean
  /**
   * Replaces the client router's sequential action queue with a rewritten
   * concurrent implementation. The implementations are swapped at the module
   * level by the bundler; the inactive one is not included in the bundle.
   */
  concurrentRouterQueue?: boolean
  instrumentationClientRouterTransitionEvents?: boolean
  varyParams?: boolean
  prefetchInlining?:
    | boolean
    | {
        maxSize?: number
        maxBundleSize?: number
      }
  preloadEntriesOnStart?: boolean
  clientRouterFilter?: boolean
  clientRouterFilterRedirects?: boolean
  /**
   * This config can be used to override the cache behavior for the client router.
   * These values indicate the time, in seconds, that the cache should be considered
   * reusable. When the `prefetch` Link prop is left unspecified, this will use the `dynamic` value.
   * When the `prefetch` Link prop is set to `true`, this will use the `static` value.
   */
  staleTimes?: {
    dynamic?: number
    /** Must be greater than or equal to 30 seconds, to ensure prefetching is not completely wasteful */
    static?: number
  }
  /**
   * @deprecated use top-level `cacheLife` instead
   */
  cacheLife?: NextConfig['cacheLife']
  // decimal for percent for possible false positives
  // e.g. 0.01 for 10% potential false matches lower
  // percent increases size of the filter
  clientRouterFilterAllowedRate?: number
  /**
   * @deprecated Use `externalProxyRewritesResolve` instead.
   */
  externalMiddlewareRewritesResolve?: boolean
  externalProxyRewritesResolve?: boolean
  /**
   * Exposes the Instant Navigation Testing API in production builds. This
   * API is always available in development mode.
   *
   * The testing API allows e2e tests to control navigation timing, enabling
   * deterministic assertions on prefetched/cached UI before dynamic data
   * streams in.
   *
   * WARNING: This flag is intended for profiling and testing purposes only.
   * Do not enable in user-facing production deployments.
   */
  exposeTestingApiInProductionBuild?: boolean
  /**
   * Show Request Insights in the dev tools indicator. Request Insights records
   * the local framework spans needed to explain App Router request, render,
   * fetch, and cache behavior without requiring an external OTEL collector.
   */
  requestInsights?: boolean
  extensionAlias?: Record<string, any>
  allowedRevalidateHeaderKeys?: string[]
  fetchCacheKeyPrefix?: string
  imgOptConcurrency?: number | null
  imgOptOperationCache?: boolean | null
  imgOptTimeoutInSeconds?: number
  imgOptMaxInputPixels?: number
  imgOptSequentialRead?: boolean | null
  optimisticClientCache?: boolean
  /**
   * @deprecated use config.expireTime instead
   */
  expireTime?: number
  /**
   * @deprecated Use `proxyPrefetch` instead.
   */
  middlewarePrefetch?: 'strict' | 'flexible'
  proxyPrefetch?: 'strict' | 'flexible'
  manualClientBasePath?: boolean
  /**
   * CSS Chunking strategy. Defaults to `true` (loose mode), which guesses dependencies between
   * CSS files to keep ordering of them.
   *
   * - `true` / `'loose'` / `{ type: 'loose' }` — default heuristic-based chunking.
   * - `'strict'` / `{ type: 'strict' }` — preserve correct ordering as much as possible, even
   *   when this leads to many requests. Webpack only.
   * - `false` — disable chunking; emit one chunk per CSS module. Webpack only.
   * - `'graph'` / `{ type: 'graph', requestCost?, weightDistribution? }` — Turbopack only.
   *   Selects a CSS chunking strategy that analyzes the most common style orderings across the
   *   application and produces shared chunks accordingly. Compared to the default mode it
   *   intentionally overships some styles in order to reduce the number of CSS requests per
   *   page. Cost overrides:
   *     - `requestCost` (bytes, default `100000`) — additional cost charged for every CSS
   *       request a chunk group makes. Larger values bias the algorithm toward fewer, larger
   *       shared chunks; smaller values toward more, smaller chunks.
   *     - `weightDistribution` (default `0.1`) — controls how a chunk's cost is distributed across
   *       the chunk groups that load it, via a per-group weight of
   *       `groupSize ^ (-weightDistribution)`. `0` weights every chunk group equally; higher
   *       values give smaller chunk groups more weight, so small pages ship fewer unrelated
   *       styles at the expense of more requests overall.
   */
  cssChunking?: CssChunkingConfig
  /**
   * Controls whether the development server automatically restarts when its
   * heap usage exceeds the memory threshold. Defaults to `true`.
   */
  devMemoryThresholdRestart?: boolean
  disablePostcssPresetEnv?: boolean
  cpus?: number
  memoryBasedWorkersCount?: boolean
  proxyTimeout?: number
  isrFlushToDisk?: boolean
  workerThreads?: boolean
  // optimizeCss can be boolean or critters' option object
  // Use Record<string, unknown> as critters doesn't export its Option type
  // https://github.com/GoogleChromeLabs/critters/blob/a590c05f9197b656d2aeaae9369df2483c26b072/packages/critters/src/index.d.ts
  optimizeCss?: boolean | Record<string, unknown>
  nextScriptWorkers?: boolean
  scrollRestoration?: boolean
  externalDir?: boolean
  disableOptimizedLoading?: boolean

  /** @deprecated A no-op as of Next 16, size metrics were removed from the build output. */
  gzipSize?: boolean
  craCompat?: boolean
  esmExternals?: boolean | 'loose'
  fullySpecified?: boolean
  urlImports?: NonNullable<webpack.Configuration['experiments']>['buildHttp']
  swcTraceProfiling?: boolean
  forceSwcTransforms?: boolean

  swcPlugins?: Array<[string, Record<string, unknown>]>

  /**
   * Additional options for SWC's preset-env (`env` configuration).
   * These are merged into the `env` block that Next.js passes to SWC,
   * alongside the browserslist-derived `targets`.
   *
   * See https://swc.rs/docs/configuration/supported-browsers for full details.
   *
   * @example
   * ```js
   * // next.config.js
   * module.exports = {
   *   experimental: {
   *     swcEnvOptions: {
   *       mode: 'usage',
   *       coreJs: '3.38',
   *     },
   *   },
   * }
   * ```
   */
  swcEnvOptions?: {
    /**
     * Polyfill injection mode, matching Babel's `useBuiltIns`.
     * - `'usage'`: Adds specific polyfill imports per file based on actual usage.
     * - `'entry'`: Replaces a single `import 'core-js'` with only the polyfills
     *   needed for the target browsers.
     */
    mode?: 'usage' | 'entry'
    /** The core-js version to use (e.g. `'3.38'`). Required when `mode` is set. */
    coreJs?: string
    /** Core-js modules or SWC transform passes to skip. */
    skip?: string[]
    /** Core-js modules or SWC transform passes to always include. */
    include?: string[]
    /** Core-js modules or SWC transform passes to always exclude. */
    exclude?: string[]
    /** Enable shipped TC39 proposals. */
    shippedProposals?: boolean
    /** Force all transforms regardless of targets. */
    forceAllTransforms?: boolean
    /** Enable debug output for preset-env. */
    debug?: boolean
    /** Enable loose mode for transforms. */
    loose?: boolean
  }

  largePageDataBytes?: number
  /**
   * If set to `false`, webpack won't fall back to polyfill Node.js modules in the browser
   * Full list of old polyfills is accessible here:
   * [webpack/webpack#ModuleNotoundError.js#L13-L42](https://github.com/webpack/webpack/blob/2a0536cf510768111a3a6dceeb14cb79b9f59273/lib/ModuleNotFoundError.js#L13-L42)
   */
  fallbackNodePolyfills?: false
  sri?: {
    algorithm?: SubresourceIntegrityAlgorithm
  }

  webVitalsAttribution?: Array<(typeof WEB_VITALS)[number]>

  /**
   * Automatically apply the "modularizeImports" optimization to imports of the specified packages.
   */
  optimizePackageImports?: string[]

  /**
   * Optimize React APIs for server builds.
   */
  optimizeServerReact?: boolean

  /**
   * Type-checks props and return values of pages.
   * Requires literal values for segment config (e.g. `export const dynamic = 'force-static' as const`).
   */
  strictRouteTypes?: boolean

  /**
   * Runs the project-local TypeScript CLI instead of using TypeScript's
   * programmatic API for build-time type checking and config loading.
   */
  useTypeScriptCli?: boolean

  /**
   * Displays an indicator when a React Transition has no other indicator rendered.
   * This includes displaying an indicator on client-side navigations.
   */
  transitionIndicator?: boolean

  /**
   * Enables experimental gesture transition APIs for optimistic client
   * navigations. Requires experimental React.
   */
  gestureTransition?: boolean

  /**
   * Controls Turbopack's memory eviction strategy for development sessions
   *
   * Only effective in dev sessions where
   * `experimental.turbopackFileSystemCacheForDev` is enabled (which it is by default).
   *
   * - `false`: disable eviction.
   * - `'full'`: after every snapshot, drop as much memory as possible.
   * - `'auto'`: evict after a snapshot when we expect to save a lot of memory or the system is under pressure
   *
   * Defaults to `'auto'`
   */
  turbopackMemoryEviction?: false | 'full' | 'auto'

  /**
   * Selects the backend used by Turbopack for Node.js evaluation, e.g. webpack
   * loaders, Babel, or PostCSS.
   *
   * This defaults to `'childProcesses'`, which creates a pool of child node.js
   * processes and communciates with them over sockets.
   *
   * `'workerThreads'` runs the same work in worker threads instead, which should
   * use less memory and CPU. It may become the default in a future version of
   * Next.js.
   */
  turbopackPluginRuntimeStrategy?: 'workerThreads' | 'childProcesses'

  /**
   * Enable minification. Defaults to true in build mode and false in dev mode.
   *
   * Pass an object to configure each environment separately, e.g.
   * `{ server: false, client: true }`. The `server` option takes precedence
   * over `experimental.serverMinification`.
   *
   * We don't recommend disabling minification in production. Disabling it
   * increases server function size, slows down cold starts, and leads to
   * degraded performance.
   */
  turbopackMinify?:
    | boolean
    | { server?: boolean; client?: boolean; edge?: boolean }

  /**
   * Enable support for `with {type: "bytes"}` for ESM imports.
   */
  turbopackImportTypeBytes?: boolean

  /**
   * Enable scope hoisting. Defaults to true in build mode. Always disabled in development mode.
   */
  turbopackScopeHoisting?: boolean

  /**
   * Share the browser runtime across routes in a single `runtime.js` asset and inline the
   * per-route chunk-group bootstrap into the HTML, dropping the per-route runtime. Defaults to
   * true on canary releases and false on stable releases. Only applies to production builds; has
   * no effect in development mode.
   */
  turbopackSharedRuntime?: boolean

  /**
   * (`next --turbopack` only) These options change the assumptions Turbopack makes when
   * making chunk merging decisions and the raw size thresholds it uses.
   */
  turbopackChunking?: {
    /**
     * Groups of pages commonly visited together, each defined by a list of regular
     * expressions matched against the route pathname.
     *
     * @example
     * ```js
     * clusters: [
     *   [/^\/dashboard/, /^\/dashboard\/settings/],
     *   [/^\/blog/, /^\/blog\/[^/]+$/],
     * ]
     * ```
     */
    clusters?: RegExp[][]
    /**
     * This is a number between `0..1`, when higher, we weight the benefits of
     * merging chunks for a signal page load higher. If you don't know a good
     * number for this, your bounce rate is a good approximate for this value.
     */
    firstPageLoadPriority?: number
    /**
     * Regular expressions matching routes that are often the first page
     * visited and whose client-side bundles should be merged more eagerly to reduce the single-route
     * request cost (e.g. the homepage). This is at the cost of extra requests on other pages.
     */
    priorityRoutes?: RegExp[]
    /**
     * How much more eagerly to merge the client-side bundles of
     * `priorityRoutes` routes, as a multiplier on their single-request probability (default
     * `1.5`). Higher values merge more aggressively for those routes at the cost of extra requests
     * elsewhere.
     */
    priorityBoost?: number
    /**
     * Estimated cost of an additional request, in bytes (uncompressed
     * and unminfified bytes of code, default is 200 KB), used by the chunker to
     * trade off request count against preventing double-fetching. Uncompressed and unminfified code
     * is approximately 5x the size of compressed and minified code.
     */
    requestCost?: number
    /**
     * Avoid creating more than one chunk smaller than this size, in bytes. Smaller
     * chunks are merged into bigger ones to avoid that. Defaults to `50000` (50 KB).
     */
    minChunkSize?: number
    /**
     * Avoid creating more than this number of chunks per chunk group. Chunks are
     * merged into bigger ones to avoid that. Defaults to `40`.
     */
    maxChunkCountPerGroup?: number
    /**
     * Never merge chunks bigger than this size, in bytes, with other chunks. This keeps code
     * in big chunks from being duplicated across multiple chunks. Defaults to `200000` (200 KB).
     */
    maxMergeChunkSize?: number
    /**
     * Emit each merged production chunk's constituent component chunks alongside it, so the
     * browser runtime can load only the ones it doesn't already have. Defaults to `false`.
     */
    generateComponentChunks?: boolean
    /**
     * Minimum size, in bytes, for a component chunk to be emitted on its own when
     * `generateComponentChunks` is enabled. Component chunks smaller than this are folded into a
     * single remainder chunk. Defaults to `20000` (20 KB).
     */
    minComponentChunkSize?: number
  }

  /**
   * (`next --turbopack` only) A custom URL prefix for Web Worker URLs
   * produced by `new Worker(new URL(..., import.meta.url))` — both the
   * entrypoint URL and the module chunks loaded inside the worker —
   * overriding `assetPrefix` for those URLs.
   *
   * Use this when `assetPrefix` points to a cross-origin CDN: browsers
   * reject cross-origin Worker construction, so the entrypoint must stay
   * same-origin. Module chunks loaded inside the worker are also routed
   * through this prefix because the worker bootstrap requires them to be
   * same-origin with the entrypoint. Mirrors webpack's
   * `output.workerPublicPath`.
   *
   * Like `assetPrefix`, the value is a prefix without a trailing slash and
   * without `/_next` — `/_next/` is appended automatically. An empty
   * string is treated as a literal empty prefix (resulting in same-origin
   * `/_next/...` URLs); only `undefined` falls back to `assetPrefix`.
   *
   * @example
   * ```js
   * // next.config.js
   * module.exports = {
   *   assetPrefix: 'https://cdn.example.com',
   *   experimental: {
   *     turbopackWorkerAssetPrefix: '',
   *   },
   * }
   * ```
   */
  turbopackWorkerAssetPrefix?: string

  /**
   * Enable nested async chunking for client side assets. Defaults to true in build mode and false in dev mode.
   * This optimization computes all possible paths through dynamic imports in the applications to figure out the modules needed at dynamic imports for every path.
   */
  turbopackClientSideNestedAsyncChunking?: boolean

  /**
   * Enable nested async chunking for server side assets. Defaults to false in dev and build mode.
   * This optimization computes all possible paths through dynamic imports in the applications to figure out the modules needed at dynamic imports for every path.
   */
  turbopackServerSideNestedAsyncChunking?: boolean

  /**
   * Enable filesystem cache for the turbopack dev server.
   *
   * Defaults to `true`.
   */
  turbopackFileSystemCacheForDev?: boolean

  /**
   * Enable filesystem cache for the turbopack build.
   *
   * Defaults to `true`.
   */
  turbopackFileSystemCacheForBuild?: boolean

  /**
   * When running inside a git worktree, warm-start this worktree's Turbopack
   * filesystem cache by seeding it from the main checkout's cache if the
   * worktree doesn't have one yet. This is best-effort and never fails a build.
   *
   * Defaults to `false`.
   */
  turbopackSeedCacheFromWorktree?: boolean

  /**
   * Enable source maps. Defaults to true.
   */
  turbopackSourceMaps?: boolean

  /**
   * Enable extraction of source maps from input files. Defaults to true.
   */
  turbopackInputSourceMaps?: boolean

  /**
   * Currently in active development. This splits modules into fragments and
   * chunks only import the used fragments of the modules.
   */
  turbopackModuleFragments?: boolean

  /**
   * Enable removing unused imports for turbopack dev server and build.
   */
  turbopackRemoveUnusedImports?: boolean

  /**
   * Enable removing unused exports for turbopack dev server and build.
   */
  turbopackRemoveUnusedExports?: boolean

  /**
   * Enable local analysis to infer side effect free modules. When enabled, Turbopack will
   * analyze module code to determine if it has side effects. This can improve tree shaking
   * and bundle size at the cost of some additional analysis.
   *
   * Defaults to `true`
   */
  turbopackInferModuleSideEffects?: boolean

  /**
   * Enable tree shaking of unused exports from analyzable CommonJS modules in Turbopack.
   *
   * Defaults to `false`
   */
  turbopackCjsTreeShaking?: boolean

  /**
   * Enable scope hoisting of static CommonJS modules.
   *
   * Defaults to `false`
   */
  turbopackCjsScopeHoisting?: boolean

  /**
   * Set this to `false` to disable the automatic configuration of the babel loader when a Babel
   * configuration file is present. This option is enabled by default.
   *
   * If this is set to `false`, but `reactCompiler` is `true`, the built-in Babel will
   * still be configured, but any Babel configuration files on disk will be ignored. If you wish to
   * use React Compiler with a different manually-configured `babel-loader`, you should disable both
   * this and `reactCompiler`.
   */
  turbopackUseBuiltinBabel?: boolean

  /**
   * Set this to `false` to disable the automatic configuration of the sass loader. The sass loader
   * configuration is enabled by default.
   */
  turbopackUseBuiltinSass?: boolean

  /**
   * Enable per-directory PostCSS config resolution for Turbopack. When enabled,
   * Turbopack searches for `postcss.config.js` starting from the CSS file's
   * parent directory first, then falls back to the project root. When disabled
   * (default), the project root is checked first, with the CSS file's directory
   * as a fallback.
   */
  turbopackLocalPostcssConfig?: boolean

  /**
   * The module ID strategy to use for Turbopack.
   * If not set, the default is `'named'` for development and `'deterministic'`
   * for production.
   */
  turbopackModuleIds?: 'named' | 'deterministic'

  /**
   * Enable server-side Fast Refresh (Hot Module Replacement) during development
   * with Turbopack. When set to `false`, server-side HMR is disabled and a full
   * restart is performed on server file changes.
   *
   * Can also be controlled via the `--no-server-fast-refresh` CLI flag.
   * If both are set, the CLI flag takes precedence.
   *
   * @default true
   */
  turbopackServerFastRefresh?: boolean

  /**
   * For use with `@next/mdx`. Compile MDX files using the new Rust compiler.
   * @see https://nextjs.org/docs/app/api-reference/next-config-js/mdxRs
   */
  mdxRs?:
    | boolean
    | {
        development?: boolean
        jsx?: boolean
        jsxRuntime?: string
        jsxImportSource?: string
        providerImportSource?: string
        mdxType?: 'gfm' | 'commonmark'
      }

  /**
   * Enable type checking for Link and Router.push, etc.
   * @deprecated Use `typedRoutes` instead — this feature is now stable.
   * @see https://nextjs.org/docs/app/api-reference/config/typescript#statically-typed-links
   */
  typedRoutes?: boolean

  /**
   * Enable type-checking and autocompletion for environment variables.
   *
   * @default false
   */
  typedEnv?: boolean

  /**
   * Runs the compilations for server and edge in parallel instead of in serial.
   * This will make builds faster if there is enough server and edge functions
   * in the application at the cost of more memory.
   *
   * NOTE: This option is only valid when the build process can use workers. See
   * the documentation for `webpackBuildWorker` for more details.
   */
  parallelServerCompiles?: boolean

  /**
   * Runs the logic to collect build traces for the server routes in parallel
   * with other work during the compilation. This will increase the speed of
   * the build at the cost of more memory. This option may incur some additional
   * work compared to if the option was disabled since the work is started
   * before data from the client compilation is available to potentially reduce
   * the amount of code that needs to be traced. Despite that, this may still
   * result in faster builds for some applications.
   *
   * Valid values are:
   * - `true`: Collect the server build traces in parallel.
   * - `false`: Do not collect the server build traces in parallel.
   * - `undefined`: Collect server build traces in parallel only in the `experimental-compile` mode.
   *
   * NOTE: This option is only valid when the build process can use workers. See
   * the documentation for `webpackBuildWorker` for more details.
   */
  parallelServerBuildTraces?: boolean

  /**
   * Run the Webpack build in a separate process to optimize memory usage during build.
   * Valid values are:
   * - `false`: Disable the Webpack build worker
   * - `true`: Enable the Webpack build worker
   * - `undefined`: Enable the Webpack build worker only if the webpack config is not customized
   */
  webpackBuildWorker?: boolean

  /**
   * Enables optimizations to reduce memory usage in Webpack. This reduces the max size of the heap
   * but may increase compile times slightly.
   * Valid values are:
   * - `false`: Disable Webpack memory optimizations (default).
   * - `true`: Enables Webpack memory optimizations.
   */
  webpackMemoryOptimizations?: boolean

  /**
   * The array of the meta tags to the client injected by tracing propagation data.
   */
  clientTraceMetadata?: string[]

  /**
   * @deprecated This configuration option has been merged into `cacheComponents`.
   * The Partial Prerendering feature is still available via `cacheComponents`.
   */
  ppr?: boolean | 'incremental'

  /**
   * Enables experimental taint APIs in React.
   * Using this feature will enable the `react@experimental` for the `app` directory.
   */
  taint?: boolean

  /**
   * Enables blocking server-side rendering for the `app` directory: React emits
   * a `<link rel="expect">` tag that holds the browser's first paint until the
   * streamed shell is coherent, avoiding the layout shift / flicker that can
   * occur while a partially-streamed HTML document is painted. Note that
   * `rel="expect"` is currently only implemented by Chromium-based browsers.
   *
   * This feature is currently only available in React's experimental release
   * channel, so enabling it opts the `app` directory into `react@experimental`
   * (the same channel used by `taint`, `transitionIndicator`, and
   * `gestureTransition`). The name mirrors React's underlying feature flag.
   *
   * This is an opt-in only. Setting it to `false` does not disable the
   * experimental channel when another feature (such as `taint`,
   * `transitionIndicator`, or `gestureTransition`) requires it.
   */
  blockingSSR?: boolean

  /**
   * Uninstalls all "unhandledRejection" and "uncaughtException" listeners from
   * the global process so that we can override the behavior, which in some
   * runtimes is to exit the process.
   *
   * This is experimental until we've considered the impact in various
   * deployment environments.
   */
  removeUncaughtErrorAndRejectionListeners?: boolean

  /**
   * During an RSC request, validates that the request headers match the
   * cache-busting search parameter sent by the client.
   */
  validateRSCRequestHeaders?: boolean

  serverActions?: {
    /**
     * Allows adjusting body parser size limit for server actions.
     */
    bodySizeLimit?: SizeLimit

    /**
     * Allowed origins that can bypass Server Action's CSRF check. This is helpful
     * when you have reverse proxy in front of your app.
     * @example
     * ["my-app.com", "*.my-app.com"]
     */
    allowedOrigins?: string[]
  }

  /**
   * Allows adjusting the maximum size of the postponed state body for PPR
   * resume requests. This includes the Resume Data Cache (RDC) which may grow
   * large for some applications.
   * @default '100 MB'
   */
  maxPostponedStateSize?: SizeLimit

  /**
   * Disables compression of the Resume Data Cache (RDC) when persisting
   * postponed state.
   * @default false
   */
  disableResumeDataCacheCompression?: boolean

  /**
   * enables the minification of server code.
   *
   * Under Turbopack this is overridden by `experimental.turbopackMinify` when
   * that option specifies a `server` value.
   */
  serverMinification?: boolean

  /**
   * Enables source maps generation for the server production bundle.
   */
  serverSourceMaps?: boolean

  /**
   * @internal Used by the Next.js internals only.
   */
  trustHostHeader?: boolean
  /**
   * @internal Used by the Next.js internals only.
   */
  isExperimentalCompile?: boolean

  useWasmBinary?: boolean

  /**
   * Use lightningcss instead of postcss-loader
   */
  useLightningcss?: boolean

  /**
   * Configure which CSS features lightningcss should always transpile
   * (include) or never transpile (exclude), regardless of browser targets.
   * Requires `useLightningcss: true`.
   */
  lightningCssFeatures?: LightningCssFeatures

  /**
   * Enables `fetch` requests to be proxied to the experimental test proxy server
   */
  testProxy?: boolean

  /**
   * Set a default test runner to be used by `next experimental-test`.
   */
  defaultTestRunner?: SupportedTestRunners
  /**
   * Allow NODE_ENV=development even for `next build`.
   */
  allowDevelopmentBuild?: true
  /**
   * @deprecated use `config.bundlePagesRouterDependencies` instead
   *
   */
  bundlePagesExternals?: boolean
  /**
   * @deprecated use `config.serverExternalPackages` instead
   *
   */
  serverComponentsExternalPackages?: string[]

  /**
   * When enabled, in dev mode, Next.js will send React's debug info through the
   * WebSocket connection, instead of including it in the main RSC payload.
   */
  reactDebugChannel?: boolean

  /**
   * @deprecated use top-level `cacheComponents` instead
   */
  cacheComponents?: boolean

  /**
   * Configuration for instant navigation validation.
   */
  instantInsights?: {
    /**
     * Controls the validation behavior of Instant Insights
     *
     * - `'warning'` (default): Validates all navigations for Instant UI in development
     * - `'manual-warning'`: Validates navigations for Instant UI in development only when configured with `instant` in Pages and Layouts
     * - `'experimental-error'`: Validates all navigations for Instant in development and build. Use with caution.
     * - `'experimental-manual-error'`: Validates navigations for Instant UI in development and build when configured with `instant` in Pages and Layouts. Use with caution.
     */
    validationLevel?: ValidationLevel
  }

  /**
   * Runs development Cache Components validation on a worker thread rather than
   * the main thread, keeping the dev server's event loop responsive during
   * rapid navigation. This covers static-shell validation (which runs on
   * initial load and HMR refresh) as well as instant-navigation validation
   * (when `instant` is configured). Enabled by default; set to `false` to run
   * validation in-process, as an escape hatch to isolate a problem or fall back
   * if the worker misbehaves.
   *
   * Has no effect with Webpack, where validation always runs in process. The
   * worker's thread cannot reach Webpack's dev source maps, so validation
   * errors would be reported without a source location.
   */
  devValidationWorker?: boolean

  /**
   * The number of times to retry static generation (per page) before giving up.
   */
  staticGenerationRetryCount?: number

  /**
   * The amount of pages to export per worker during static generation.
   */
  staticGenerationMaxConcurrency?: number

  /**
   * The minimum number of pages to be chunked into each export worker.
   */
  staticGenerationMinPagesPerWorker?: number

  /**
   * Allows previously fetched data to be re-used when editing server components.
   */
  serverComponentsHmrCache?: boolean

  /**
   * Cancels the render and validation work for a Server Components HMR refresh
   * once a newer refresh supersedes it. Development only.
   */
  serverComponentsHmrCancellation?: boolean

  /**
   * Render <style> tags inline in the HTML for imported CSS assets.
   * Supports app-router in production mode only.
   */
  inlineCss?: boolean

  // TODO: Remove this config when the API is stable.
  /**
   * This config allows you to enable the experimental navigation API `forbidden` and `unauthorized`.
   */
  authInterrupts?: boolean

  /**
   * Seconds before a `'use cache'` fill is considered stalled. Defaults to
   * 90% of `staticPageGenerationTimeout`. In prerender it's clamped to that
   * ceiling so errors surface before the build worker kills the page.
   */
  useCacheTimeout?: number

  /**
   * Enables the use of the `"use cache"` directive.
   * @deprecated use top-level `cacheComponents` instead
   */
  useCache?: boolean

  /**
   * Enables durable `"use cache"` remote cache entries across deployments. Only implemented for
   * Turbopack.
   */
  durableUseCacheEntries?: boolean

  /**
   * Enables detection and reporting of slow modules during development builds.
   * Enabling this may impact build performance to ensure accurate measurements.
   */
  slowModuleDetection?: {
    /**
     * The time threshold in milliseconds for identifying slow modules.
     * Modules taking longer than this build time threshold will be reported.
     */
    buildTimeThresholdMs: number
  }

  /**
   * Enables using the global-not-found.js file in the app directory
   *
   */
  globalNotFound?: boolean

  /**
   * @experimental Use the Rust port of the React compiler (Turbopack only).
   * Requires `reactCompiler` to be enabled.
   */
  turbopackRustReactCompiler?: boolean

  /**
   * Enable debug information to be forwarded from browser to dev server stdout/stderr.
   *
   * - `'warn'` (default): Forward warnings and errors to terminal
   * - `'error'`: Forward only errors to terminal
   * - `'verbose'`: Forward all browser console output to terminal
   * - `true`: Same as 'verbose' - forward all browser console output to terminal
   * - `false`: Disable browser log forwarding to terminal
   * - Object: Enable with custom configuration
   *
   * @deprecated Use `logging.browserToTerminal` instead.
   */
  browserDebugInfoInTerminal?:
    | boolean
    | 'error'
    | 'warn'
    | 'verbose'
    | {
        /**
         * Minimum log level to show in terminal.
         * @default 'verbose' (for object config, to preserve backward compatibility)
         */
        level?: 'error' | 'warn' | 'verbose'

        /**
         * Option to limit stringification at a specific nesting depth when logging circular objects.
         * @default 5
         */
        depthLimit?: number

        /**
         * Maximum number of properties/elements to stringify when logging objects/arrays with circular references.
         * @default 100
         */
        edgeLimit?: number
        /**
         * Whether to include source location information in debug output when available
         */
        showSourceLocation?: boolean
      }

  /**
   * Body size limit for request bodies with middleware configured.
   * Defaults to 10MB. Can be specified as a number (bytes) or string (e.g. '5mb').
   *
   * @deprecated Use `proxyClientMaxBodySize` instead.
   */
  middlewareClientMaxBodySize?: SizeLimit

  /**
   * Body size limit for request bodies with proxy configured.
   * Defaults to 10MB. Can be specified as a number (bytes) or string (e.g. '5mb').
   */
  proxyClientMaxBodySize?: SizeLimit

  /**
   * Enable the Model Context Protocol (MCP) server for AI-assisted development.
   * When enabled, Next.js will expose an MCP server at `/_next/mcp` that provides
   * code intelligence and project context to AI assistants.
   *
   * @default true
   */
  mcpServer?: boolean

  /**
   * Acquires a lockfile at `<distDir>/lock` when starting `next dev` or `next
   * build`. Failing to acquire the lock causes the process to exit with an
   * error message.
   *
   * This is because if multiple processes write to the same `distDir` at the
   * same time, it can mangle the state of the directory. Disabling this option
   * is not recommended.
   *
   * @default true
   */
  lockDistDir?: boolean

  /**
   * Hide logs that occur after a render has already aborted.
   * This can help reduce noise in the console when dealing with aborted renders.
   *
   * @default false
   */
  hideLogsAfterAbort?: boolean

  /**
   * Whether `process.env.NEXT_DEPLOYMENT_ID` is available at runtime in the server (and `next
   * build` doesn't need to embed the deployment ID value into the build output).
   *
   * @default false
   */
  runtimeServerDeploymentId?: boolean

  /**
   * @deprecated Use the top-level `supportsImmutableAssets` option instead.
   */
  supportsImmutableAssets?: boolean

  /**
   * An array of paths in app or pages directories that should wait to be processed
   * until all other entries have been processed. This is useful for deferring
   * compilation of certain routes during development and build.
   */
  deferredEntries?: string[]

  /**
   * An async function that is called and awaited before processing deferred entries.
   * This callback runs after all non-deferred entries have been compiled.
   */
  onBeforeDeferredEntries?: () => Promise<void>

  /**
   * Whether to report inlined system environment variables as warnings or errors.
   * Only supported for Turbopack.
   */
  reportSystemEnvInlining?: 'error' | 'warn'
}

export type ExportPathMap = {
  [path: string]: {
    page: string
    query?: NextParsedUrlQuery

    /**
     * When true, this indicates that this is a pages router page that should
     * be rendered as a fallback.
     *
     * @internal
     */
    _pagesFallback?: boolean

    /**
     * The locale that this page should be rendered in.
     *
     * @internal
     */
    _locale?: string

    /**
     * The path that was used to generate the page.
     *
     * @internal
     */
    _ssgPath?: string

    /**
     * The parameters that are currently unknown.
     *
     * @internal
     */
    _fallbackRouteParams?: readonly FallbackRouteParam[]

    /**
     * @internal
     */
    _isAppDir?: boolean

    /**
     * @internal
     */
    _isDynamicError?: boolean

    /**
     * @internal
     */
    _isRoutePPREnabled?: boolean

    /**
     * When true, the page is prerendered as a fallback shell, while allowing
     * any dynamic accesses to result in an empty shell. This is the case when
     * the app has Cache Components enabled, and
     * there are also routes prerendered with a more complete set of params.
     * Prerendering those routes would catch any invalid dynamic accesses.
     *
     * @internal
     */
    _allowEmptyStaticShell?: boolean

    /**
     * When true, run build-time instant validation for this export path.
     * Only set on the first export entry per page, since validation uses
     * instant.unstable_samples (not actual params from generateStaticParams),
     * so the result is the same for all param combinations.
     *
     * @internal
     */
    _runInstantValidation?: boolean

    /**
     * When true, a fallback shell produced for this export path could later be
     * upgraded to a concrete version (at least one fallback param is a
     * `generateStaticParams` candidate). Threaded into
     * `renderOpts.isFallbackUpgradeable` so the build-baked shell carries the
     * gated `isUpgradeableISRFallback` value.
     *
     * @internal
     */
    _isFallbackUpgradeable?: boolean
  }
}

/**
 * Next.js can be configured through a `next.config.js` file in the root of your project directory.
 *
 * This can change the behavior, enable experimental features, and configure other advanced options.
 *
 * Read more: [Next.js Docs: `next.config.js`](https://nextjs.org/docs/app/api-reference/config/next-config-js)
 */

export type ValidationLevel =
  | 'warning'
  | 'manual-warning'
  | 'experimental-error'
  | 'experimental-manual-error'

export interface NextConfig {
  allowedDevOrigins?: string[]

  exportPathMap?: (
    defaultMap: ExportPathMap,
    ctx: {
      dev: boolean
      dir: string
      outDir: string | null
      distDir: string
      buildId: string
    }
  ) => Promise<ExportPathMap> | ExportPathMap

  /**
   * Internationalization configuration
   *
   * @see [Internationalization docs](https://nextjs.org/docs/advanced-features/i18n-routing)
   */
  i18n?: I18NConfig | null

  /**
   * @see [Next.js TypeScript documentation](https://nextjs.org/docs/app/api-reference/config/typescript)
   */
  typescript?: TypeScriptConfig

  /**
   * Enable type checking for Link and Router.push, etc.
   * This feature requires TypeScript in your project.
   *
   * @see [Typed Links documentation](https://nextjs.org/docs/app/api-reference/config/typescript#statically-typed-links)
   */
  typedRoutes?: boolean

  /**
   * Headers allow you to set custom HTTP headers for an incoming request path.
   *
   * @see [Headers configuration documentation](https://nextjs.org/docs/app/api-reference/config/next-config-js/headers)
   */
  headers?: () => Promise<Header[]> | Header[]

  /**
   * Rewrites allow you to map an incoming request path to a different destination path.
   *
   * @see [Rewrites configuration documentation](https://nextjs.org/docs/app/api-reference/config/next-config-js/rewrites)
   */
  rewrites?: () =>
    | Promise<
        | Rewrite[]
        | {
            beforeFiles?: Rewrite[]
            afterFiles?: Rewrite[]
            fallback?: Rewrite[]
          }
      >
    | Rewrite[]
    | {
        beforeFiles?: Rewrite[]
        afterFiles?: Rewrite[]
        fallback?: Rewrite[]
      }

  /**
   * Redirects allow you to redirect an incoming request path to a different destination path.
   *
   * @see [Redirects configuration documentation](https://nextjs.org/docs/app/api-reference/config/next-config-js/redirects)
   */
  redirects?: () => Promise<Redirect[]> | Redirect[]

  /**
   * @see [Moment.js locales excluded by default](https://nextjs.org/docs/upgrading#momentjs-locales-excluded-by-default)
   */
  excludeDefaultMomentLocales?: boolean

  /**
   * Before continuing to add custom webpack configuration to your application make sure Next.js doesn't already support your use-case
   *
   * @see [Custom Webpack Config documentation](https://nextjs.org/docs/app/api-reference/config/next-config-js/webpack)
   */
  webpack?: NextJsWebpackConfig | null

  /**
   * By default Next.js will redirect urls with trailing slashes to their counterpart without a trailing slash.
   *
   * @default false
   * @see [Trailing Slash Configuration](https://nextjs.org/docs/app/api-reference/config/next-config-js/trailingSlash)
   */
  trailingSlash?: boolean

  /**
   * Next.js comes with built-in support for environment variables
   *
   * @see [Environment Variables documentation](https://nextjs.org/docs/app/api-reference/config/next-config-js/env)
   */
  env?: Record<string, string | undefined>

  /**
   * Destination directory (defaults to `.next`)
   */
  distDir?: string

  /**
   * The build output directory (defaults to `.next`) is now cleared by default except for the Next.js caches.
   */
  cleanDistDir?: boolean

  /**
   * To set up a CDN, you can set up an asset prefix and configure your CDN's origin to resolve to the domain that Next.js is hosted on.
   *
   * @see [CDN Support with Asset Prefix](https://nextjs.org/docs/app/api-reference/config/next-config-js/assetPrefix)
   */
  assetPrefix?: string

  /**
   * The default cache handler for the Pages and App Router uses the filesystem cache. This requires no configuration, however, you can customize the cache handler if you prefer.
   *
   * @see [Configuring Caching](https://nextjs.org/docs/app/building-your-application/deploying#configuring-caching) and the [API Reference](https://nextjs.org/docs/app/api-reference/next-config-js/incrementalCacheHandlerPath).
   */
  cacheHandler?: string | undefined

  /**
   * Path to a custom adapter module for deployment platform integration.
   * Can also be set via the `NEXT_ADAPTER_PATH` environment variable.
   */
  adapterPath?: string

  cacheHandlers?: {
    default?: string
    remote?: string
    static?: string
    [handlerName: string]: string | undefined
  }

  /**
   * Configure the in-memory cache size in bytes. Defaults to 50 MB.
   * If `cacheMaxMemorySize: 0`, this disables in-memory caching entirely.
   *
   * @see [Configuring Caching](https://nextjs.org/docs/app/building-your-application/deploying#configuring-caching).
   */
  cacheMaxMemorySize?: number

  /**
   * By default, `Next` will serve each file in the `pages` folder under a pathname matching the filename.
   * To disable this behavior and prevent routing based set this to `true`.
   *
   * @default true
   * @see [Disabling file-system routing](https://nextjs.org/docs/advanced-features/custom-server#disabling-file-system-routing)
   */
  useFileSystemPublicRoutes?: boolean

  /**
   * @see [Configuring the build ID](https://nextjs.org/docs/app/api-reference/config/next-config-js/generateBuildId)
   */
  generateBuildId?: () => string | null | Promise<string | null>

  /** @see [Disabling ETag Configuration](https://nextjs.org/docs/app/api-reference/config/next-config-js/generateEtags) */
  generateEtags?: boolean

  /** @see [Including non-page files in the pages directory](https://nextjs.org/docs/app/api-reference/config/next-config-js/pageExtensions) */
  pageExtensions?: string[]

  /**
   * Module specifiers that are required for side effects on the client before
   * hydration, in array order, ahead of the user's `instrumentation-client.{ts,js}`.
   * Each entry may be a bare npm package name or a path relative to the project root.
   */
  instrumentationClientInject?: string[]

  /** @see [Compression documentation](https://nextjs.org/docs/app/api-reference/config/next-config-js/compress) */
  compress?: boolean

  /** @see [Disabling x-powered-by](https://nextjs.org/docs/app/api-reference/config/next-config-js/poweredByHeader) */
  poweredByHeader?: boolean

  /** @see [Using the Image Component](https://nextjs.org/docs/app/api-reference/next-config-js/images) */
  images?: ImageConfig

  /** Configure indicators in development environment */
  devIndicators?:
    | false
    | {
        /**
         * Position of the development tools indicator in the browser window.
         * @default "bottom-left"
         * */
        position?: 'top-left' | 'top-right' | 'bottom-left' | 'bottom-right'
      }

  /**
   * Next.js exposes some options that give you some control over how the server will dispose or keep in memory built pages in development.
   *
   * @see [Configuring `onDemandEntries`](https://nextjs.org/docs/app/api-reference/config/next-config-js/onDemandEntries)
   */
  onDemandEntries?: {
    /** period (in ms) where the server will keep pages in the buffer */
    maxInactiveAge?: number
    /** number of pages that should be kept simultaneously without being disposed */
    pagesBufferLength?: number
  }

  /**
   * A unique identifier for a deployment that will be included in each request's query string or header.
   */
  deploymentId?: string

  /**
   * Whether the deployment environment supports immutable assets (assets deployed to
   * `_next/static/immutable` don't need a `?dpl` parameter and can be safely requested across
   * deployments.)
   */
  supportsImmutableAssets?: boolean

  /**
   * Deploy a Next.js application under a sub-path of a domain
   *
   * @see [Base path configuration](https://nextjs.org/docs/app/api-reference/config/next-config-js/basePath)
   */
  basePath?: string

  /** @see [Customizing sass options](https://nextjs.org/docs/app/api-reference/next-config-js/sassOptions) */
  sassOptions?: {
    implementation?: string
    [key: string]: any
  }

  /**
   * Enable browser source map generation during the production build
   *
   * @see [Source Maps](https://nextjs.org/docs/advanced-features/source-maps)
   */
  productionBrowserSourceMaps?: boolean

  /**
   * Enable {@link https://nextjs.org/docs/app/api-reference/config/next-config-js/reactCompiler React Compiler in Next.js}.
   * Configuration accepts partial config object of the Compiler.
   * If provided, the Compiler will be enabled.
   */
  reactCompiler?: boolean | ReactCompilerOptions

  /**
   * Enable react profiling in production
   *
   */
  reactProductionProfiling?: boolean

  /**
   * The Next.js runtime is Strict Mode-compliant.
   *
   * @see [React Strict Mode](https://nextjs.org/docs/app/api-reference/config/next-config-js/reactStrictMode)
   */
  reactStrictMode?: boolean | null

  /**
   * The maximum length of the headers that are emitted by React and added to
   * the response.
   *
   * @see [React Max Headers Length](https://nextjs.org/docs/app/api-reference/config/next-config-js/reactMaxHeadersLength)
   */
  reactMaxHeadersLength?: number

  /**
   * Next.js enables HTTP Keep-Alive by default.
   * You may want to disable HTTP Keep-Alive for certain `fetch()` calls or globally.
   *
   * @see [Disabling HTTP Keep-Alive](https://nextjs.org/docs/app/api-reference/next-config-js/httpAgentOptions)
   */
  httpAgentOptions?: { keepAlive?: boolean }

  /**
   * Timeout after waiting to generate static pages in seconds
   *
   * @default 60
   */
  staticPageGenerationTimeout?: number

  /**
   * Add `"crossorigin"` attribute to generated `<script>` elements generated by `<Head />` or `<NextScript />` components
   *
   *
   * @see [`crossorigin` attribute documentation](https://developer.mozilla.org/docs/Web/HTML/Attributes/crossorigin)
   */
  crossOrigin?: 'anonymous' | 'use-credentials'

  /**
   * Optionally enable compiler transforms
   *
   * @see [Supported Compiler Options](https://nextjs.org/docs/advanced-features/compiler#supported-features)
   */
  compiler?: {
    reactRemoveProperties?:
      | boolean
      | {
          properties?: string[]
        }
    relay?: {
      src: string
      artifactDirectory?: string
      language?: 'typescript' | 'javascript' | 'flow'
      eagerEsModules?: boolean
    }
    removeConsole?:
      | boolean
      | {
          exclude?: string[]
        }
    styledComponents?: boolean | StyledComponentsConfig
    emotion?: boolean | EmotionConfig

    styledJsx?:
      | boolean
      | {
          useLightningcss?: boolean
        }

    /**
     * Replaces variables in your code during compile time. Each key will be
     * replaced with the respective values.
     */
    define?: Record<string, string | number | boolean>

    /**
     * Replaces server-only (Node.js and Edge) variables in your code during compile time.
     * Each key will be replaced with the respective values.
     */
    defineServer?: Record<string, string | number | boolean>

    /**
     * A hook function that executes after production build compilation finishes,
     * but before running post-compilation tasks such as type checking and
     * static page generation.
     */
    runAfterProductionCompile?: (metadata: {
      /**
       * The root directory of the project
       */
      projectDir: string
      /**
       * The build output directory (defaults to `.next`)
       */
      distDir: string
    }) => Promise<void>
  }

  /**
   * The type of build output.
   * - `undefined`: The default build output, `.next` directory, that works with production mode `next start` or a hosting provider like Vercel
   * - `'standalone'`: A standalone build output, `.next/standalone` directory, that only includes necessary files/dependencies. Useful for self-hosting in a Docker container.
   * - `'export'`: An exported build output, `out` directory, that only includes static HTML/CSS/JS. Useful for self-hosting without a Node.js server.
   * @see [Output File Tracing](https://nextjs.org/docs/advanced-features/output-file-tracing)
   * @see [Static HTML Export](https://nextjs.org/docs/advanced-features/static-html-export)
   */
  output?: 'standalone' | 'export'

  /**
   * Automatically transpile and bundle dependencies from local packages (like monorepos) or from external dependencies (`node_modules`). This replaces the
   * `next-transpile-modules` package.
   * @see [transpilePackages](https://nextjs.org/docs/advanced-features/compiler#module-transpilation)
   */
  transpilePackages?: string[]

  /**
   * Options for Turbopack. Temporarily also available as `experimental.turbo` for compatibility.
   */
  turbopack?: TurbopackOptions

  /**
   * @deprecated Use `skipProxyUrlNormalize` instead.
   */
  skipMiddlewareUrlNormalize?: boolean

  skipProxyUrlNormalize?: boolean

  skipTrailingSlashRedirect?: boolean

  modularizeImports?: Record<
    string,
    {
      transform: string | Record<string, string>
      preventFullImport?: boolean
      skipDefaultConversion?: boolean
    }
  >

  /**
   * Logging configuration. Set to `false` to disable logging.
   */
  logging?: LoggingConfig | false

  /**
   * Enables source maps while generating static pages.
   * Helps with errors during the prerender phase in `next build`.
   * Defaults to `true`. Set to `false` to disable.
   */
  enablePrerenderSourceMaps?: boolean

  /**
   * When enabled, routes can combine a prerendered shell with dynamic content
   * streamed into it, rather than being either fully static or fully dynamic. You can mark data and parts of your UI as cacheable using the
   * `use cache` directive, which includes them in the pre-render pass alongside
   * static parts of the page. Also enables `cacheLife` and `cacheTag` APIs, and
   * includes Partial Prerendering support.
   *
   * @see [Cache Components documentation](https://nextjs.org/docs/app/api-reference/config/next-config-js/cacheComponents)
   */
  cacheComponents?: boolean

  /**
   * Opts the whole app into Partial Prefetching: `<Link prefetch={true}>`
   * prefetches only the static parts of a route, never its dynamic data.
   * When `true`, the default segment-level `prefetch` becomes
   * `'partial'`; per-segment `prefetch` exports still win. Requires
   * `cacheComponents: true`.
   *
   * When `false` or omitted, this does nothing (the legacy behavior, where
   * dynamic data is included in the prefetch).
   *
   * `'unstable_eager'` is like `true`, except the default becomes
   * `'unstable_eager'` instead of `'partial'`: every Link has an implied
   * prefetch={true}. Internal migration aid; not part of the public API.
   */
  partialPrefetching?: boolean | 'unstable_eager'

  cacheLife?: {
    [profile: string]: {
      // How long the client can cache a value without checking with the server.
      stale?: number
      // How frequently you want the cache to refresh on the server.
      // Stale values may be served while revalidating.
      revalidate?: number
      // In the worst case scenario, where you haven't had traffic in a while,
      // how stale can a value be until you prefer deopting to dynamic.
      // Must be longer than revalidate.
      expire?: number
    }
  }

  /**
   * period (in seconds) where the server allow to serve stale cache
   */
  expireTime?: number

  /**
   * When `next dev` detects an AI coding agent and no managed
   * agent-rules block is present, Next.js auto-generates `AGENTS.md`
   * and `CLAUDE.md` at the project root so the agent reads
   * version-matched docs from `node_modules/next/dist/docs/` instead
   * of stale training data. Set to `false` to disable this behavior.
   *
   * @default true
   */
  agentRules?: boolean

  /**
   * Enable experimental features. Note that all experimental features are subject to breaking changes in the future.
   */
  experimental?: ExperimentalConfig

  /**
   * Enables the bundling of node_modules packages (externals) for pages server-side bundles.
   * @see https://nextjs.org/docs/pages/api-reference/next-config-js/bundlePagesRouterDependencies
   */
  bundlePagesRouterDependencies?: boolean

  /**
   * A list of packages that should be treated as external in the server build.
   * @see https://nextjs.org/docs/app/api-reference/next-config-js/serverExternalPackages
   */
  serverExternalPackages?: string[]

  /**
   * This is the repo root usually and only files above this
   * directory are traced and included.
   */
  outputFileTracingRoot?: string

  /**
   * This allows manually excluding traced files if too many
   * are included incorrectly on a per-page basis.
   */
  outputFileTracingExcludes?: Record<string, string[]>

  /**
   * This allows manually including traced files if some
   * were not detected on a per-page basis.
   */
  outputFileTracingIncludes?: Record<string, string[]>

  /**
   * A string that is incorporated into content-addressed output filenames
   * (chunks, assets) for both Webpack and Turbopack. Changing this value
   * forces all output hashes to change, which is useful for invalidating
   * cached assets across deployments without modifying source files.
   *
   * When `NEXT_HASH_SALT` environment variable is also set, the two values are
   * concatenated (`outputHashSalt + NEXT_HASH_SALT`) to form the effective salt.
   */
  outputHashSalt?: string

  watchOptions?: {
    pollIntervalMs?: number
  }

  /**
   * User Agent of bots that can handle streaming metadata.
   * Besides the default behavior, Next.js act differently on serving metadata to bots based on their capability.
   *
   * @default
   * /Mediapartners-Google|Slurp|DuckDuckBot|baiduspider|yandex|sogou|bitlybot|tumblr|vkShare|quora link preview|redditbot|ia_archiver|Bingbot|BingPreview|applebot|facebookexternalhit|facebookcatalog|Twitterbot|LinkedInBot|Slackbot|Discordbot|WhatsApp|SkypeUriPreview/i
   */
  htmlLimitedBots?: RegExp

  /**
   * @internal
   */
  configFile?: string | undefined

  /**
   * @internal
   */
  configOrigin?: string | undefined

  /**
   * @internal
   */
  _originalRedirects?: any

  /**
   * @internal
   */
  _originalRewrites?: any
}

export const defaultConfig = Object.freeze({
  env: {},
  webpack: null,
  typescript: {
    ignoreBuildErrors: false,
    tsconfigPath: undefined,
  },
  typedRoutes: false,
  distDir: '.next',
  cleanDistDir: true,
  assetPrefix: '',
  cacheHandler: process.env.NEXT_CACHE_HANDLER_PATH,
  // default to 50MB limit
  cacheMaxMemorySize: 50 * 1024 * 1024,
  configOrigin: 'default',
  useFileSystemPublicRoutes: true,
  generateBuildId: () => null,
  generateEtags: true,
  pageExtensions: ['tsx', 'ts', 'jsx', 'js'],
  instrumentationClientInject: [],
  poweredByHeader: true,
  compress: true,
  images: imageConfigDefault,
  devIndicators: {
    position: 'bottom-left',
  },
  onDemandEntries: {
    maxInactiveAge: 60 * 1000,
    pagesBufferLength: 5,
  },
  basePath: '',
  sassOptions: {},
  trailingSlash: false,
  i18n: null,
  productionBrowserSourceMaps: false,
  excludeDefaultMomentLocales: true,
  reactProductionProfiling: false,
  reactStrictMode: null,
  reactMaxHeadersLength: 6000,
  httpAgentOptions: {
    keepAlive: true,
  },
  logging: {
    serverFunctions: true,
  } satisfies LoggingConfig,
  compiler: {},
  expireTime: process.env.NEXT_PRIVATE_CDN_CONSUMED_SWR_CACHE_CONTROL
    ? undefined
    : 31536000, // one year
  staticPageGenerationTimeout: 60,
  output: !!process.env.NEXT_PRIVATE_STANDALONE ? 'standalone' : undefined,
  modularizeImports: undefined,
  outputFileTracingRoot: '',
  allowedDevOrigins: undefined,
  enablePrerenderSourceMaps: true,
  cacheComponents: false,
  cacheLife: {
    default: {
      stale: undefined, // defaults to staleTimes.static
      revalidate: 60 * 15, // 15 minutes
      expire: INFINITE_CACHE,
    },
    seconds: {
      stale: 30, // 30 seconds
      revalidate: 1, // 1 second
      expire: 60, // 1 minute
    },
    minutes: {
      stale: 60 * 5, // 5 minutes
      revalidate: 60, // 1 minute
      expire: 60 * 60, // 1 hour
    },
    hours: {
      stale: 60 * 5, // 5 minutes
      revalidate: 60 * 60, // 1 hour
      expire: 60 * 60 * 24, // 1 day
    },
    days: {
      stale: 60 * 5, // 5 minutes
      revalidate: 60 * 60 * 24, // 1 day
      expire: 60 * 60 * 24 * 7, // 1 week
    },
    weeks: {
      stale: 60 * 5, // 5 minutes
      revalidate: 60 * 60 * 24 * 7, // 1 week
      expire: 60 * 60 * 24 * 30, // 1 month
    },
    max: {
      stale: 60 * 5, // 5 minutes
      revalidate: 60 * 60 * 24 * 30, // 1 month
      expire: 60 * 60 * 24 * 365, // 1 year
    },
  },
  cacheHandlers: {
    default: process.env.NEXT_DEFAULT_CACHE_HANDLER_PATH,
    remote: process.env.NEXT_REMOTE_CACHE_HANDLER_PATH,
    static: process.env.NEXT_STATIC_CACHE_HANDLER_PATH,
  },
  adapterPath: process.env.NEXT_ADAPTER_PATH || undefined,
  experimental: {
    coldCacheBadge: false,
    devValidationWorker: true,
    useSkewCookie: false,
    cssChunking: true,
    multiZoneDraftMode: false,
    appNavFailHandling: false,
    prerenderEarlyExit: true,
    serverMinification: true,
    linkNoTouchStart: false,
    caseSensitiveRoutes: false,
    clientParamParsingOrigins: undefined,
    cachedNavigations: false,
    dynamicOnHover: false,
    useOffline: false,
    varyParams: true,
    optimisticRouting: true,
    concurrentRouterQueue: false,
    instrumentationClientRouterTransitionEvents: false,
    prefetchInlining: true,
    preloadEntriesOnStart: true,
    clientRouterFilter: true,
    clientRouterFilterRedirects: false,
    fetchCacheKeyPrefix: '',
    proxyPrefetch: 'flexible',
    optimisticClientCache: true,
    manualClientBasePath: false,
    cpus: Math.max(
      1,
      (Number(process.env.CIRCLE_NODE_TOTAL) ||
        (os.cpus() || { length: 1 }).length) - 1
    ),
    memoryBasedWorkersCount: false,
    imgOptConcurrency: null,
    imgOptOperationCache: null,
    imgOptTimeoutInSeconds: 7,
    imgOptMaxInputPixels: 268_402_689, // https://sharp.pixelplumbing.com/api-constructor#:~:text=%5Boptions.limitInputPixels%5D
    imgOptSequentialRead: null,
    isrFlushToDisk: true,
    workerThreads: false,
    proxyTimeout: undefined,
    optimizeCss: false,
    nextScriptWorkers: false,
    scrollRestoration: false,
    externalDir: false,
    devMemoryThresholdRestart: true,
    disableOptimizedLoading: false,
    gzipSize: true,
    craCompat: false,
    esmExternals: true,
    fullySpecified: false,
    swcTraceProfiling: false,
    forceSwcTransforms: false,
    requestInsights: false,
    swcPlugins: undefined,
    largePageDataBytes: 128 * 1000, // 128KB by default
    disablePostcssPresetEnv: undefined,
    urlImports: undefined,
    typedEnv: false,
    clientTraceMetadata: undefined,
    parallelServerCompiles: false,
    parallelServerBuildTraces: false,
    ppr: false,
    authInterrupts: false,
    webpackBuildWorker: undefined,
    webpackMemoryOptimizations: false,
    optimizeServerReact: true,
    strictRouteTypes: false,
    useTypeScriptCli: true,
    removeUncaughtErrorAndRejectionListeners: false,
    validateRSCRequestHeaders: true,
    staleTimes: {
      dynamic: 0,
      static: 300,
    },
    allowDevelopmentBuild: undefined,
    reactDebugChannel: true,
    staticGenerationRetryCount: undefined,
    serverComponentsHmrCache: true,
    serverComponentsHmrCancellation: false,
    staticGenerationMaxConcurrency: 8,
    staticGenerationMinPagesPerWorker: 25,
    transitionIndicator: false,
    gestureTransition: false,
    inlineCss: false,
    useCache: undefined,
    slowModuleDetection: undefined,
    globalNotFound: false,
    browserDebugInfoInTerminal: 'warn',
    lockDistDir: true,
    disableResumeDataCacheCompression: false,
    proxyClientMaxBodySize: 10_485_760, // 10MB
    hideLogsAfterAbort: false,
    mcpServer: true,
    turbopackFileSystemCacheForDev: true,
    turbopackFileSystemCacheForBuild: true,
    turbopackInferModuleSideEffects: true,
    turbopackPluginRuntimeStrategy: 'childProcesses',
    turbopackSharedRuntime: !isStableBuild(),
  },
  htmlLimitedBots: undefined,
  bundlePagesRouterDependencies: false,
} satisfies NextConfig)

export async function normalizeConfig(phase: string, config: any) {
  if (typeof config === 'function') {
    config = config(phase, { defaultConfig })
  }
  // Support `new Promise` and `async () =>` as return values of the config export
  return await config
}

// This should be a supertype of NextConfigComplete
//
// The Vercel builder needs these fields (read `config` in required-server-files.json)
// {
//   pageExtensions: string[];
//   experimental?: {
//     cacheComponents?: boolean;
//     clientParamParsingOrigins?: string[];
//     clientSegmentCache?: boolean;
//     serverActions?: Record<string, never>;
//   };
// };
export interface NextConfigRuntime {
  // Can be undefined, particularly when experimental.runtimeServerDeploymentId is true
  deploymentId?: NextConfigComplete['deploymentId']
  supportsImmutableAssets?: NextConfigComplete['supportsImmutableAssets']

  configFileName?: string
  // Should only be included when using isExperimentalCompile
  env?: NextConfigComplete['env']

  distDir: NextConfigComplete['distDir']
  cacheComponents: NextConfigComplete['cacheComponents']
  partialPrefetching: NextConfigComplete['partialPrefetching']
  agentRules: NextConfigComplete['agentRules']
  htmlLimitedBots: NextConfigComplete['htmlLimitedBots']
  assetPrefix: NextConfigComplete['assetPrefix']
  output?: NextConfigComplete['output']
  crossOrigin: NextConfigComplete['crossOrigin']
  trailingSlash: NextConfigComplete['trailingSlash']
  images: NextConfigComplete['images']
  reactMaxHeadersLength: NextConfigComplete['reactMaxHeadersLength']
  cacheLife: NextConfigComplete['cacheLife']
  basePath: NextConfigComplete['basePath']
  expireTime?: NextConfigComplete['expireTime']
  generateEtags: NextConfigComplete['generateEtags']
  poweredByHeader: NextConfigComplete['poweredByHeader']
  cacheHandler: NextConfigComplete['cacheHandler']
  cacheHandlers: NextConfigComplete['cacheHandlers']
  cacheMaxMemorySize: NextConfigComplete['cacheMaxMemorySize']
  compress: NextConfigComplete['compress']
  i18n: NextConfigComplete['i18n']
  httpAgentOptions: NextConfigComplete['httpAgentOptions']
  skipProxyUrlNormalize: NextConfigComplete['skipProxyUrlNormalize']
  pageExtensions: NextConfigComplete['pageExtensions']
  useFileSystemPublicRoutes: NextConfigComplete['useFileSystemPublicRoutes']
  logging?: NextConfigComplete['logging']
  adapterPath?: NextConfigComplete['adapterPath']
  staticPageGenerationTimeout: NextConfigComplete['staticPageGenerationTimeout']

  experimental: Pick<
    NextConfigComplete['experimental'],
    | 'taint'
    | 'serverActions'
    | 'staleTimes'
    | 'dynamicOnHover'
    | 'useOffline'
    | 'optimisticRouting'
    | 'inlineCss'
    | 'prefetchInlining'
    | 'authInterrupts'
    | 'useCacheTimeout'
    | 'clientTraceMetadata'
    | 'clientParamParsingOrigins'
    | 'allowedRevalidateHeaderKeys'
    | 'fetchCacheKeyPrefix'
    | 'isrFlushToDisk'
    | 'optimizeCss'
    | 'nextScriptWorkers'
    | 'disableOptimizedLoading'
    | 'largePageDataBytes'
    | 'serverComponentsHmrCache'
    | 'serverComponentsHmrCancellation'
    | 'caseSensitiveRoutes'
    | 'validateRSCRequestHeaders'
    | 'sri'
    | 'useSkewCookie'
    | 'preloadEntriesOnStart'
    | 'hideLogsAfterAbort'
    | 'removeUncaughtErrorAndRejectionListeners'
    | 'imgOptConcurrency'
    | 'imgOptOperationCache'
    | 'imgOptMaxInputPixels'
    | 'imgOptSequentialRead'
    | 'imgOptTimeoutInSeconds'
    | 'proxyClientMaxBodySize'
    | 'proxyTimeout'
    | 'testProxy'
    | 'runtimeServerDeploymentId'
    | 'maxPostponedStateSize'
    | 'disableResumeDataCacheCompression'
    | 'cachedNavigations'
    | 'exposeTestingApiInProductionBuild'
    | 'instantInsights'
    | 'requestInsights'
  > & {
    // Pick on @internal fields generates invalid .d.ts files
    /** @internal */
    trustHostHeader?: NextConfigComplete['experimental']['trustHostHeader']
    /** @internal */
    isExperimentalCompile?: NextConfigComplete['experimental']['isExperimentalCompile']
  }
}

export function getNextConfigRuntime(
  config: NextConfigComplete | NextConfigRuntime
): NextConfigRuntime {
  // This config filter is a breaking change, so only do it if experimental.runtimeServerDeploymentId is enabled
  if (!config.experimental.runtimeServerDeploymentId) {
    return config
  }

  const ex = config.experimental

  type Requiredish<T> = {
    [K in keyof Required<T>]: T[K]
  }

  const experimental = {
    taint: ex.taint,
    serverActions: ex.serverActions,
    staleTimes: ex.staleTimes,
    dynamicOnHover: ex.dynamicOnHover,
    useOffline: ex.useOffline,
    optimisticRouting: ex.optimisticRouting,
    inlineCss: ex.inlineCss,
    prefetchInlining: ex.prefetchInlining,
    authInterrupts: ex.authInterrupts,
    useCacheTimeout: ex.useCacheTimeout,
    clientTraceMetadata: ex.clientTraceMetadata,
    clientParamParsingOrigins: ex.clientParamParsingOrigins,
    allowedRevalidateHeaderKeys: ex.allowedRevalidateHeaderKeys,
    fetchCacheKeyPrefix: ex.fetchCacheKeyPrefix,
    isrFlushToDisk: ex.isrFlushToDisk,
    optimizeCss: ex.optimizeCss,
    nextScriptWorkers: ex.nextScriptWorkers,
    disableOptimizedLoading: ex.disableOptimizedLoading,
    largePageDataBytes: ex.largePageDataBytes,
    serverComponentsHmrCache: ex.serverComponentsHmrCache,
    serverComponentsHmrCancellation: ex.serverComponentsHmrCancellation,
    caseSensitiveRoutes: ex.caseSensitiveRoutes,
    validateRSCRequestHeaders: ex.validateRSCRequestHeaders,
    sri: ex.sri,
    useSkewCookie: ex.useSkewCookie,
    preloadEntriesOnStart: ex.preloadEntriesOnStart,
    hideLogsAfterAbort: ex.hideLogsAfterAbort,
    removeUncaughtErrorAndRejectionListeners:
      ex.removeUncaughtErrorAndRejectionListeners,
    imgOptConcurrency: ex.imgOptConcurrency,
    imgOptOperationCache: ex.imgOptOperationCache,
    imgOptMaxInputPixels: ex.imgOptMaxInputPixels,
    imgOptSequentialRead: ex.imgOptSequentialRead,
    imgOptTimeoutInSeconds: ex.imgOptTimeoutInSeconds,
    proxyClientMaxBodySize: ex.proxyClientMaxBodySize,
    proxyTimeout: ex.proxyTimeout,
    testProxy: ex.testProxy,
    runtimeServerDeploymentId: ex.runtimeServerDeploymentId,
    maxPostponedStateSize: ex.maxPostponedStateSize,
    disableResumeDataCacheCompression: ex.disableResumeDataCacheCompression,
    cachedNavigations: ex.cachedNavigations,
    exposeTestingApiInProductionBuild: ex.exposeTestingApiInProductionBuild,
    instantInsights: ex.instantInsights,
    requestInsights: ex.requestInsights,

    trustHostHeader: ex.trustHostHeader,
    isExperimentalCompile: ex.isExperimentalCompile,
  } satisfies Requiredish<NextConfigRuntime['experimental']>

  const runtimeConfig: Requiredish<NextConfigRuntime> = {
    deploymentId: config.experimental.runtimeServerDeploymentId
      ? ''
      : config.deploymentId,
    supportsImmutableAssets: config.supportsImmutableAssets,

    configFileName: undefined,
    env: undefined,

    distDir: config.distDir,
    cacheComponents: config.cacheComponents,
    partialPrefetching: config.partialPrefetching,
    agentRules: config.agentRules,
    htmlLimitedBots: config.htmlLimitedBots,
    assetPrefix: config.assetPrefix,
    output: config.output,
    crossOrigin: config.crossOrigin,
    trailingSlash: config.trailingSlash,
    images: config.images,
    reactMaxHeadersLength: config.reactMaxHeadersLength,
    cacheLife: config.cacheLife,
    basePath: config.basePath,
    expireTime: config.expireTime,
    generateEtags: config.generateEtags,
    poweredByHeader: config.poweredByHeader,
    cacheHandler: config.cacheHandler,
    cacheHandlers: config.cacheHandlers,
    // The full adapterPath might be non-deterministic across builds and doesn't
    // actually matter at runtime, so replace it with a placeholder if it's set.
    adapterPath: config.adapterPath ? '<omitted but set>' : undefined,
    cacheMaxMemorySize: config.cacheMaxMemorySize,
    compress: config.compress,
    i18n: config.i18n,
    httpAgentOptions: config.httpAgentOptions,
    skipProxyUrlNormalize: config.skipProxyUrlNormalize,
    pageExtensions: config.pageExtensions,
    useFileSystemPublicRoutes: config.useFileSystemPublicRoutes,
    logging: config.logging,
    staticPageGenerationTimeout: config.staticPageGenerationTimeout,

    experimental,
  }

  if (config.experimental.isExperimentalCompile) {
    runtimeConfig.env = config.env
  }

  return runtimeConfig
}

// Re-export from shared lib for backwards compatibility
export {
  DEFAULT_MAX_POSTPONED_STATE_SIZE,
  parseMaxPostponedStateSize,
} from '../shared/lib/size-limit'