cdk-nextjs 0.6.2 → 0.7.0

package/lib/runtime/load-module.d.ts

@@ -0,0 +1,8 @@
+/**
+ * `createRequire` anchored to the module being loaded, rather than a bare
+ * `require`: this file is bundled to ESM by esbuild, where the ambient `require`
+ * resolves relative to `lib/runtime/`, not the staged app tree.
+ */
+export declare function loadBuiltModule(absolutePath: string): Promise<unknown>;
+/** Pulls a named function export off a loaded module, or throws saying why not. */
+export declare function requireFunctionExport<T>(exports: unknown, name: string, describe: () => string): T;

package/lib/runtime/load-module.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadBuiltModule = loadBuiltModule;
+exports.requireFunctionExport = requireFunctionExport;
+/**
+ * Loading built Next.js modules out of the staged deployment tree.
+ *
+ * Shared by the middleware runner and the entrypoint registry, because the one
+ * non-obvious part is the same for both: Turbopack emits **async modules** whose
+ * `module.exports` is a `Promise`. Its keys live behind
+ * `Symbol(turbopack exports)`, so `Object.keys` reports nothing and a
+ * synchronous `require(...).handler` is `undefined` — which looks exactly like
+ * Next.js having changed its template API. `await` covers both that and the
+ * plain-CJS/webpack shape.
+ */
+const node_module_1 = require("node:module");
+/**
+ * `createRequire` anchored to the module being loaded, rather than a bare
+ * `require`: this file is bundled to ESM by esbuild, where the ambient `require`
+ * resolves relative to `lib/runtime/`, not the staged app tree.
+ */
+async function loadBuiltModule(absolutePath) {
+    return (0, node_module_1.createRequire)(absolutePath)(absolutePath);
+}
+/** Pulls a named function export off a loaded module, or throws saying why not. */
+function requireFunctionExport(exports, name, describe) {
+    const value = exports?.[name];
+    if (typeof value !== "function") {
+        throw new Error(`${describe()} does not export a \`${name}\` function (got ` +
+            `${typeof value}). This means Next.js changed the shape of its build ` +
+            `templates (next/dist/build/templates/).`);
+    }
+    return value;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/runtime/manifest.d.ts

@@ -0,0 +1,215 @@
+/** 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.
+ */
+export declare const ADAPTER_DIR_NAME = "cdk-nextjs-adapter";
+/**
+ * Deployment root inside {@link ADAPTER_DIR_NAME}: the staged union of every
+ * shipped output's traced `assets`, keyed by repo-root-relative path. This is
+ * what replaces `output: "standalone"`.
+ */
+export declare const STAGING_DIR_NAME = "app";
+/**
+ * Parent of the per-group deployment roots, used instead of
+ * {@link STAGING_DIR_NAME} when `functionGroups` splits the app: each group is
+ * staged at `<distDir>/cdk-nextjs-adapter/groups/<name>/`, including the implicit
+ * `default` one.
+ *
+ * Splitting gets its own subtree rather than reusing `app/` for the default group
+ * so that a tree left over from a build with different grouping can never be
+ * mistaken for this build's, and so `du` on either directory answers "how big is
+ * the thing I deploy" without qualification.
+ */
+export declare const GROUPS_DIR_NAME = "groups";
+/**
+ * Which group the running function *is*. Set per Lambda at synth, read by the
+ * runtime only to make a misroute say so; see `ownedRouteError`.
+ */
+export declare const FUNCTION_GROUP_ENV_VAR = "CDK_NEXTJS_FUNCTION_GROUP";
+/**
+ * The global the cache handler (`src/adapter/s3-cache-handler.ts`) registers its
+ * CloudFront invalidation hook under, and the runtime (`core.ts`) calls. A global
+ * rather than an import, because the cache handler is a separate bundle that
+ * Next.js loads itself: the two share a process, not a module graph.
+ */
+export declare const REVALIDATED_PAGE_HOOK: unique symbol;
+/**
+ * Directory inside {@link ADAPTER_DIR_NAME} holding one deployment root, relative
+ * and POSIX. `undefined` means "not splitting", which is its own layout rather
+ * than a group named `default`.
+ */
+export declare function groupStagingDirName(group?: string): string;
+/** {@link AdapterManifest}, written inside {@link ADAPTER_DIR_NAME}. */
+export declare const MANIFEST_FILE_NAME = "manifest.json";
+/**
+ * The entrypoints the runtime renders a 404 or a 500 with, in the order it
+ * tries them, and `/_error`, the last resort for both. Before basePath.
+ */
+export declare const STATUS_PAGE_SUFFIXES: {
+    404: string[];
+    500: string[];
+    fallback: string;
+};
+/**
+ * Every {@link STATUS_PAGE_SUFFIXES} page: App Router's `/_not-found`, Pages
+ * Router's `/404` and `/500`, and `/_error`. The runtime may render any request
+ * with them, wherever it landed, so every function group stages them
+ * (`collectGroupStagingPlan`) and no URL has to be routed to them.
+ */
+export declare const ERROR_PAGE_SUFFIXES: string[];
+/**
+ * Reserved key inside the staging tree that cdk-nextjs's own bundled runtime
+ * files are copied to at synth (Lambda handler
+ * `cdk-nextjs-runtime/lambda.handler`). Reserved because a repo-root-relative
+ * asset key could otherwise collide with it.
+ */
+export declare const RUNTIME_DIR_NAME = "cdk-nextjs-runtime";
+/**
+ * The file, next to the manifest in {@link RUNTIME_DIR_NAME}, that lists
+ * `public/` on every type but `NextjsRegionalContainers`: a JSON array of
+ * `/`-separated paths relative to `public/`, as `readPublicFiles` returns them.
+ * Synth writes it after the build command (so `postbuild` output is listed)
+ * because those deployment packages do not carry `public/` itself; the runtime
+ * serves a listed file from S3. The RegionalContainers image copies `public/`
+ * in and has no such file.
+ */
+export declare const PUBLIC_FILES_FILE_NAME = "public-files.json";
+/**
+ * Where the runtime reads {@link AdapterManifest} from, given the deployment
+ * root. Synth copies `manifest.json` in next to the bundled shells rather than
+ * leaving it at its build-time location (`<distDir>/cdk-nextjs-adapter/`, one
+ * level *above* the staging tree) so that a single asset is self-describing.
+ */
+export declare function deployedManifestPath(deploymentRoot: string): string;
+export interface AdapterManifest {
+    readonly version: 1;
+    readonly buildId: string;
+    /**
+     * From the deployment root to the Next.js project dir. "" when the app is at
+     * the repo root.
+     *
+     * **The runtime `chdir`s here at cold start, and that is load-bearing.** Next
+     * inlines `__NEXT_RELATIVE_PROJECT_DIR = relative(buildCwd, projectDir)` into
+     * every entrypoint at build time (`next/dist/build/define-env.js`), and the
+     * built code resolves it as `join(process.cwd(), relativeProjectDir)` to find
+     * `required-server-files.json`, the prerender manifest, and the app's own
+     * files. `requestMeta.relativeProjectDir` overrides it in
+     * `next/dist/server/route-modules/route-module.js` but **not** in
+     * `app-page-runtime.js`, which passes the inlined value through as the render
+     * `dir` — so `process.cwd()` is the only mechanism that covers every
+     * entrypoint type. `build-outputs.ts` asserts `buildCwd === projectDir` to
+     * keep the inlined value `""` and this field the whole answer.
+     */
+    readonly relativeProjectDir: string;
+    readonly config: AdapterManifestConfig;
+    /** `ctx.routing` verbatim, including `middlewareMatchers`. */
+    readonly routing: unknown;
+    /**
+     * Every pathname `resolveRoutes` is allowed to match: the {@link entrypoints}
+     * keys plus {@link staticFiles}. Sorted and deduped.
+     */
+    readonly pathnames: string[];
+    /**
+     * Route *template* (`/blog/[slug]`) → entrypoint. Keys are basePath- and
+     * locale-prefixed exactly as `resolveRoutes` reports `resolvedPathname`, so
+     * the lookup is a plain index with no normalization.
+     *
+     * Includes dynamic *prerender* templates (notably Pages Router
+     * `/_next/data/<buildId>/<locale>/blog/[slug].json`) mapped to the entrypoint
+     * of the route that owns them.
+     */
+    readonly entrypoints: Record<string, AdapterEntrypoint>;
+    readonly middleware: AdapterMiddleware | null;
+    /**
+     * Pathname → repo-root-relative POSIX key of the file to serve.
+     *
+     * A map rather than a list of pathnames because the two are not derivable from
+     * each other: `/favicon.ico` is `<distDir>/server/app/favicon.ico.body`, `/404`
+     * is `<distDir>/server/pages/404.html`, and a fully-static Pages Router route
+     * is `<distDir>/server/pages/<route>.html`. The runtime serves these itself —
+     * `NextjsStaticAssets` only uploads `<distDir>/static` and `public`, so nothing
+     * in front of the compute can answer them.
+     *
+     * Whether the file is present in the deployment package depends on the
+     * deployment type; see `stageServedStaticFiles` in `build-outputs.ts`.
+     */
+    readonly staticFiles: Record<string, string>;
+    /**
+     * Group name → the route templates that group's deployment package holds,
+     * including the implicit `default`. Absent when `functionGroups` is not used.
+     *
+     * Every group gets the *same* manifest, because routing is identical in all of
+     * them: middleware, redirects and rewrites are duplicated by design, and a
+     * group has to be able to resolve a pathname it does not own in order to say so
+     * rather than crash on a missing file. This field is what lets it say so.
+     */
+    readonly groups?: Record<string, string[]>;
+    /**
+     * Every behavior the edge routes a non-default group on, most specific first
+     * (`GroupBehavior` in `function-groups.ts`). Present exactly when
+     * {@link groups} is. Recorded by the assignment rather than recomputed at
+     * synth, so the behaviors deployed are the ones it checked.
+     */
+    readonly behaviors?: {
+        group: string;
+        route: string;
+        pattern: string;
+    }[];
+    /**
+     * The `functionGroups` the build was split by (name and routes, as passed in
+     * `CDK_NEXTJS_FUNCTION_GROUPS`), present exactly when {@link groups} is. Synth
+     * compares it with its own props to catch a stale or hand-run build.
+     */
+    readonly functionGroups?: {
+        name: string;
+        routes: string[];
+    }[];
+}
+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.
+     */
+    readonly distDir: string;
+    /**
+     * `next.config` `compress`. The runtime gzips streamed responses itself
+     * (neither API Gateway in STREAM mode nor CloudFront can), so honoring this
+     * is on us.
+     */
+    readonly compress: boolean;
+    /**
+     * `next.config` `generateEtags`. Honored for the files the runtime serves
+     * itself, as `next start` does (`serveStatic`'s `etag` option).
+     */
+    readonly generateEtags: boolean;
+    /**
+     * `ResolveRoutesParams["i18n"]`-shaped, narrower than NextConfigComplete.
+     * `null` when the app configures no `i18n`.
+     */
+    readonly i18n: unknown | null;
+    /**
+     * `next.config` `deploymentId` (or `NEXT_DEPLOYMENT_ID`), reduced to the
+     * characters safe in an S3 key prefix and a DynamoDB partition key — `/` in
+     * particular would split the prefix `prune-cache-bucket.ts` matches on. `""`
+     * when the app sets none.
+     */
+    readonly deploymentId: string;
+}
+export type AdapterEntrypointType = "app-page" | "app-route" | "page" | "page-api";
+export interface AdapterEntrypoint {
+    readonly id: string;
+    /** Repo-root-relative POSIX key inside the staging tree. Never absolute. */
+    readonly filePath: string;
+    readonly type: AdapterEntrypointType;
+}
+export interface AdapterMiddleware {
+    readonly id: string;
+    /** Repo-root-relative POSIX key inside the staging tree. Never absolute. */
+    readonly filePath: string;
+}

package/lib/runtime/manifest.js

@@ -0,0 +1,118 @@
+"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.groupStagingDirName = groupStagingDirName;
+exports.deployedManifestPath = deployedManifestPath;
+/**
+ * The build-time → run-time contract for the adapter runtime.
+ *
+ * `src/adapter/build-outputs.ts` writes an {@link AdapterManifest} during
+ * `next build`; the runtime shells in `src/runtime/` read it at cold start and
+ * the CDK constructs read it at synth. It is the only thing that crosses those
+ * three boundaries, so it is deliberately plain JSON.
+ *
+ * **Every path in this manifest is a repo-root-relative POSIX key**, never a
+ * 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.
+ *
+ * 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.
+ */
+exports.ADAPTER_DIR_NAME = "cdk-nextjs-adapter";
+/**
+ * Deployment root inside {@link ADAPTER_DIR_NAME}: the staged union of every
+ * shipped output's traced `assets`, keyed by repo-root-relative path. This is
+ * what replaces `output: "standalone"`.
+ */
+exports.STAGING_DIR_NAME = "app";
+/**
+ * Parent of the per-group deployment roots, used instead of
+ * {@link STAGING_DIR_NAME} when `functionGroups` splits the app: each group is
+ * staged at `<distDir>/cdk-nextjs-adapter/groups/<name>/`, including the implicit
+ * `default` one.
+ *
+ * Splitting gets its own subtree rather than reusing `app/` for the default group
+ * so that a tree left over from a build with different grouping can never be
+ * mistaken for this build's, and so `du` on either directory answers "how big is
+ * the thing I deploy" without qualification.
+ */
+exports.GROUPS_DIR_NAME = "groups";
+/**
+ * Which group the running function *is*. Set per Lambda at synth, read by the
+ * runtime only to make a misroute say so; see `ownedRouteError`.
+ */
+exports.FUNCTION_GROUP_ENV_VAR = "CDK_NEXTJS_FUNCTION_GROUP";
+/**
+ * The global the cache handler (`src/adapter/s3-cache-handler.ts`) registers its
+ * CloudFront invalidation hook under, and the runtime (`core.ts`) calls. A global
+ * rather than an import, because the cache handler is a separate bundle that
+ * Next.js loads itself: the two share a process, not a module graph.
+ */
+exports.REVALIDATED_PAGE_HOOK = Symbol.for("cdk-nextjs.invalidateRevalidatedPage");
+/**
+ * Directory inside {@link ADAPTER_DIR_NAME} holding one deployment root, relative
+ * and POSIX. `undefined` means "not splitting", which is its own layout rather
+ * than a group named `default`.
+ */
+function groupStagingDirName(group) {
+    return group === undefined ? exports.STAGING_DIR_NAME : `${exports.GROUPS_DIR_NAME}/${group}`;
+}
+/** {@link AdapterManifest}, written inside {@link ADAPTER_DIR_NAME}. */
+exports.MANIFEST_FILE_NAME = "manifest.json";
+/**
+ * The entrypoints the runtime renders a 404 or a 500 with, in the order it
+ * tries them, and `/_error`, the last resort for both. Before basePath.
+ */
+exports.STATUS_PAGE_SUFFIXES = {
+    404: ["/_not-found", "/404"],
+    500: ["/500"],
+    fallback: "/_error",
+};
+/**
+ * Every {@link STATUS_PAGE_SUFFIXES} page: App Router's `/_not-found`, Pages
+ * Router's `/404` and `/500`, and `/_error`. The runtime may render any request
+ * with them, wherever it landed, so every function group stages them
+ * (`collectGroupStagingPlan`) and no URL has to be routed to them.
+ */
+exports.ERROR_PAGE_SUFFIXES = [
+    ...exports.STATUS_PAGE_SUFFIXES[404],
+    ...exports.STATUS_PAGE_SUFFIXES[500],
+    exports.STATUS_PAGE_SUFFIXES.fallback,
+];
+/**
+ * Reserved key inside the staging tree that cdk-nextjs's own bundled runtime
+ * files are copied to at synth (Lambda handler
+ * `cdk-nextjs-runtime/lambda.handler`). Reserved because a repo-root-relative
+ * asset key could otherwise collide with it.
+ */
+exports.RUNTIME_DIR_NAME = "cdk-nextjs-runtime";
+/**
+ * The file, next to the manifest in {@link RUNTIME_DIR_NAME}, that lists
+ * `public/` on every type but `NextjsRegionalContainers`: a JSON array of
+ * `/`-separated paths relative to `public/`, as `readPublicFiles` returns them.
+ * Synth writes it after the build command (so `postbuild` output is listed)
+ * because those deployment packages do not carry `public/` itself; the runtime
+ * serves a listed file from S3. The RegionalContainers image copies `public/`
+ * in and has no such file.
+ */
+exports.PUBLIC_FILES_FILE_NAME = "public-files.json";
+/**
+ * Where the runtime reads {@link AdapterManifest} from, given the deployment
+ * root. Synth copies `manifest.json` in next to the bundled shells rather than
+ * leaving it at its build-time location (`<distDir>/cdk-nextjs-adapter/`, one
+ * level *above* the staging tree) so that a single asset is self-describing.
+ */
+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"]}

package/lib/runtime/middleware.d.ts

@@ -0,0 +1,43 @@
+import { MiddlewareInvoker } from "./dispatch";
+import { AdapterMiddleware } from "./manifest";
+/**
+ * The adapter-facing export of `.next/server/middleware.js`.
+ *
+ * Web-style (`Request` in, `Response` out) even for `runtime: "nodejs"` — see
+ * `next/dist/build/templates/middleware.js`. Next's own `next-server` reaches
+ * the same module through its *default* export with an internal
+ * `{ handler, request, page }` options object; that path is not ours.
+ */
+export type MiddlewareHandler = (request: Request, ctx: MiddlewarePerRequest) => Promise<Response>;
+/** Per-request context handed to {@link MiddlewareHandler}. */
+export interface MiddlewarePerRequest {
+    readonly waitUntil?: (promise: Promise<unknown>) => void;
+    readonly signal?: AbortSignal;
+}
+export interface MiddlewareRunnerOptions {
+    readonly middleware: AdapterMiddleware;
+    /**
+     * Absolute path the manifest's repo-root-relative `filePath`s resolve against
+     * — the staging tree root, which is `process.cwd()` at runtime.
+     */
+    readonly root: string;
+    /** Test seam, and step 4's hook for a preloaded handler. */
+    readonly loadHandler?: () => Promise<MiddlewareHandler>;
+}
+export declare class MiddlewareRunner {
+    private readonly options;
+    /**
+     * Memoized across requests: loading `.next/server/middleware.js` pulls in the
+     * app's whole middleware closure, which is cold-start-expensive and must not
+     * be repeated. Held as the promise so concurrent first requests share it.
+     */
+    private handler?;
+    constructor(options: MiddlewareRunnerOptions);
+    /**
+     * The `invokeMiddleware` callback for one request. Created per request because
+     * `waitUntil` / `signal` are per-request while the loaded
+     * handler is not.
+     */
+    invokerFor(perRequest?: MiddlewarePerRequest): MiddlewareInvoker;
+    private load;
+}

package/lib/runtime/middleware.js

@@ -0,0 +1,113 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MiddlewareRunner = void 0;
+/* eslint-disable import/no-extraneous-dependencies */
+/**
+ * The middleware runner: the `invokeMiddleware` callback `resolveRoutes` calls,
+ * and nothing more.
+ *
+ * Deliberately small. A middleware runner would normally own two more jobs,
+ * deciding whether middleware runs and interpreting what it returned, but
+ * neither is done here:
+ *
+ * - **Matcher evaluation** (does this path run middleware?). `resolveRoutes`
+ *   already checks `routes.middlewareMatchers` before calling us, and Next
+ *   builds those matchers with the `x-prerender-revalidate` `missing` rule
+ *   injected, so ISR revalidation requests skip user middleware too.
+ *   Re-checking here would duplicate that and risk disagreeing with it.
+ * - **The `x-middleware-*` header protocol** (what did middleware ask for?).
+ *   `@next/routing` exports `responseToMiddlewareResult`, which translates
+ *   `x-middleware-override-headers` / `x-middleware-request-*` /
+ *   `x-middleware-rewrite` / `location` / `x-middleware-refresh` into a
+ *   `MiddlewareResult`. The previous implementation parsed these headers by
+ *   hand and drifted from `next start`.
+ */
+const node_path_1 = require("node:path");
+const routing_1 = require("@next/routing");
+const load_module_1 = require("./load-module");
+/**
+ * Methods that cannot carry a body. `new Request(url, { body })` throws for
+ * these, so the stream is simply not attached.
+ */
+const BODYLESS_METHODS = new Set(["GET", "HEAD"]);
+class MiddlewareRunner {
+    options;
+    /**
+     * Memoized across requests: loading `.next/server/middleware.js` pulls in the
+     * app's whole middleware closure, which is cold-start-expensive and must not
+     * be repeated. Held as the promise so concurrent first requests share it.
+     */
+    handler;
+    constructor(options) {
+        this.options = options;
+    }
+    /**
+     * The `invokeMiddleware` callback for one request. Created per request because
+     * `waitUntil` / `signal` are per-request while the loaded
+     * handler is not.
+     */
+    invokerFor(perRequest = {}) {
+        return async ({ url, headers, requestBody, method }) => {
+            const handler = await this.load();
+            const hasBody = !BODYLESS_METHODS.has(method.toUpperCase());
+            const request = new Request(url, {
+                method,
+                headers,
+                body: hasBody ? requestBody : undefined,
+                // Required by undici whenever the body is a stream, and absent from
+                // TypeScript's `RequestInit`.
+                ...(hasBody ? { duplex: "half" } : {}),
+            });
+            let response;
+            try {
+                response = await handler(request, perRequest);
+            }
+            catch (error) {
+                // Middleware runs on every request, so an unattributed stack here is
+                // expensive to debug. Rethrown, not swallowed: the caller turns it into
+                // a 500, the same as `next start`.
+                throw new Error(`Middleware (${this.options.middleware.filePath}) threw while ` +
+                    `handling ${method} ${url.pathname}`, { cause: error });
+            }
+            // Mutates `headers` in place as well as returning the result, which is
+            // why dispatch hands it a copy it owns.
+            return {
+                ...(0, routing_1.responseToMiddlewareResult)(response, headers, url),
+                response,
+            };
+        };
+    }
+    load() {
+        if (!this.handler) {
+            const handler = this.options.loadHandler
+                ? this.options.loadHandler()
+                : loadMiddlewareHandler(this.options.root, this.options.middleware);
+            this.handler = handler;
+            // Forgotten on failure: middleware runs on every request, so a cached
+            // rejection is the whole app answering 500 for the life of the sandbox over
+            // a load failure that may have nothing to do with the module (EMFILE under
+            // a cold-start burst, an allocation near the memory limit).
+            handler.catch(() => {
+                if (this.handler === handler) {
+                    this.handler = undefined;
+                }
+            });
+        }
+        return this.handler;
+    }
+}
+exports.MiddlewareRunner = MiddlewareRunner;
+/** `require` the built middleware module and pull `handler` off it. */
+async function loadMiddlewareHandler(root, middleware) {
+    const absolute = (0, node_path_1.join)(root, middleware.filePath);
+    let exports;
+    try {
+        exports = await (0, load_module_1.loadBuiltModule)(absolute);
+    }
+    catch (error) {
+        throw new Error(`Could not load middleware from "${absolute}" (manifest filePath ` +
+            `"${middleware.filePath}"). The deployment package is incomplete.`, { cause: error });
+    }
+    return (0, load_module_1.requireFunctionExport)(exports, "handler", () => `Middleware at "${absolute}"`);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"middleware.js","sourceRoot":"","sources":["../../src/runtime/middleware.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable import/no-extraneous-dependencies */\n/**\n * The middleware runner: the `invokeMiddleware` callback `resolveRoutes` calls,\n * and nothing more.\n *\n * Deliberately small. A middleware runner would normally own two more jobs,\n * deciding whether middleware runs and interpreting what it returned, but\n * neither is done here:\n *\n * - **Matcher evaluation** (does this path run middleware?). `resolveRoutes`\n *   already checks `routes.middlewareMatchers` before calling us, and Next\n *   builds those matchers with the `x-prerender-revalidate` `missing` rule\n *   injected, so ISR revalidation requests skip user middleware too.\n *   Re-checking here would duplicate that and risk disagreeing with it.\n * - **The `x-middleware-*` header protocol** (what did middleware ask for?).\n *   `@next/routing` exports `responseToMiddlewareResult`, which translates\n *   `x-middleware-override-headers` / `x-middleware-request-*` /\n *   `x-middleware-rewrite` / `location` / `x-middleware-refresh` into a\n *   `MiddlewareResult`. The previous implementation parsed these headers by\n *   hand and drifted from `next start`.\n */\nimport { join } from \"node:path\";\nimport { responseToMiddlewareResult } from \"@next/routing\";\nimport { MiddlewareInvoker } from \"./dispatch\";\nimport { loadBuiltModule, requireFunctionExport } from \"./load-module\";\nimport { AdapterMiddleware } from \"./manifest\";\n\n/**\n * The adapter-facing export of `.next/server/middleware.js`.\n *\n * Web-style (`Request` in, `Response` out) even for `runtime: \"nodejs\"` — see\n * `next/dist/build/templates/middleware.js`. Next's own `next-server` reaches\n * the same module through its *default* export with an internal\n * `{ handler, request, page }` options object; that path is not ours.\n */\nexport type MiddlewareHandler = (\n  request: Request,\n  ctx: MiddlewarePerRequest,\n) => Promise<Response>;\n\n/** Per-request context handed to {@link MiddlewareHandler}. */\nexport interface MiddlewarePerRequest {\n  readonly waitUntil?: (promise: Promise<unknown>) => void;\n  readonly signal?: AbortSignal;\n}\n\nexport interface MiddlewareRunnerOptions {\n  readonly middleware: AdapterMiddleware;\n  /**\n   * Absolute path the manifest's repo-root-relative `filePath`s resolve against\n   * — the staging tree root, which is `process.cwd()` at runtime.\n   */\n  readonly root: string;\n  /** Test seam, and step 4's hook for a preloaded handler. */\n  readonly loadHandler?: () => Promise<MiddlewareHandler>;\n}\n\n/**\n * Methods that cannot carry a body. `new Request(url, { body })` throws for\n * these, so the stream is simply not attached.\n */\nconst BODYLESS_METHODS = new Set([\"GET\", \"HEAD\"]);\n\nexport class MiddlewareRunner {\n  /**\n   * Memoized across requests: loading `.next/server/middleware.js` pulls in the\n   * app's whole middleware closure, which is cold-start-expensive and must not\n   * be repeated. Held as the promise so concurrent first requests share it.\n   */\n  private handler?: Promise<MiddlewareHandler>;\n\n  public constructor(private readonly options: MiddlewareRunnerOptions) {}\n\n  /**\n   * The `invokeMiddleware` callback for one request. Created per request because\n   * `waitUntil` / `signal` are per-request while the loaded\n   * handler is not.\n   */\n  public invokerFor(perRequest: MiddlewarePerRequest = {}): MiddlewareInvoker {\n    return async ({ url, headers, requestBody, method }) => {\n      const handler = await this.load();\n      const hasBody = !BODYLESS_METHODS.has(method.toUpperCase());\n      const request = new Request(url, {\n        method,\n        headers,\n        body: hasBody ? requestBody : undefined,\n        // Required by undici whenever the body is a stream, and absent from\n        // TypeScript's `RequestInit`.\n        ...(hasBody ? { duplex: \"half\" } : {}),\n      } as RequestInit);\n\n      let response: Response;\n      try {\n        response = await handler(request, perRequest);\n      } catch (error) {\n        // Middleware runs on every request, so an unattributed stack here is\n        // expensive to debug. Rethrown, not swallowed: the caller turns it into\n        // a 500, the same as `next start`.\n        throw new Error(\n          `Middleware (${this.options.middleware.filePath}) threw while ` +\n            `handling ${method} ${url.pathname}`,\n          { cause: error },\n        );\n      }\n\n      // Mutates `headers` in place as well as returning the result, which is\n      // why dispatch hands it a copy it owns.\n      return {\n        ...responseToMiddlewareResult(response, headers, url),\n        response,\n      };\n    };\n  }\n\n  private load(): Promise<MiddlewareHandler> {\n    if (!this.handler) {\n      const handler = this.options.loadHandler\n        ? this.options.loadHandler()\n        : loadMiddlewareHandler(this.options.root, this.options.middleware);\n      this.handler = handler;\n      // Forgotten on failure: middleware runs on every request, so a cached\n      // rejection is the whole app answering 500 for the life of the sandbox over\n      // a load failure that may have nothing to do with the module (EMFILE under\n      // a cold-start burst, an allocation near the memory limit).\n      handler.catch(() => {\n        if (this.handler === handler) {\n          this.handler = undefined;\n        }\n      });\n    }\n    return this.handler;\n  }\n}\n\n/** `require` the built middleware module and pull `handler` off it. */\nasync function loadMiddlewareHandler(\n  root: string,\n  middleware: AdapterMiddleware,\n): Promise<MiddlewareHandler> {\n  const absolute = join(root, middleware.filePath);\n  let exports: unknown;\n  try {\n    exports = await loadBuiltModule(absolute);\n  } catch (error) {\n    throw new Error(\n      `Could not load middleware from \"${absolute}\" (manifest filePath ` +\n        `\"${middleware.filePath}\"). The deployment package is incomplete.`,\n      { cause: error },\n    );\n  }\n  return requireFunctionExport<MiddlewareHandler>(\n    exports,\n    \"handler\",\n    () => `Middleware at \"${absolute}\"`,\n  );\n}\n"]}

package/lib/runtime/middleware.test.d.ts

@@ -0,0 +1 @@
+export {};