cdk-nextjs 0.7.10 → 0.7.11

package/lib/runtime/lambda.mjs

@@ -25416,7 +25416,7 @@ var require_dist_cjs13 = __commonJS({
   "node_modules/.pnpm/@aws-sdk+credential-provider-web-identity@3.972.78/node_modules/@aws-sdk/credential-provider-web-identity/dist-cjs/index.js"(exports) {
     var { setCredentialFeature: setCredentialFeature2 } = (init_client3(), __toCommonJS(client_exports2));
     var { CredentialsProviderError: CredentialsProviderError2, externalDataInterceptor: externalDataInterceptor2 } = (init_config2(), __toCommonJS(config_exports));
-    var { readFileSync: readFileSync3 } = __require("node:fs");
+    var { readFileSync: readFileSync2 } = __require("node:fs");
     var fromWebToken = (init) => async (awsIdentityProperties) => {
       init.logger?.debug("@aws-sdk/credential-provider-web-identity - fromWebToken");
       const { roleArn, roleSessionName, webIdentityToken, providerId, policyArns, policy, durationSeconds } = init;
@@ -25457,7 +25457,7 @@ var require_dist_cjs13 = __commonJS({
       }
       const credentials = await fromWebToken({
         ...init,
-        webIdentityToken: externalDataInterceptor2?.getTokenRecord?.()[webIdentityTokenFile] ?? readFileSync3(webIdentityTokenFile, { encoding: "ascii" }),
+        webIdentityToken: externalDataInterceptor2?.getTokenRecord?.()[webIdentityTokenFile] ?? readFileSync2(webIdentityTokenFile, { encoding: "ascii" }),
         roleArn,
         roleSessionName
       })(awsIdentityProperties);
@@ -35918,7 +35918,7 @@ var require_dist = __commonJS({
       if (typeof e5 !== "undefined") e5.ab = __dirname + "/";
       var t = {};
       e5.r(t);
-      e5.d(t, { detectDomainLocale: () => detectDomainLocale2, detectLocale: () => detectLocale2, getAcceptLanguageLocale: () => getAcceptLanguageLocale, getCookieLocale: () => getCookieLocale, normalizeLocalePath: () => normalizeLocalePath, resolveRoutes: () => resolveRoutes2, responseToMiddlewareResult: () => responseToMiddlewareResult2 });
+      e5.d(t, { detectDomainLocale: () => detectDomainLocale2, detectLocale: () => detectLocale2, getAcceptLanguageLocale: () => getAcceptLanguageLocale, getCookieLocale: () => getCookieLocale, normalizeLocalePath: () => normalizeLocalePath2, resolveRoutes: () => resolveRoutes2, responseToMiddlewareResult: () => responseToMiddlewareResult2 });
       function matchesCondition(e6, t8) {
         if (e6 === void 0) {
           return { matched: false };
@@ -36117,7 +36117,7 @@ var require_dist = __commonJS({
         }
         return void 0;
       }
-      function normalizeLocalePath(e6, t8) {
+      function normalizeLocalePath2(e6, t8) {
         if (!t8 || t8.length === 0) {
           return { pathname: e6 };
         }
@@ -36201,7 +36201,7 @@ var require_dist = __commonJS({
       }
       function detectLocale2(e6) {
         const { pathname: t8, hostname: n4, cookieHeader: a5, acceptLanguageHeader: s2, i18n: r5 } = e6;
-        const o3 = normalizeLocalePath(t8, r5.locales);
+        const o3 = normalizeLocalePath2(t8, r5.locales);
         if (o3.detectedLocale) {
           return { locale: o3.detectedLocale, pathnameWithoutLocale: o3.pathname, localeInPath: true };
         }
@@ -36486,7 +36486,7 @@ var require_dist = __commonJS({
             const t9 = f5.hostname;
             const a6 = h5.get("cookie") || void 0;
             const s4 = h5.get("accept-language") || void 0;
-            const r6 = normalizeLocalePath(e7, l3.locales);
+            const r6 = normalizeLocalePath2(e7, l3.locales);
             const o4 = !!r6.detectedLocale;
             const i6 = detectDomainLocale2(l3.domains, t9);
             const c6 = i6?.defaultLocale || l3.defaultLocale;
@@ -36877,9 +36877,249 @@ var require_dist = __commonJS({
   }
 });
 
+// package.json
+var require_package = __commonJS({
+  "package.json"(exports, module) {
+    module.exports = {
+      name: "cdk-nextjs",
+      description: "Deploy Next.js apps on AWS with CDK",
+      repository: {
+        type: "git",
+        url: "https://github.com/cdklabs/cdk-nextjs.git"
+      },
+      scripts: {
+        build: "pnpm dlx projen build",
+        bump: "pnpm dlx projen bump",
+        "bump:releasable-commits": "pnpm dlx projen bump:releasable-commits",
+        bundle: "pnpm dlx projen bundle",
+        "bundle:adapter/adapter": "pnpm dlx projen bundle:adapter/adapter",
+        "bundle:adapter/adapter:watch": "pnpm dlx projen bundle:adapter/adapter:watch",
+        "bundle:adapter/cache-handler": "pnpm dlx projen bundle:adapter/cache-handler",
+        "bundle:adapter/cache-handler:watch": "pnpm dlx projen bundle:adapter/cache-handler:watch",
+        "bundle:adapter/use-cache-default-handler": "pnpm dlx projen bundle:adapter/use-cache-default-handler",
+        "bundle:adapter/use-cache-default-handler:watch": "pnpm dlx projen bundle:adapter/use-cache-default-handler:watch",
+        "bundle:adapter/use-cache-remote-handler": "pnpm dlx projen bundle:adapter/use-cache-remote-handler",
+        "bundle:adapter/use-cache-remote-handler:watch": "pnpm dlx projen bundle:adapter/use-cache-remote-handler:watch",
+        "bundle:lambdas/post-deploy/post-deploy.lambda": "pnpm dlx projen bundle:lambdas/post-deploy/post-deploy.lambda",
+        "bundle:lambdas/post-deploy/post-deploy.lambda:watch": "pnpm dlx projen bundle:lambdas/post-deploy/post-deploy.lambda:watch",
+        "bundle:lambdas/redeploy-stage/redeploy-stage.lambda": "pnpm dlx projen bundle:lambdas/redeploy-stage/redeploy-stage.lambda",
+        "bundle:lambdas/redeploy-stage/redeploy-stage.lambda:watch": "pnpm dlx projen bundle:lambdas/redeploy-stage/redeploy-stage.lambda:watch",
+        "bundle:nextjs-build/patch-fetch": "pnpm dlx projen bundle:nextjs-build/patch-fetch",
+        "bundle:nextjs-build/patch-fetch:watch": "pnpm dlx projen bundle:nextjs-build/patch-fetch:watch",
+        "bundle:runtime/lambda": "pnpm dlx projen bundle:runtime/lambda",
+        "bundle:runtime/lambda:watch": "pnpm dlx projen bundle:runtime/lambda:watch",
+        "bundle:runtime/server": "pnpm dlx projen bundle:runtime/server",
+        "bundle:runtime/server:watch": "pnpm dlx projen bundle:runtime/server:watch",
+        clobber: "pnpm dlx projen clobber",
+        compat: "pnpm dlx projen compat",
+        compile: "pnpm dlx projen compile",
+        default: "pnpm dlx projen default",
+        docgen: "pnpm dlx projen docgen",
+        eject: "pnpm dlx projen eject",
+        eslint: "pnpm dlx projen eslint",
+        integ: "pnpm dlx projen integ",
+        "integ:update": "pnpm dlx projen integ:update",
+        package: "pnpm dlx projen package",
+        "package-all": "pnpm dlx projen package-all",
+        "package:js": "pnpm dlx projen package:js",
+        "post-compile": "pnpm dlx projen post-compile",
+        "post-upgrade": "pnpm dlx projen post-upgrade",
+        "pre-compile": "pnpm dlx projen pre-compile",
+        release: "pnpm dlx projen release",
+        "rosetta:extract": "pnpm dlx projen rosetta:extract",
+        test: "pnpm dlx projen test",
+        "test:watch": "pnpm dlx projen test:watch",
+        unbump: "pnpm dlx projen unbump",
+        upgrade: "pnpm dlx projen upgrade",
+        "upgrade-cdklabs-projen-project-types": "pnpm dlx projen upgrade-cdklabs-projen-project-types",
+        "upgrade-dev-deps": "pnpm dlx projen upgrade-dev-deps",
+        watch: "pnpm dlx projen watch",
+        projen: "pnpm dlx projen"
+      },
+      author: {
+        name: "Amazon Web Services",
+        email: "aws-cdk-dev@amazon.com",
+        organization: true
+      },
+      devDependencies: {
+        "@aws-cdk/integ-runner": "latest",
+        "@aws-cdk/integ-tests-alpha": "latest",
+        "@aws-crypto/sha256-js": "^5.2.0",
+        "@aws-sdk/client-api-gateway": "^3.1141.0",
+        "@aws-sdk/client-cloudfront": "^3.1141.0",
+        "@aws-sdk/client-dynamodb": "^3.1141.0",
+        "@aws-sdk/client-s3": "^3.1141.0",
+        "@aws-sdk/client-ssm": "^3.1141.0",
+        "@aws-sdk/lib-storage": "^3.1141.0",
+        "@mrgrain/jsii-struct-builder": "^0.7.64",
+        "@next/routing": "16.4.0",
+        "@smithy/signature-v4": "^2.3.0",
+        "@types/aws-lambda": "^8.10.163",
+        "@types/debug": "^4.1.13",
+        "@types/jest": "^29.5.14",
+        "@types/mime-types": "^2.1.4",
+        "@types/node": "^24",
+        "@typescript-eslint/eslint-plugin": "^8",
+        "@typescript-eslint/parser": "^8",
+        "aws-cdk": "^2.1143.0",
+        "aws-cdk-lib": "2.261.0",
+        "cdk-nag": "^2.38.2",
+        "cdklabs-projen-project-types": "^0.6.17",
+        "commit-and-tag-version": "^12",
+        constructs: "10.5.1",
+        debug: "^4.4.3",
+        esbuild: "^0.28.2",
+        eslint: "^9",
+        "eslint-config-prettier": "^9.1.2",
+        "eslint-import-resolver-typescript": "^3.10.1",
+        "eslint-plugin-import": "^2.32.0",
+        "eslint-plugin-prettier": "^5.5.6",
+        jest: "^29.7.0",
+        "jest-junit": "^17",
+        jsii: "~6.0.4",
+        "jsii-diff": "^1.140.0",
+        "jsii-docgen": "^10.5.0",
+        "jsii-pacmak": "^1.140.0",
+        "jsii-rosetta": "~5.9.67",
+        "mime-types": "^2.1.35",
+        next: "^16.4.0",
+        prettier: "^3.9.9",
+        projen: "^0.101.6",
+        "ts-jest": "^29.4.14",
+        "ts-node": "^10.9.2",
+        typescript: "^5.9.3",
+        undici: "^6.29.0"
+      },
+      peerDependencies: {
+        "aws-cdk-lib": "^2.261.0",
+        constructs: "^10.5.1"
+      },
+      pnpm: {
+        onlyBuiltDependencies: [
+          "esbuild",
+          "unrs-resolver",
+          "sharp"
+        ],
+        overrides: {
+          postcss: "^8.5.23",
+          browserslist: "^4.28.7",
+          "js-yaml@3": "^3.15.1",
+          "js-yaml@4": "^4.3.1",
+          "brace-expansion@1": "^1.1.21",
+          "brace-expansion@5": "^5.0.12",
+          "@babel/core": "^7.29.6",
+          sharp: "^0.35.5",
+          "source-map-js": "^1.2.2"
+        }
+      },
+      keywords: [
+        "aws",
+        "aws-cdk",
+        "cdk",
+        "next",
+        "next.js",
+        "nextjs"
+      ],
+      devEngines: {
+        packageManager: {
+          name: "pnpm",
+          version: "10.32.1",
+          onFail: "ignore"
+        }
+      },
+      main: "lib/index.js",
+      license: "Apache-2.0",
+      stability: "stable",
+      publishConfig: {
+        access: "public"
+      },
+      version: "0.7.11",
+      packageManager: "pnpm@10.32.1",
+      jest: {
+        coverageProvider: "v8",
+        testPathIgnorePatterns: [
+          "/node_modules/",
+          "/cdk.out/"
+        ],
+        testMatch: [
+          "<rootDir>/@(src|test)/**/*(*.)@(spec|test).ts?(x)",
+          "<rootDir>/@(src|test)/**/__tests__/**/*.ts?(x)",
+          "<rootDir>/@(projenrc)/**/*(*.)@(spec|test).ts?(x)",
+          "<rootDir>/@(projenrc)/**/__tests__/**/*.ts?(x)"
+        ],
+        clearMocks: true,
+        collectCoverage: true,
+        coverageReporters: [
+          "json",
+          "lcov",
+          "clover",
+          "cobertura",
+          "text"
+        ],
+        coverageDirectory: "coverage",
+        coveragePathIgnorePatterns: [
+          "/node_modules/",
+          "/cdk.out/"
+        ],
+        watchPathIgnorePatterns: [
+          "/node_modules/"
+        ],
+        reporters: [
+          "default",
+          [
+            "jest-junit",
+            {
+              outputDirectory: "test-reports"
+            }
+          ]
+        ],
+        transform: {
+          "^.+\\.[t]sx?$": [
+            "ts-jest",
+            {
+              tsconfig: "test/tsconfig.json"
+            }
+          ]
+        }
+      },
+      types: "lib/index.d.ts",
+      jsii: {
+        outdir: "dist",
+        targets: {},
+        tsconfig: "tsconfig.json",
+        validateTsconfig: "strict"
+      },
+      exports: {
+        ".": {
+          types: "./lib/index.d.ts",
+          import: "./lib/index.js",
+          default: "./lib/index.js"
+        },
+        "./adapter": {
+          import: "./lib/adapter/adapter.mjs",
+          default: "./lib/adapter/adapter.mjs"
+        },
+        "./cache-handler": {
+          import: "./lib/adapter/cache-handler.mjs",
+          default: "./lib/adapter/cache-handler.mjs"
+        },
+        "./cache-handlers/default": {
+          import: "./lib/adapter/use-cache-default-handler.mjs",
+          default: "./lib/adapter/use-cache-default-handler.mjs"
+        },
+        "./cache-handlers/remote": {
+          import: "./lib/adapter/use-cache-remote-handler.mjs",
+          default: "./lib/adapter/use-cache-remote-handler.mjs"
+        }
+      },
+      "//": '~~ Generated by projen. To modify, edit .projenrc.ts and run "pnpm dlx projen".'
+    };
+  }
+});
+
 // src/runtime/lambda.mts
 import { dirname as dirname2 } from "node:path";
-import { fileURLToPath as fileURLToPath2 } from "node:url";
+import { fileURLToPath } from "node:url";
 
 // src/runtime/core.ts
 import { readFile as readFile3 } from "node:fs/promises";
@@ -37547,8 +37787,7 @@ function requestLocale(manifest, url) {
   const i18n = asI18n(manifest.config.i18n);
   if (!i18n) return void 0;
   const pathname = withoutPathPrefix(url.pathname, manifest.config.basePath);
-  const segment = (pathname.split("/")[1] ?? "").toLowerCase();
-  return i18n.locales.find((candidate) => candidate.toLowerCase() === segment) ?? (0, import_routing.detectDomainLocale)(i18n.domains, url.hostname)?.defaultLocale ?? i18n.defaultLocale;
+  return (0, import_routing.normalizeLocalePath)(pathname, i18n.locales).detectedLocale ?? (0, import_routing.detectDomainLocale)(i18n.domains, url.hostname)?.defaultLocale ?? i18n.defaultLocale;
 }
 
 // src/runtime/entrypoints.ts
@@ -38032,9 +38271,8 @@ function padEmptyBody() {
 }
 
 // src/runtime/image.ts
-import { readFileSync as readFileSync2 } from "node:fs";
 import { isAbsolute as isAbsolutePath, join as join9 } from "node:path";
-import { fileURLToPath, pathToFileURL } from "node:url";
+import { pathToFileURL } from "node:url";
 
 // src/runtime/image-utils.ts
 var import_client_s32 = __toESM(require_dist_cjs16());
@@ -38105,6 +38343,9 @@ function resolveErrorResponse(error2, ImageError) {
   return { statusCode: 500, message: "Internal Server Error" };
 }
 
+// src/cdk-nextjs-version.ts
+var CDK_NEXTJS_VERSION = require_package().version;
+
 // src/runtime/next-modules.ts
 import { createRequire as createRequire2 } from "node:module";
 import { join as join8 } from "node:path";
@@ -38164,13 +38405,13 @@ var RuntimeImageOptimizer = class {
    * off.
    */
   isEnabled() {
-    this.loaded ??= loadImageRuntime(this.options);
-    const { imagesConfig } = this.loaded;
-    return imagesConfig.loader === "default" && !imagesConfig.unoptimized;
+    const images = manifestImages(this.options.manifest);
+    return images.loader === "default" && !images.unoptimized;
   }
   async handle(req, res, url, waitUntil) {
     this.loaded ??= loadImageRuntime(this.options);
-    const { next, nextConfig, imagesConfig } = this.loaded;
+    const { next, nextConfig } = this.loaded;
+    const imagesConfig = nextConfig.images;
     const {
       ImageError,
       ImageOptimizerCache,
@@ -38405,9 +38646,8 @@ function newImageResponseCache(ResponseCache) {
   }
 }
 function cacheHandlerUrl(distDir, cacheHandler) {
-  const path = cacheHandler.startsWith("file://") ? fileURLToPath(cacheHandler) : cacheHandler;
   return pathToFileURL(
-    isAbsolutePath(path) ? path : join9(distDir, path)
+    isAbsolutePath(cacheHandler) ? cacheHandler : join9(distDir, cacheHandler)
   ).toString();
 }
 function deferWrites(images, waitUntil) {
@@ -38427,29 +38667,29 @@ function sendText(res, statusCode, body) {
   res.setHeader("Content-Type", "text/plain");
   res.end(body);
 }
-function loadImageRuntime({ deploymentRoot, manifest }) {
+function manifestImages(manifest) {
+  if (manifest.cdkNextjsVersion !== CDK_NEXTJS_VERSION) {
+    throw new Error(
+      `The adapter manifest was written by cdk-nextjs ${manifest.cdkNextjsVersion ?? "(unknown)"}, but this runtime is cdk-nextjs ${CDK_NEXTJS_VERSION}. Rebuild the app with this version.`
+    );
+  }
+  return manifest.config.images;
+}
+function loadImageRuntime({ manifest }) {
   const next = {
-    configShared: nextModule("next/dist/server/config-shared.js"),
-    imageConfig: nextModule("next/dist/shared/lib/image-config.js"),
     optimizer: nextModule("next/dist/server/image-optimizer.js"),
     serveStatic: nextModule("next/dist/server/serve-static.js")
   };
-  const path = join9(
-    deploymentRoot,
-    manifest.relativeProjectDir,
-    manifest.config.distDir,
-    "required-server-files.json"
-  );
-  const required = JSON.parse(readFileSync2(path, "utf-8"));
-  const nextConfig = next.configShared.getNextConfigRuntime(required.config);
-  return {
-    next,
-    nextConfig,
-    imagesConfig: {
-      ...next.imageConfig.imageConfigDefault,
-      ...nextConfig.images
-    }
+  const { config } = manifest;
+  const nextConfig = {
+    basePath: config.basePath,
+    assetPrefix: config.assetPrefix,
+    images: manifestImages(manifest),
+    experimental: config.experimental,
+    cacheHandler: config.cacheHandler ?? void 0,
+    cacheMaxMemorySize: config.cacheMaxMemorySize
   };
+  return { next, nextConfig };
 }
 
 // src/runtime/middleware.ts
@@ -39702,7 +39942,7 @@ function formatQuery(event) {
 
 // src/runtime/lambda.mts
 var runtime = await loadRuntime(
-  deploymentRootOf(dirname2(fileURLToPath2(import.meta.url)))
+  deploymentRootOf(dirname2(fileURLToPath(import.meta.url)))
 );
 var LambdaResponseSink = class {
   constructor(responseStream) {

package/lib/runtime/manifest.d.ts

@@ -1,5 +1,3 @@
-/** Current {@link AdapterManifest.version}. Bump on any breaking shape change. */
-export declare const ADAPTER_MANIFEST_VERSION = 1;
 /**
  * Directory written inside `distDir` (`.next`), matching the existing
  * `cdk-nextjs-init-cache` convention.
@@ -84,7 +82,13 @@ export declare const PUBLIC_FILES_FILE_NAME = "public-files.json";
  */
 export declare function deployedManifestPath(deploymentRoot: string): string;
 export interface AdapterManifest {
-    readonly version: 1;
+    /**
+     * The cdk-nextjs that wrote this (`CDK_NEXTJS_VERSION`). Whatever reads the
+     * manifest requires its own version here, rather than a hand-bumped shape
+     * version: the adapter and its readers ship in one package, so a mismatch is
+     * always a stale build or a second cdk-nextjs install.
+     */
+    readonly cdkNextjsVersion: string;
     readonly buildId: string;
     /**
      * From the deployment root to the Next.js project dir. "" when the app is at
@@ -171,11 +175,7 @@ export interface AdapterManifestConfig {
     readonly basePath: string;
     readonly trailingSlash: boolean;
     readonly assetPrefix: string;
-    /**
-     * `distDir` relative to the project dir — `.next` unless configured. POSIX.
-     * The runtime reads `required-server-files.json` from here for the image
-     * optimizer's config.
-     */
+    /** `distDir` relative to the project dir — `.next` unless configured. POSIX. */
     readonly distDir: string;
     /**
      * `next.config` `compress`. The runtime gzips streamed responses itself
@@ -200,6 +200,32 @@ export interface AdapterManifestConfig {
      * when the app sets none.
      */
     readonly deploymentId: string;
+    /**
+     * `next.config` `images`, resolved and defaulted (`ctx.config.images`).
+     * `NextConfigComplete["images"]`-shaped. With {@link experimental},
+     * {@link cacheHandler} and {@link cacheMaxMemorySize}, what the image
+     * optimizer is handed as its `nextConfig`.
+     *
+     * `images` and `experimental` are copied whole rather than field by field:
+     * Next's optimizer picks what it reads out of both (six `experimental.imgOpt*`
+     * flags in 16.4), and a hand-kept list would silently drop the next one it
+     * starts reading.
+     */
+    readonly images: unknown;
+    /**
+     * `next.config` `experimental`, resolved (`ctx.config.experimental`), as
+     * JSON: function-valued entries are dropped, as they are from
+     * `required-server-files.json`. See {@link images}.
+     */
+    readonly experimental: unknown;
+    /**
+     * `next.config` `cacheHandler`, relative to the dist dir as
+     * `required-server-files.json` has it (the build machine's absolute path
+     * means nothing in the deployment). `null` when there is none.
+     */
+    readonly cacheHandler: string | null;
+    /** `next.config` `cacheMaxMemorySize`. */
+    readonly cacheMaxMemorySize: number;
 }
 export type AdapterEntrypointType = "app-page" | "app-route" | "page" | "page-api";
 export interface AdapterEntrypoint {

package/lib/runtime/manifest.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PUBLIC_FILES_FILE_NAME = exports.RUNTIME_DIR_NAME = exports.ERROR_PAGE_SUFFIXES = exports.STATUS_PAGE_SUFFIXES = exports.MANIFEST_FILE_NAME = exports.REVALIDATED_PAGE_HOOK = exports.FUNCTION_GROUP_ENV_VAR = exports.GROUPS_DIR_NAME = exports.STAGING_DIR_NAME = exports.ADAPTER_DIR_NAME = exports.ADAPTER_MANIFEST_VERSION = void 0;
+exports.PUBLIC_FILES_FILE_NAME = exports.RUNTIME_DIR_NAME = exports.ERROR_PAGE_SUFFIXES = exports.STATUS_PAGE_SUFFIXES = exports.MANIFEST_FILE_NAME = exports.REVALIDATED_PAGE_HOOK = exports.FUNCTION_GROUP_ENV_VAR = exports.GROUPS_DIR_NAME = exports.STAGING_DIR_NAME = exports.ADAPTER_DIR_NAME = void 0;
 exports.groupStagingDirName = groupStagingDirName;
 exports.deployedManifestPath = deployedManifestPath;
 /**
@@ -15,15 +15,17 @@ exports.deployedManifestPath = deployedManifestPath;
  * build-machine absolute path: absolute paths work on the build machine and
  * fail in Lambda. The staging tree those keys index into is
  * `<distDir>/cdk-nextjs-adapter/app`; the runtime calls that directory the
- * *deployment root* and resolves every key against it.
+ * *deployment root* and resolves every key against it. The exceptions are the
+ * Next.js config copied into {@link AdapterManifestConfig}: `cacheHandler` is
+ * relative to the dist dir, as Next's own `required-server-files.json` has it,
+ * and `images` is copied whole, so `images.loaderFile` stays the build machine's
+ * absolute path (nothing in the runtime reads it).
  *
  * This file is intentionally not exported from `src/index.ts`: it is an
  * internal contract, not public construct API, so it is exempt from the JSII
  * restrictions the rest of `src/` follows.
  */
 const node_path_1 = require("node:path");
-/** Current {@link AdapterManifest.version}. Bump on any breaking shape change. */
-exports.ADAPTER_MANIFEST_VERSION = 1;
 /**
  * Directory written inside `distDir` (`.next`), matching the existing
  * `cdk-nextjs-init-cache` convention.
@@ -115,4 +117,4 @@ exports.PUBLIC_FILES_FILE_NAME = "public-files.json";
 function deployedManifestPath(deploymentRoot) {
     return (0, node_path_1.join)(deploymentRoot, exports.RUNTIME_DIR_NAME, exports.MANIFEST_FILE_NAME);
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"manifest.js","sourceRoot":"","sources":["../../src/runtime/manifest.ts"],"names":[],"mappings":";;;AAsEA,kDAEC;AAoDD,oDAEC;AA9HD;;;;;;;;;;;;;;;;;GAiBG;AACH,yCAAiC;AAEjC,kFAAkF;AACrE,QAAA,wBAAwB,GAAG,CAAC,CAAC;AAE1C;;;GAGG;AACU,QAAA,gBAAgB,GAAG,oBAAoB,CAAC;AAErD;;;;GAIG;AACU,QAAA,gBAAgB,GAAG,KAAK,CAAC;AAEtC;;;;;;;;;;GAUG;AACU,QAAA,eAAe,GAAG,QAAQ,CAAC;AAExC;;;GAGG;AACU,QAAA,sBAAsB,GAAG,2BAA2B,CAAC;AAElE;;;;;GAKG;AACU,QAAA,qBAAqB,GAAG,MAAM,CAAC,GAAG,CAC7C,sCAAsC,CACvC,CAAC;AAEF;;;;GAIG;AACH,SAAgB,mBAAmB,CAAC,KAAc;IAChD,OAAO,KAAK,KAAK,SAAS,CAAC,CAAC,CAAC,wBAAgB,CAAC,CAAC,CAAC,GAAG,uBAAe,IAAI,KAAK,EAAE,CAAC;AAChF,CAAC;AAED,wEAAwE;AAC3D,QAAA,kBAAkB,GAAG,eAAe,CAAC;AAElD;;;GAGG;AACU,QAAA,oBAAoB,GAAG;IAClC,GAAG,EAAE,CAAC,aAAa,EAAE,MAAM,CAAC;IAC5B,GAAG,EAAE,CAAC,MAAM,CAAC;IACb,QAAQ,EAAE,SAAS;CACpB,CAAC;AAEF;;;;;GAKG;AACU,QAAA,mBAAmB,GAAG;IACjC,GAAG,4BAAoB,CAAC,GAAG,CAAC;IAC5B,GAAG,4BAAoB,CAAC,GAAG,CAAC;IAC5B,4BAAoB,CAAC,QAAQ;CAC9B,CAAC;AAEF;;;;;GAKG;AACU,QAAA,gBAAgB,GAAG,oBAAoB,CAAC;AAErD;;;;;;;;GAQG;AACU,QAAA,sBAAsB,GAAG,mBAAmB,CAAC;AAE1D;;;;;GAKG;AACH,SAAgB,oBAAoB,CAAC,cAAsB;IACzD,OAAO,IAAA,gBAAI,EAAC,cAAc,EAAE,wBAAgB,EAAE,0BAAkB,CAAC,CAAC;AACpE,CAAC","sourcesContent":["/**\n * The build-time → run-time contract for the adapter runtime.\n *\n * `src/adapter/build-outputs.ts` writes an {@link AdapterManifest} during\n * `next build`; the runtime shells in `src/runtime/` read it at cold start and\n * the CDK constructs read it at synth. It is the only thing that crosses those\n * three boundaries, so it is deliberately plain JSON.\n *\n * **Every path in this manifest is a repo-root-relative POSIX key**, never a\n * build-machine absolute path: absolute paths work on the build machine and\n * fail in Lambda. The staging tree those keys index into is\n * `<distDir>/cdk-nextjs-adapter/app`; the runtime calls that directory the\n * *deployment root* and resolves every key against it.\n *\n * This file is intentionally not exported from `src/index.ts`: it is an\n * internal contract, not public construct API, so it is exempt from the JSII\n * restrictions the rest of `src/` follows.\n */\nimport { join } from \"node:path\";\n\n/** Current {@link AdapterManifest.version}. Bump on any breaking shape change. */\nexport const ADAPTER_MANIFEST_VERSION = 1;\n\n/**\n * Directory written inside `distDir` (`.next`), matching the existing\n * `cdk-nextjs-init-cache` convention.\n */\nexport const ADAPTER_DIR_NAME = \"cdk-nextjs-adapter\";\n\n/**\n * Deployment root inside {@link ADAPTER_DIR_NAME}: the staged union of every\n * shipped output's traced `assets`, keyed by repo-root-relative path. This is\n * what replaces `output: \"standalone\"`.\n */\nexport const STAGING_DIR_NAME = \"app\";\n\n/**\n * Parent of the per-group deployment roots, used instead of\n * {@link STAGING_DIR_NAME} when `functionGroups` splits the app: each group is\n * staged at `<distDir>/cdk-nextjs-adapter/groups/<name>/`, including the implicit\n * `default` one.\n *\n * Splitting gets its own subtree rather than reusing `app/` for the default group\n * so that a tree left over from a build with different grouping can never be\n * mistaken for this build's, and so `du` on either directory answers \"how big is\n * the thing I deploy\" without qualification.\n */\nexport const GROUPS_DIR_NAME = \"groups\";\n\n/**\n * Which group the running function *is*. Set per Lambda at synth, read by the\n * runtime only to make a misroute say so; see `ownedRouteError`.\n */\nexport const FUNCTION_GROUP_ENV_VAR = \"CDK_NEXTJS_FUNCTION_GROUP\";\n\n/**\n * The global the cache handler (`src/adapter/s3-cache-handler.ts`) registers its\n * CloudFront invalidation hook under, and the runtime (`core.ts`) calls. A global\n * rather than an import, because the cache handler is a separate bundle that\n * Next.js loads itself: the two share a process, not a module graph.\n */\nexport const REVALIDATED_PAGE_HOOK = Symbol.for(\n  \"cdk-nextjs.invalidateRevalidatedPage\",\n);\n\n/**\n * Directory inside {@link ADAPTER_DIR_NAME} holding one deployment root, relative\n * and POSIX. `undefined` means \"not splitting\", which is its own layout rather\n * than a group named `default`.\n */\nexport function groupStagingDirName(group?: string): string {\n  return group === undefined ? STAGING_DIR_NAME : `${GROUPS_DIR_NAME}/${group}`;\n}\n\n/** {@link AdapterManifest}, written inside {@link ADAPTER_DIR_NAME}. */\nexport const MANIFEST_FILE_NAME = \"manifest.json\";\n\n/**\n * The entrypoints the runtime renders a 404 or a 500 with, in the order it\n * tries them, and `/_error`, the last resort for both. Before basePath.\n */\nexport const STATUS_PAGE_SUFFIXES = {\n  404: [\"/_not-found\", \"/404\"],\n  500: [\"/500\"],\n  fallback: \"/_error\",\n};\n\n/**\n * Every {@link STATUS_PAGE_SUFFIXES} page: App Router's `/_not-found`, Pages\n * Router's `/404` and `/500`, and `/_error`. The runtime may render any request\n * with them, wherever it landed, so every function group stages them\n * (`collectGroupStagingPlan`) and no URL has to be routed to them.\n */\nexport const ERROR_PAGE_SUFFIXES = [\n  ...STATUS_PAGE_SUFFIXES[404],\n  ...STATUS_PAGE_SUFFIXES[500],\n  STATUS_PAGE_SUFFIXES.fallback,\n];\n\n/**\n * Reserved key inside the staging tree that cdk-nextjs's own bundled runtime\n * files are copied to at synth (Lambda handler\n * `cdk-nextjs-runtime/lambda.handler`). Reserved because a repo-root-relative\n * asset key could otherwise collide with it.\n */\nexport const RUNTIME_DIR_NAME = \"cdk-nextjs-runtime\";\n\n/**\n * The file, next to the manifest in {@link RUNTIME_DIR_NAME}, that lists\n * `public/` on every type but `NextjsRegionalContainers`: a JSON array of\n * `/`-separated paths relative to `public/`, as `readPublicFiles` returns them.\n * Synth writes it after the build command (so `postbuild` output is listed)\n * because those deployment packages do not carry `public/` itself; the runtime\n * serves a listed file from S3. The RegionalContainers image copies `public/`\n * in and has no such file.\n */\nexport const PUBLIC_FILES_FILE_NAME = \"public-files.json\";\n\n/**\n * Where the runtime reads {@link AdapterManifest} from, given the deployment\n * root. Synth copies `manifest.json` in next to the bundled shells rather than\n * leaving it at its build-time location (`<distDir>/cdk-nextjs-adapter/`, one\n * level *above* the staging tree) so that a single asset is self-describing.\n */\nexport function deployedManifestPath(deploymentRoot: string): string {\n  return join(deploymentRoot, RUNTIME_DIR_NAME, MANIFEST_FILE_NAME);\n}\n\nexport interface AdapterManifest {\n  readonly version: 1;\n  readonly buildId: string;\n  /**\n   * From the deployment root to the Next.js project dir. \"\" when the app is at\n   * the repo root.\n   *\n   * **The runtime `chdir`s here at cold start, and that is load-bearing.** Next\n   * inlines `__NEXT_RELATIVE_PROJECT_DIR = relative(buildCwd, projectDir)` into\n   * every entrypoint at build time (`next/dist/build/define-env.js`), and the\n   * built code resolves it as `join(process.cwd(), relativeProjectDir)` to find\n   * `required-server-files.json`, the prerender manifest, and the app's own\n   * files. `requestMeta.relativeProjectDir` overrides it in\n   * `next/dist/server/route-modules/route-module.js` but **not** in\n   * `app-page-runtime.js`, which passes the inlined value through as the render\n   * `dir` — so `process.cwd()` is the only mechanism that covers every\n   * entrypoint type. `build-outputs.ts` asserts `buildCwd === projectDir` to\n   * keep the inlined value `\"\"` and this field the whole answer.\n   */\n  readonly relativeProjectDir: string;\n  readonly config: AdapterManifestConfig;\n  /** `ctx.routing` verbatim, including `middlewareMatchers`. */\n  readonly routing: unknown;\n  /**\n   * Every pathname `resolveRoutes` is allowed to match: the {@link entrypoints}\n   * keys plus {@link staticFiles}. Sorted and deduped.\n   */\n  readonly pathnames: string[];\n  /**\n   * Route *template* (`/blog/[slug]`) → entrypoint. Keys are basePath- and\n   * locale-prefixed exactly as `resolveRoutes` reports `resolvedPathname`, so\n   * the lookup is a plain index with no normalization.\n   *\n   * Includes dynamic *prerender* templates (notably Pages Router\n   * `/_next/data/<buildId>/<locale>/blog/[slug].json`) mapped to the entrypoint\n   * of the route that owns them.\n   */\n  readonly entrypoints: Record<string, AdapterEntrypoint>;\n  readonly middleware: AdapterMiddleware | null;\n  /**\n   * Pathname → repo-root-relative POSIX key of the file to serve.\n   *\n   * A map rather than a list of pathnames because the two are not derivable from\n   * each other: `/favicon.ico` is `<distDir>/server/app/favicon.ico.body`, `/404`\n   * is `<distDir>/server/pages/404.html`, and a fully-static Pages Router route\n   * is `<distDir>/server/pages/<route>.html`. The runtime serves these itself —\n   * `NextjsStaticAssets` only uploads `<distDir>/static` and `public`, so nothing\n   * in front of the compute can answer them.\n   *\n   * Whether the file is present in the deployment package depends on the\n   * deployment type; see `stageServedStaticFiles` in `build-outputs.ts`.\n   */\n  readonly staticFiles: Record<string, string>;\n  /**\n   * Group name → the route templates that group's deployment package holds,\n   * including the implicit `default`. Absent when `functionGroups` is not used.\n   *\n   * Every group gets the *same* manifest, because routing is identical in all of\n   * them: middleware, redirects and rewrites are duplicated by design, and a\n   * group has to be able to resolve a pathname it does not own in order to say so\n   * rather than crash on a missing file. This field is what lets it say so.\n   */\n  readonly groups?: Record<string, string[]>;\n  /**\n   * Every behavior the edge routes a non-default group on, most specific first\n   * (`GroupBehavior` in `function-groups.ts`). Present exactly when\n   * {@link groups} is. Recorded by the assignment rather than recomputed at\n   * synth, so the behaviors deployed are the ones it checked.\n   */\n  readonly behaviors?: { group: string; route: string; pattern: string }[];\n  /**\n   * The `functionGroups` the build was split by (name and routes, as passed in\n   * `CDK_NEXTJS_FUNCTION_GROUPS`), present exactly when {@link groups} is. Synth\n   * compares it with its own props to catch a stale or hand-run build.\n   */\n  readonly functionGroups?: { name: string; routes: string[] }[];\n}\n\nexport interface AdapterManifestConfig {\n  readonly basePath: string;\n  readonly trailingSlash: boolean;\n  readonly assetPrefix: string;\n  /**\n   * `distDir` relative to the project dir — `.next` unless configured. POSIX.\n   * The runtime reads `required-server-files.json` from here for the image\n   * optimizer's config.\n   */\n  readonly distDir: string;\n  /**\n   * `next.config` `compress`. The runtime gzips streamed responses itself\n   * (neither API Gateway in STREAM mode nor CloudFront can), so honoring this\n   * is on us.\n   */\n  readonly compress: boolean;\n  /**\n   * `next.config` `generateEtags`. Honored for the files the runtime serves\n   * itself, as `next start` does (`serveStatic`'s `etag` option).\n   */\n  readonly generateEtags: boolean;\n  /**\n   * `ResolveRoutesParams[\"i18n\"]`-shaped, narrower than NextConfigComplete.\n   * `null` when the app configures no `i18n`.\n   */\n  readonly i18n: unknown | null;\n  /**\n   * `next.config` `deploymentId` (or `NEXT_DEPLOYMENT_ID`), reduced to the\n   * characters safe in an S3 key prefix and a DynamoDB partition key — `/` in\n   * particular would split the prefix `prune-cache-bucket.ts` matches on. `\"\"`\n   * when the app sets none.\n   */\n  readonly deploymentId: string;\n}\n\nexport type AdapterEntrypointType =\n  \"app-page\" | \"app-route\" | \"page\" | \"page-api\";\n\nexport interface AdapterEntrypoint {\n  readonly id: string;\n  /** Repo-root-relative POSIX key inside the staging tree. Never absolute. */\n  readonly filePath: string;\n  readonly type: AdapterEntrypointType;\n}\n\nexport interface AdapterMiddleware {\n  readonly id: string;\n  /** Repo-root-relative POSIX key inside the staging tree. Never absolute. */\n  readonly filePath: string;\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"manifest.js","sourceRoot":"","sources":["../../src/runtime/manifest.ts"],"names":[],"mappings":";;;AAuEA,kDAEC;AAoDD,oDAEC;AA/HD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,yCAAiC;AAEjC;;;GAGG;AACU,QAAA,gBAAgB,GAAG,oBAAoB,CAAC;AAErD;;;;GAIG;AACU,QAAA,gBAAgB,GAAG,KAAK,CAAC;AAEtC;;;;;;;;;;GAUG;AACU,QAAA,eAAe,GAAG,QAAQ,CAAC;AAExC;;;GAGG;AACU,QAAA,sBAAsB,GAAG,2BAA2B,CAAC;AAElE;;;;;GAKG;AACU,QAAA,qBAAqB,GAAG,MAAM,CAAC,GAAG,CAC7C,sCAAsC,CACvC,CAAC;AAEF;;;;GAIG;AACH,SAAgB,mBAAmB,CAAC,KAAc;IAChD,OAAO,KAAK,KAAK,SAAS,CAAC,CAAC,CAAC,wBAAgB,CAAC,CAAC,CAAC,GAAG,uBAAe,IAAI,KAAK,EAAE,CAAC;AAChF,CAAC;AAED,wEAAwE;AAC3D,QAAA,kBAAkB,GAAG,eAAe,CAAC;AAElD;;;GAGG;AACU,QAAA,oBAAoB,GAAG;IAClC,GAAG,EAAE,CAAC,aAAa,EAAE,MAAM,CAAC;IAC5B,GAAG,EAAE,CAAC,MAAM,CAAC;IACb,QAAQ,EAAE,SAAS;CACpB,CAAC;AAEF;;;;;GAKG;AACU,QAAA,mBAAmB,GAAG;IACjC,GAAG,4BAAoB,CAAC,GAAG,CAAC;IAC5B,GAAG,4BAAoB,CAAC,GAAG,CAAC;IAC5B,4BAAoB,CAAC,QAAQ;CAC9B,CAAC;AAEF;;;;;GAKG;AACU,QAAA,gBAAgB,GAAG,oBAAoB,CAAC;AAErD;;;;;;;;GAQG;AACU,QAAA,sBAAsB,GAAG,mBAAmB,CAAC;AAE1D;;;;;GAKG;AACH,SAAgB,oBAAoB,CAAC,cAAsB;IACzD,OAAO,IAAA,gBAAI,EAAC,cAAc,EAAE,wBAAgB,EAAE,0BAAkB,CAAC,CAAC;AACpE,CAAC","sourcesContent":["/**\n * The build-time → run-time contract for the adapter runtime.\n *\n * `src/adapter/build-outputs.ts` writes an {@link AdapterManifest} during\n * `next build`; the runtime shells in `src/runtime/` read it at cold start and\n * the CDK constructs read it at synth. It is the only thing that crosses those\n * three boundaries, so it is deliberately plain JSON.\n *\n * **Every path in this manifest is a repo-root-relative POSIX key**, never a\n * build-machine absolute path: absolute paths work on the build machine and\n * fail in Lambda. The staging tree those keys index into is\n * `<distDir>/cdk-nextjs-adapter/app`; the runtime calls that directory the\n * *deployment root* and resolves every key against it. The exceptions are the\n * Next.js config copied into {@link AdapterManifestConfig}: `cacheHandler` is\n * relative to the dist dir, as Next's own `required-server-files.json` has it,\n * and `images` is copied whole, so `images.loaderFile` stays the build machine's\n * absolute path (nothing in the runtime reads it).\n *\n * This file is intentionally not exported from `src/index.ts`: it is an\n * internal contract, not public construct API, so it is exempt from the JSII\n * restrictions the rest of `src/` follows.\n */\nimport { join } from \"node:path\";\n\n/**\n * Directory written inside `distDir` (`.next`), matching the existing\n * `cdk-nextjs-init-cache` convention.\n */\nexport const ADAPTER_DIR_NAME = \"cdk-nextjs-adapter\";\n\n/**\n * Deployment root inside {@link ADAPTER_DIR_NAME}: the staged union of every\n * shipped output's traced `assets`, keyed by repo-root-relative path. This is\n * what replaces `output: \"standalone\"`.\n */\nexport const STAGING_DIR_NAME = \"app\";\n\n/**\n * Parent of the per-group deployment roots, used instead of\n * {@link STAGING_DIR_NAME} when `functionGroups` splits the app: each group is\n * staged at `<distDir>/cdk-nextjs-adapter/groups/<name>/`, including the implicit\n * `default` one.\n *\n * Splitting gets its own subtree rather than reusing `app/` for the default group\n * so that a tree left over from a build with different grouping can never be\n * mistaken for this build's, and so `du` on either directory answers \"how big is\n * the thing I deploy\" without qualification.\n */\nexport const GROUPS_DIR_NAME = \"groups\";\n\n/**\n * Which group the running function *is*. Set per Lambda at synth, read by the\n * runtime only to make a misroute say so; see `ownedRouteError`.\n */\nexport const FUNCTION_GROUP_ENV_VAR = \"CDK_NEXTJS_FUNCTION_GROUP\";\n\n/**\n * The global the cache handler (`src/adapter/s3-cache-handler.ts`) registers its\n * CloudFront invalidation hook under, and the runtime (`core.ts`) calls. A global\n * rather than an import, because the cache handler is a separate bundle that\n * Next.js loads itself: the two share a process, not a module graph.\n */\nexport const REVALIDATED_PAGE_HOOK = Symbol.for(\n  \"cdk-nextjs.invalidateRevalidatedPage\",\n);\n\n/**\n * Directory inside {@link ADAPTER_DIR_NAME} holding one deployment root, relative\n * and POSIX. `undefined` means \"not splitting\", which is its own layout rather\n * than a group named `default`.\n */\nexport function groupStagingDirName(group?: string): string {\n  return group === undefined ? STAGING_DIR_NAME : `${GROUPS_DIR_NAME}/${group}`;\n}\n\n/** {@link AdapterManifest}, written inside {@link ADAPTER_DIR_NAME}. */\nexport const MANIFEST_FILE_NAME = \"manifest.json\";\n\n/**\n * The entrypoints the runtime renders a 404 or a 500 with, in the order it\n * tries them, and `/_error`, the last resort for both. Before basePath.\n */\nexport const STATUS_PAGE_SUFFIXES = {\n  404: [\"/_not-found\", \"/404\"],\n  500: [\"/500\"],\n  fallback: \"/_error\",\n};\n\n/**\n * Every {@link STATUS_PAGE_SUFFIXES} page: App Router's `/_not-found`, Pages\n * Router's `/404` and `/500`, and `/_error`. The runtime may render any request\n * with them, wherever it landed, so every function group stages them\n * (`collectGroupStagingPlan`) and no URL has to be routed to them.\n */\nexport const ERROR_PAGE_SUFFIXES = [\n  ...STATUS_PAGE_SUFFIXES[404],\n  ...STATUS_PAGE_SUFFIXES[500],\n  STATUS_PAGE_SUFFIXES.fallback,\n];\n\n/**\n * Reserved key inside the staging tree that cdk-nextjs's own bundled runtime\n * files are copied to at synth (Lambda handler\n * `cdk-nextjs-runtime/lambda.handler`). Reserved because a repo-root-relative\n * asset key could otherwise collide with it.\n */\nexport const RUNTIME_DIR_NAME = \"cdk-nextjs-runtime\";\n\n/**\n * The file, next to the manifest in {@link RUNTIME_DIR_NAME}, that lists\n * `public/` on every type but `NextjsRegionalContainers`: a JSON array of\n * `/`-separated paths relative to `public/`, as `readPublicFiles` returns them.\n * Synth writes it after the build command (so `postbuild` output is listed)\n * because those deployment packages do not carry `public/` itself; the runtime\n * serves a listed file from S3. The RegionalContainers image copies `public/`\n * in and has no such file.\n */\nexport const PUBLIC_FILES_FILE_NAME = \"public-files.json\";\n\n/**\n * Where the runtime reads {@link AdapterManifest} from, given the deployment\n * root. Synth copies `manifest.json` in next to the bundled shells rather than\n * leaving it at its build-time location (`<distDir>/cdk-nextjs-adapter/`, one\n * level *above* the staging tree) so that a single asset is self-describing.\n */\nexport function deployedManifestPath(deploymentRoot: string): string {\n  return join(deploymentRoot, RUNTIME_DIR_NAME, MANIFEST_FILE_NAME);\n}\n\nexport interface AdapterManifest {\n  /**\n   * The cdk-nextjs that wrote this (`CDK_NEXTJS_VERSION`). Whatever reads the\n   * manifest requires its own version here, rather than a hand-bumped shape\n   * version: the adapter and its readers ship in one package, so a mismatch is\n   * always a stale build or a second cdk-nextjs install.\n   */\n  readonly cdkNextjsVersion: string;\n  readonly buildId: string;\n  /**\n   * From the deployment root to the Next.js project dir. \"\" when the app is at\n   * the repo root.\n   *\n   * **The runtime `chdir`s here at cold start, and that is load-bearing.** Next\n   * inlines `__NEXT_RELATIVE_PROJECT_DIR = relative(buildCwd, projectDir)` into\n   * every entrypoint at build time (`next/dist/build/define-env.js`), and the\n   * built code resolves it as `join(process.cwd(), relativeProjectDir)` to find\n   * `required-server-files.json`, the prerender manifest, and the app's own\n   * files. `requestMeta.relativeProjectDir` overrides it in\n   * `next/dist/server/route-modules/route-module.js` but **not** in\n   * `app-page-runtime.js`, which passes the inlined value through as the render\n   * `dir` — so `process.cwd()` is the only mechanism that covers every\n   * entrypoint type. `build-outputs.ts` asserts `buildCwd === projectDir` to\n   * keep the inlined value `\"\"` and this field the whole answer.\n   */\n  readonly relativeProjectDir: string;\n  readonly config: AdapterManifestConfig;\n  /** `ctx.routing` verbatim, including `middlewareMatchers`. */\n  readonly routing: unknown;\n  /**\n   * Every pathname `resolveRoutes` is allowed to match: the {@link entrypoints}\n   * keys plus {@link staticFiles}. Sorted and deduped.\n   */\n  readonly pathnames: string[];\n  /**\n   * Route *template* (`/blog/[slug]`) → entrypoint. Keys are basePath- and\n   * locale-prefixed exactly as `resolveRoutes` reports `resolvedPathname`, so\n   * the lookup is a plain index with no normalization.\n   *\n   * Includes dynamic *prerender* templates (notably Pages Router\n   * `/_next/data/<buildId>/<locale>/blog/[slug].json`) mapped to the entrypoint\n   * of the route that owns them.\n   */\n  readonly entrypoints: Record<string, AdapterEntrypoint>;\n  readonly middleware: AdapterMiddleware | null;\n  /**\n   * Pathname → repo-root-relative POSIX key of the file to serve.\n   *\n   * A map rather than a list of pathnames because the two are not derivable from\n   * each other: `/favicon.ico` is `<distDir>/server/app/favicon.ico.body`, `/404`\n   * is `<distDir>/server/pages/404.html`, and a fully-static Pages Router route\n   * is `<distDir>/server/pages/<route>.html`. The runtime serves these itself —\n   * `NextjsStaticAssets` only uploads `<distDir>/static` and `public`, so nothing\n   * in front of the compute can answer them.\n   *\n   * Whether the file is present in the deployment package depends on the\n   * deployment type; see `stageServedStaticFiles` in `build-outputs.ts`.\n   */\n  readonly staticFiles: Record<string, string>;\n  /**\n   * Group name → the route templates that group's deployment package holds,\n   * including the implicit `default`. Absent when `functionGroups` is not used.\n   *\n   * Every group gets the *same* manifest, because routing is identical in all of\n   * them: middleware, redirects and rewrites are duplicated by design, and a\n   * group has to be able to resolve a pathname it does not own in order to say so\n   * rather than crash on a missing file. This field is what lets it say so.\n   */\n  readonly groups?: Record<string, string[]>;\n  /**\n   * Every behavior the edge routes a non-default group on, most specific first\n   * (`GroupBehavior` in `function-groups.ts`). Present exactly when\n   * {@link groups} is. Recorded by the assignment rather than recomputed at\n   * synth, so the behaviors deployed are the ones it checked.\n   */\n  readonly behaviors?: { group: string; route: string; pattern: string }[];\n  /**\n   * The `functionGroups` the build was split by (name and routes, as passed in\n   * `CDK_NEXTJS_FUNCTION_GROUPS`), present exactly when {@link groups} is. Synth\n   * compares it with its own props to catch a stale or hand-run build.\n   */\n  readonly functionGroups?: { name: string; routes: string[] }[];\n}\n\nexport interface AdapterManifestConfig {\n  readonly basePath: string;\n  readonly trailingSlash: boolean;\n  readonly assetPrefix: string;\n  /** `distDir` relative to the project dir — `.next` unless configured. POSIX. */\n  readonly distDir: string;\n  /**\n   * `next.config` `compress`. The runtime gzips streamed responses itself\n   * (neither API Gateway in STREAM mode nor CloudFront can), so honoring this\n   * is on us.\n   */\n  readonly compress: boolean;\n  /**\n   * `next.config` `generateEtags`. Honored for the files the runtime serves\n   * itself, as `next start` does (`serveStatic`'s `etag` option).\n   */\n  readonly generateEtags: boolean;\n  /**\n   * `ResolveRoutesParams[\"i18n\"]`-shaped, narrower than NextConfigComplete.\n   * `null` when the app configures no `i18n`.\n   */\n  readonly i18n: unknown | null;\n  /**\n   * `next.config` `deploymentId` (or `NEXT_DEPLOYMENT_ID`), reduced to the\n   * characters safe in an S3 key prefix and a DynamoDB partition key — `/` in\n   * particular would split the prefix `prune-cache-bucket.ts` matches on. `\"\"`\n   * when the app sets none.\n   */\n  readonly deploymentId: string;\n  /**\n   * `next.config` `images`, resolved and defaulted (`ctx.config.images`).\n   * `NextConfigComplete[\"images\"]`-shaped. With {@link experimental},\n   * {@link cacheHandler} and {@link cacheMaxMemorySize}, what the image\n   * optimizer is handed as its `nextConfig`.\n   *\n   * `images` and `experimental` are copied whole rather than field by field:\n   * Next's optimizer picks what it reads out of both (six `experimental.imgOpt*`\n   * flags in 16.4), and a hand-kept list would silently drop the next one it\n   * starts reading.\n   */\n  readonly images: unknown;\n  /**\n   * `next.config` `experimental`, resolved (`ctx.config.experimental`), as\n   * JSON: function-valued entries are dropped, as they are from\n   * `required-server-files.json`. See {@link images}.\n   */\n  readonly experimental: unknown;\n  /**\n   * `next.config` `cacheHandler`, relative to the dist dir as\n   * `required-server-files.json` has it (the build machine's absolute path\n   * means nothing in the deployment). `null` when there is none.\n   */\n  readonly cacheHandler: string | null;\n  /** `next.config` `cacheMaxMemorySize`. */\n  readonly cacheMaxMemorySize: number;\n}\n\nexport type AdapterEntrypointType =\n  \"app-page\" | \"app-route\" | \"page\" | \"page-api\";\n\nexport interface AdapterEntrypoint {\n  readonly id: string;\n  /** Repo-root-relative POSIX key inside the staging tree. Never absolute. */\n  readonly filePath: string;\n  readonly type: AdapterEntrypointType;\n}\n\nexport interface AdapterMiddleware {\n  readonly id: string;\n  /** Repo-root-relative POSIX key inside the staging tree. Never absolute. */\n  readonly filePath: string;\n}\n"]}