Adapters and deployment outputs

{
  "version": 1,
  "config": {
    "distDir": ".next",
    "output": "standalone",
    "deploymentId": "tea-shop-8",
    "adapterPath": "/my-app/my-adapter.js",
    "compress": true,
    "experimental": {
      "trustHostHeader": false
    },
    "…": "46 more settings, and the rest of experimental"
  },
  "appDir": "/my-app",
  "relativeAppDir": "",
  "files": [
    ".next/package.json",
    ".next/routes-manifest.json",
    ".next/server/pages-manifest.json",
    ".next/build-manifest.json",
    ".next/prerender-manifest.json",
    ".next/server/preview-props.json",
    ".next/server/functions-config-manifest.json",
    ".next/server/middleware-manifest.json",
    ".next/server/middleware-build-manifest.js",
    ".next/server/app-paths-manifest.json",
    ".next/app-path-routes-manifest.json",
    ".next/server/server-reference-manifest.js",
    ".next/server/server-reference-manifest.json",
    ".next/server/prefetch-hints.json",
    ".next/BUILD_ID",
    ".next/server/next-font-manifest.js",
    ".next/server/next-font-manifest.json",
    ".next/required-server-files.json"
  ],
  "ignore": []
}

const serverFilesManifest: RequiredServerFilesManifest = {
  version: 1,
  config: {
    ...runtimeConfigWithoutFilePath,
    distDir: buildDistDir,
    // …
    experimental: {
      ...runtimeConfig.experimental,
      trustHostHeader: ciEnvironment.hasNextSupport,
      isExperimentalCompile: isCompileMode,
    },
  },
  appDir: dir,
  relativeAppDir: path.relative(outputFileTracingRoot, dir),

for (const file of [
  ...requiredServerFiles.files,
  path.join(
    requiredServerFiles.config.distDir,
    SERVER_FILES_MANIFEST + '.json'
  ),
  ...loadedEnvFiles.reduce<string[]>((acc, envFile) => {
    if (['.env', '.env.production'].includes(envFile.path)) {
      acc.push(envFile.path)
    }
    return acc
  }, []),
]) {
  // requiredServerFiles.appDir Refers to the application directory, not App Router.
  const filePath = path.join(requiredServerFiles.appDir, file)
  const outputPath = path.join(
    distDir,
    STANDALONE_DIRECTORY,
    path.relative(outputFileTracingRoot, filePath)
  )
  await fs.mkdir(path.dirname(outputPath), {
    recursive: true,
  })
  await fs.copyFile(filePath, outputPath)
}

const nextConfig = ${JSON.stringify(nextConfig)}

process.env.__NEXT_PRIVATE_STANDALONE_CONFIG = JSON.stringify(nextConfig)

const nextConfig = {"env":{},"webpack":null,"typescript":{"ignoreBuildErrors":false},"typedRoutes":false,"distDir":"./.next",…}

// Run after hasInstrumentationHook, which inserts the NFT-provided file hash for .next/server/instrumentation.js
for (const file of requiredServerFiles) {
  // add to shared node assets
  const filePath = path.join(dir, file)
  const fileOutputPath = path.relative(repoRoot, filePath)
  await pushAsset(
    sharedNodeAssets,
    sharedNodeAssetsHashes,
    fileOutputPath,
    filePath,
    bundler,
    salt
  )
}

const routerServerContext = this.getRouterServerContext(req)
const nextConfig =
  routerServerContext?.nextConfig || serverFilesManifest?.config

// Injected in base-server.ts
const protocol = req.headers['x-forwarded-proto']?.includes('https')
  ? 'https'
  : 'http'

// When there are hostname and port we build an absolute URL
if (!getRequestMeta(req, 'initURL')) {
  const initUrl = serverFilesManifest?.config.experimental.trustHostHeader
    ? `${protocol}://${req.headers.host || 'localhost'}${req.url}`
    : `${protocol}://${routerServerContext?.hostname || 'localhost'}${req.url}`

export interface AdapterOutputs {
  pages: Array<AdapterOutput['PAGES']>
  middleware?: AdapterOutput['MIDDLEWARE']
  appPages: Array<AdapterOutput['APP_PAGE']>
  pagesApi: Array<AdapterOutput['PAGES_API']>
  appRoutes: Array<AdapterOutput['APP_ROUTE']>
  prerenders: Array<AdapterOutput['PRERENDER']>
  staticFiles: Array<AdapterOutput['STATIC_FILE']>
}

/**
 * fallback is initial cache data generated during build for a prerender
 */
fallback?: {
  /**
   * path to the fallback file can be HTML/JSON/RSC,
   */
  filePath: string | undefined
  /**
   * initialStatus is the status code that should be applied
   * when serving the fallback
   */
  initialStatus?: number
  /**
   * initialHeaders are the headers that should be sent when
   * serving the fallback
   */
  initialHeaders?: Record<string, string | string[]>
  /**
   * initial expiration is how long until the fallback entry
   * is considered expired and no longer valid to serve
   */
  initialExpiration?: number
  /**
   * initial revalidate is how long until the fallback is
   * considered stale and should be revalidated
   */
  initialRevalidate?: Revalidate

  /**
   * postponedState is the PPR state when it postponed and is used for resuming
   */
  postponedState: string | undefined
}

await adapterMod.onBuildComplete({
  routing: {
    beforeMiddleware: [...headers, ...redirects],
    middlewareMatchers:
      outputs.middleware?.config.matchers?.map((matcher) => ({
        source: matcher.source,
        sourceRegex: matcher.sourceRegex,
        has: matcher.has,
        missing: matcher.missing,
      })) ?? [],
    beforeFiles: rewrites.beforeFiles,
    afterFiles: rewrites.afterFiles,
    dynamicRoutes: combinedDynamicRoutes,
    onMatch: [
      {
        // This ensures we only match known emitted-by-Next.js files and not
        // user-emitted files which may be missing a hash in their filename.
        sourceRegex: `${path.posix.join(config.basePath || '/', '_next/static', `/(?:[^/]+/pages|pages|chunks|immutable|runtime|css|image|media|${escapeStringRegexp(buildId)})/.+`)}`,
        // Next.js assets contain a hash or entropy in their filenames, so they
        // are guaranteed to be unique and cacheable indefinitely.
        headers: {
          'cache-control': `public,max-age=${CACHE_ONE_YEAR_SECONDS},immutable`,
        },
      },
      ...onMatchHeaders,
    ],
    fallback: rewrites.fallback,
    shouldNormalizeNextData: !!needsMiddlewareResolveRoutes,

const redirects = routesManifest.redirects.map((route) => {
  const converted = convertRedirects([route], 307)[0]
  const regex = converted.src || route.regex

  return {
    source: route.source,
    sourceRegex: route.internal ? regex : modifyRouteRegex(regex),
    headers: 'headers' in converted ? converted.headers || {} : {},
    status: converted.status || getRedirectStatus(route),
    has: route.has,
    missing: route.missing,
    priority: route.internal || undefined,
  } satisfies Route
})

{
  "beforeMiddleware": [
    {
      "source": "/teas/:slug",
      "sourceRegex": "^\\/teas(?:\\/([^\\/]+?))(?:\\/)?$",
      "headers": {
        "x-shop": "tea"
      }
    },
    {
      "source": "/:path+/",
      "sourceRegex": "^(?:\\/((?:[^\\/]+?)(?:\\/(?:[^\\/]+?))*))\\/$",
      "headers": {
        "Location": "/$1"
      },
      "status": 308,
      "priority": true
    },
    {
      "source": "/old-menu",
      "sourceRegex": "^\\/old-menu(?:\\/)?$",
      "headers": {
        "Location": "/menu"
      },
      "status": 308
    }
  ],
  "afterFiles": [
    {
      "source": "/t/:slug",
      "sourceRegex": "^\\/t(?:\\/([^\\/]+?))(?:\\/)?$",
      "destination": "/teas/$1"
    }
  ],
  "dynamicRoutes": [
    {
      "source": "/teas/[slug]",
      "sourceRegex": "^[/]?/teas/(?<nxtPslug>[^/]+?)(\\.rsc|\\.segments/.+\\.segment\\.rsc|)(?:/)?$",
      "destination": "/teas/[slug]$2?nxtPslug=$nxtPslug"
    }
  ],
  "onMatch": [
    {
      "sourceRegex": "/_next/static/(?:[^/]+/pages|pages|chunks|immutable|runtime|css|image|media|build\\-TfctsWXpff2fKS)/.+",
      "headers": {
        "cache-control": "public,max-age=31536000,immutable"
      }
    },
    {
      "source": "/:path*",
      "sourceRegex": "^(?:\\/((?:[^\\/]+?)(?:\\/(?:[^\\/]+?))*))?(?:\\/)?$",
      "headers": {
        "x-nextjs-deployment-id": "tea-shop-8"
      },
      "has": [
        {
          "type": "header",
          "key": "rsc",
          "value": "1"
        }
      ]
    },
    {
      "source": "/_next/data/(.*)",
      "sourceRegex": "^\\/_next\\/data(?:\\/(.*))(?:\\/)?$",
      "headers": {
        "x-nextjs-deployment-id": "tea-shop-8"
      }
    }
  ]
}

{
  "deploymentId": "tea-shop-8",
  "redirects": [
    {
      "source": "/:path+/",
      "destination": "/:path+",
      "internal": true,
      "priority": true,
      "statusCode": 308,
      "regex": "^(?:/((?:[^/]+?)(?:/(?:[^/]+?))*))/$"
    },
    {
      "source": "/old-menu",
      "destination": "/menu",
      "statusCode": 308,
      "regex": "^(?!/_next)/old-menu(?:/)?$"
    }
  ],
  "headers": [
    {
      "source": "/teas/:slug",
      "headers": [
        {
          "key": "x-shop",
          "value": "tea"
        }
      ],
      "regex": "^/teas(?:/([^/]+?))(?:/)?$"
    }
  ],
  "rewrites": {
    "beforeFiles": [],
    "afterFiles": [
      {
        "source": "/t/:slug",
        "destination": "/teas/:slug",
        "regex": "^/t(?:/([^/]+?))(?:/)?$"
      }
    ],
    "fallback": []
  },
  "onMatchHeaders": [
    {
      "source": "/:path*",
      "has": [
        {
          "type": "header",
          "key": "rsc",
          "value": "1"
        }
      ],
      "headers": [
        {
          "key": "x-nextjs-deployment-id",
          "value": "tea-shop-8"
        }
      ],
      "regex": "^(?:/((?:[^/]+?)(?:/(?:[^/]+?))*))?(?:/)?$"
    },
    {
      "source": "/_next/data/(.*)",
      "headers": [
        {
          "key": "x-nextjs-deployment-id",
          "value": "tea-shop-8"
        }
      ],
      "regex": "^/_next/data(?:/(.*))(?:/)?$"
    }
  ]
}

1import type { NextConfig } from "next";2 3const nextConfig: NextConfig = {4  cacheComponents: true,5  partialPrefetching: true,6  adapterPath: require.resolve("./my-adapter.js"),7  output: "standalone",8  deploymentId: "tea-shop-8",9  async headers() {10    return [{ source: "/teas/:slug", headers: [{ key: "x-shop", value: "tea" }] }];11  },12  async redirects() {13    return [{ source: "/old-menu", destination: "/menu", permanent: true }];14  },15  async rewrites() {16    return [{ source: "/t/:slug", destination: "/teas/:slug" }];17  },18};19 20export default nextConfig;21 

if (config.deploymentId && !config.generateBuildId) {
  // Skew protection is enabled and NEXT_NAV_DEPLOYMENT_ID_HEADER will be used instead. Set a
  // constant but "random" string because various tools perform `.replace(escapedBuildId, ....)`
  // which would fail if this were something like "build-id" instead.
  return 'build-TfctsWXpff2fKS'
}

onMatchHeaders.push(
  {
    source: '/:path*',
    has: [
      {
        type: 'header',
        key: 'rsc',
        value: '1',
      },
    ],
    headers: [
      {
        key: NEXT_NAV_DEPLOYMENT_ID_HEADER,
        value: config.deploymentId,
      },
    ],
  },
  {
    source: '/_next/data/(.*)',
    headers: [
      {
        key: NEXT_NAV_DEPLOYMENT_ID_HEADER,
        value: config.deploymentId,
      },
    ],
  }
)

// For static prerenders served from CDN, routes-manifest.json adds a header.
if (isRSCRequest && !isPossibleServerAction && deploymentId) {
  res.setHeader(NEXT_NAV_DEPLOYMENT_ID_HEADER, deploymentId)
}

function maybeAppendBuildIdToRSCPayload<T extends RSCPayload>(
  ctx: AppRenderContext,
  payload: T
): T {
  if (!ctx.sharedContext.deploymentId) {
    // When using the build id, we need to initialize the id on initial page load, so a build id
    // header wouldn't be enough.
    payload.b = ctx.sharedContext.buildId
  }
  return payload
}

const htmlTagIndex = indexOfUint8Array(chunk, ENCODED_TAGS.OPENING.HTML)
if (htmlTagIndex === -1) {
  this.push(chunk)
  callback()
  return
}

const insertionPoint = htmlTagIndex + ENCODED_TAGS.OPENING.HTML.length
const encodedAttribute = Buffer.from(` data-dpl-id="${dplId}"`)

let deploymentId: string | undefined

if (typeof window !== 'undefined') {
  deploymentId = document.documentElement.dataset.dplId
  // Immediately remove the attribute to prevent hydration errors (the dplId was inserted into the
  // HTML only), React isn't aware of it at all.
  document.documentElement.removeAttribute('data-dpl-id')
} else {
  // Client side: replaced with globalThis.NEXT_DEPLOYMENT_ID
  // Server side: left as is or replaced with a string or replaced with false
  deploymentId = process.env.NEXT_DEPLOYMENT_ID || undefined
}

export function getDeploymentId(): string | undefined {
  return deploymentId
}

export function getDeploymentIdQuery(ampersand = false): string {
  let id = getDeploymentId()
  if (id) {
    return `${ampersand ? '&' : '?'}dpl=${id}`
  }
  return ''
}

...(config.experimental?.useSkewCookie || !config.deploymentId
  ? {
      'process.env.NEXT_DEPLOYMENT_ID': false,
    }
  : isClient
    ? isTurbopack
      ? {
          // This is set at runtime by packages/next/src/client/register-deployment-id-global.ts
          'process.env.NEXT_DEPLOYMENT_ID': {
            [DEFINE_ENV_EXPRESSION]: 'globalThis.NEXT_DEPLOYMENT_ID',
          },
        }
      : {
          // For Webpack, we currently don't use the non-inlining globalThis.NEXT_DEPLOYMENT_ID
          // approach because we cannot forward this global variable to web workers easily.
          'process.env.NEXT_DEPLOYMENT_ID': config.deploymentId || false,
        }
    : config.experimental?.runtimeServerDeploymentId
      ? {
          // Don't inline at all, keep process.env.NEXT_DEPLOYMENT_ID as is
        }
      : {
          'process.env.NEXT_DEPLOYMENT_ID': config.deploymentId || false,
        }),

const deploymentId = getDeploymentId()
if (deploymentId) {
  headers['x-deployment-id'] = deploymentId
}

if (
  (res.headers.get(NEXT_NAV_DEPLOYMENT_ID_HEADER) ?? flightResponse.b) !==
  getNavigationBuildId()
) {
  // The server build does not match the client build.
  return doMpaNavigation(res.url)
}