cdk-nextjs 0.6.2 → 0.7.0

package/lib/runtime/middleware.test.js

@@ -0,0 +1,259 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const promises_1 = require("node:fs/promises");
+const node_os_1 = require("node:os");
+const node_path_1 = require("node:path");
+const dispatch_1 = require("./dispatch");
+const middleware_1 = require("./middleware");
+const app_playground_json_1 = __importDefault(require("../adapter/__fixtures__/app-playground.json"));
+const build_outputs_1 = require("../adapter/build-outputs");
+const fixtureContext = structuredClone(app_playground_json_1.default);
+// The fixture's project dir is a synthetic `/repo/…` path, so the build cwd has
+// to be stated; see `assertBuildCwd`.
+const manifest = (0, build_outputs_1.buildAdapterManifest)(fixtureContext, {
+    buildCwd: fixtureContext.projectDir,
+}).manifest;
+const ORIGIN = "https://example.test";
+const dispatcher = new dispatch_1.Dispatcher({ manifest });
+function request(url, init = {}) {
+    return {
+        method: init.method ?? "GET",
+        url: new URL(url, ORIGIN),
+        headers: new Headers({ host: "example.test", ...init.headers }),
+        body: new ReadableStream({
+            start(controller) {
+                if (init.body !== undefined) {
+                    controller.enqueue(new TextEncoder().encode(init.body));
+                }
+                controller.close();
+            },
+        }),
+    };
+}
+function runnerFor(handler) {
+    return new middleware_1.MiddlewareRunner({
+        middleware: manifest.middleware,
+        root: "/unused-because-loadHandler-is-set",
+        loadHandler: async () => handler,
+    });
+}
+/** Dispatch a request through a `Dispatcher` backed by `handler`. */
+function dispatchThrough(handler, dispatchRequest, perRequest) {
+    return dispatcher.dispatch({
+        ...dispatchRequest,
+        invokeMiddleware: runnerFor(handler).invokerFor(perRequest),
+    });
+}
+describe("MiddlewareRunner request construction", () => {
+    it("gives middleware the real method, url and headers", async () => {
+        const seen = [];
+        await dispatchThrough(async (incoming) => {
+            seen.push(incoming);
+            return next();
+        }, request("/isr/1?q=1", { headers: { "x-caller": "yes" } }));
+        expect(seen).toHaveLength(1);
+        expect(seen[0].method).toBe("GET");
+        expect(seen[0].url).toBe(`${ORIGIN}/isr/1?q=1`);
+        expect(seen[0].headers.get("x-caller")).toBe("yes");
+    });
+    it("attaches the body for methods that can have one", async () => {
+        const bodies = [];
+        await dispatchThrough(async (incoming) => {
+            bodies.push(await incoming.text());
+            return next();
+        }, request("/api/health", { method: "POST", body: "payload" }));
+        expect(bodies).toEqual(["payload"]);
+    });
+    it("omits the body for GET and HEAD", async () => {
+        // `new Request(url, { body })` throws for these, so the runner must not
+        // attach the stream at all.
+        for (const method of ["GET", "HEAD", "get"]) {
+            const seen = [];
+            await dispatchThrough(async (incoming) => {
+                seen.push(incoming);
+                return next();
+            }, request("/isr/1", { method }));
+            expect(seen[0].body).toBeNull();
+        }
+    });
+    it("passes waitUntil straight through", async () => {
+        const waited = [];
+        await dispatchThrough(async (_incoming, ctx) => {
+            ctx.waitUntil?.(Promise.resolve("logged"));
+            return next();
+        }, request("/isr/1"), { waitUntil: (promise) => waited.push(promise) });
+        expect(waited).toHaveLength(1);
+    });
+    it("loads the handler at most once across requests", async () => {
+        let loads = 0;
+        const runner = new middleware_1.MiddlewareRunner({
+            middleware: manifest.middleware,
+            root: "/unused",
+            loadHandler: async () => {
+                loads += 1;
+                return async () => next();
+            },
+        });
+        const invokeMiddleware = runner.invokerFor();
+        await dispatcher.dispatch({ ...request("/isr/1"), invokeMiddleware });
+        await dispatcher.dispatch({ ...request("/isr/2"), invokeMiddleware });
+        // A fresh invoker for a later request must reuse the loaded handler.
+        await dispatcher.dispatch({
+            ...request("/isr/3"),
+            invokeMiddleware: runner.invokerFor(),
+        });
+        expect(loads).toBe(1);
+    });
+    it("retries a load that failed instead of caching the rejection", async () => {
+        // 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).
+        let loads = 0;
+        const runner = new middleware_1.MiddlewareRunner({
+            middleware: manifest.middleware,
+            root: "/unused",
+            loadHandler: async () => {
+                loads += 1;
+                if (loads === 1) {
+                    throw new Error("EMFILE");
+                }
+                return async () => next();
+            },
+        });
+        const dispatch = () => dispatcher.dispatch({
+            ...request("/isr/1"),
+            invokeMiddleware: runner.invokerFor(),
+        });
+        await expect(dispatch()).rejects.toThrow(/EMFILE/);
+        await expect(dispatch()).resolves.toBeDefined();
+        expect(loads).toBe(2);
+    });
+    it("attributes a middleware throw to middleware", async () => {
+        await expect(dispatchThrough(async () => {
+            throw new Error("boom");
+        }, request("/isr/1"))).rejects.toThrow(/Middleware \(.*middleware\.js\) threw while handling GET/);
+    });
+});
+describe("MiddlewareRunner response translation", () => {
+    it("treats NextResponse.next() as a pass-through", async () => {
+        const result = await dispatchThrough(async () => next(), request("/isr/1"));
+        expect(result.kind).toBe("entrypoint");
+    });
+    it("forwards request headers set via the x-middleware-* protocol", async () => {
+        // This is the real wire format behind `NextResponse.next({ request: { headers } })`,
+        // and the reason dispatch captures `MiddlewareResult.requestHeaders`:
+        // `resolveRoutes` itself drops them.
+        const result = await dispatchThrough(async () => new Response(null, {
+            status: 200,
+            headers: {
+                "x-middleware-next": "1",
+                "x-middleware-override-headers": "host,x-user",
+                "x-middleware-request-host": "example.test",
+                "x-middleware-request-x-user": "42",
+            },
+        }), request("/isr/1"));
+        expect(result.kind).toBe("entrypoint");
+        if (result.kind !== "entrypoint")
+            return;
+        expect(result.requestHeaders.get("x-user")).toBe("42");
+    });
+    it("returns response headers middleware set", async () => {
+        const result = await dispatchThrough(async () => new Response(null, {
+            status: 200,
+            headers: { "x-middleware-next": "1", "x-flag": "on" },
+        }), request("/isr/1"));
+        expect(result.responseHeaders.get("x-flag")).toBe("on");
+    });
+    it("turns an internal x-middleware-rewrite into the rewritten entrypoint", async () => {
+        const result = await dispatchThrough(async () => new Response(null, {
+            status: 200,
+            headers: { "x-middleware-rewrite": `${ORIGIN}/api/health` },
+        }), request("/isr/1"));
+        expect(result.kind).toBe("entrypoint");
+        if (result.kind !== "entrypoint")
+            return;
+        expect(result.resolvedPathname).toBe("/api/health");
+    });
+    it("turns an external x-middleware-rewrite into a proxy target", async () => {
+        const result = await dispatchThrough(async () => new Response(null, {
+            status: 200,
+            headers: { "x-middleware-rewrite": "https://upstream.test/x" },
+        }), request("/isr/1"));
+        expect(result.kind).toBe("external-rewrite");
+    });
+    it("turns a location header into a redirect", async () => {
+        const result = await dispatchThrough(async () => new Response(null, {
+            status: 307,
+            headers: { location: `${ORIGIN}/login` },
+        }), request("/isr/1"));
+        // A same-origin `location` comes back relative: `resolveRoutes` emits the
+        // path, not the absolute URL middleware wrote. Matches `next start`.
+        expect(result).toMatchObject({
+            kind: "redirect",
+            status: 307,
+            location: "/login",
+        });
+    });
+    it("treats a middleware-authored response as the response", async () => {
+        // No `x-middleware-next` and no rewrite: middleware answered the request.
+        const result = await dispatchThrough(async () => new Response("denied", { status: 401 }), request("/isr/1"));
+        expect(result.kind).toBe("middleware-responded");
+        if (result.kind !== "middleware-responded")
+            return;
+        expect(result.response.status).toBe(401);
+        expect(await result.response.text()).toBe("denied");
+    });
+});
+describe("MiddlewareRunner module loading", () => {
+    /** Writes a CJS middleware module and returns the root to resolve it from. */
+    async function writeModule(source) {
+        const root = await (0, promises_1.mkdtemp)((0, node_path_1.join)((0, node_os_1.tmpdir)(), "cdk-nextjs-middleware-"));
+        await (0, promises_1.writeFile)((0, node_path_1.join)(root, "middleware.js"), source);
+        return root;
+    }
+    const invoke = (root) => new middleware_1.MiddlewareRunner({
+        middleware: { id: "/_middleware", filePath: "middleware.js" },
+        root,
+    }).invokerFor()({
+        method: "GET",
+        url: new URL(`${ORIGIN}/isr/1`),
+        headers: new Headers({ host: "example.test" }),
+        requestBody: new ReadableStream({
+            start(controller) {
+                controller.close();
+            },
+        }),
+    });
+    it("loads a module that exports handler directly", async () => {
+        const root = await writeModule(`exports.handler = async () => new Response(null, { headers: { "x-middleware-next": "1", "x-flag": "sync" } });`);
+        const result = await invoke(root);
+        expect(result.responseHeaders?.get("x-flag")).toBe("sync");
+    });
+    it("awaits a module whose exports are a promise", async () => {
+        // Turbopack's async-module shape: `module.exports` is a Promise. A real
+        // `.next/server/middleware.js` built by Turbopack looks exactly like this.
+        const root = await writeModule(`module.exports = Promise.resolve({ handler: async () => new Response(null, { headers: { "x-middleware-next": "1", "x-flag": "async" } }) });`);
+        const result = await invoke(root);
+        expect(result.responseHeaders?.get("x-flag")).toBe("async");
+    });
+    it("reports a missing module as an incomplete package", async () => {
+        const root = await (0, promises_1.mkdtemp)((0, node_path_1.join)((0, node_os_1.tmpdir)(), "cdk-nextjs-middleware-"));
+        await expect(invoke(root)).rejects.toThrow(/Could not load middleware from .*middleware\.js.*deployment package is incomplete/s);
+    });
+    it("reports a module without a handler export", async () => {
+        const root = await writeModule(`module.exports = { nope: 1 };`);
+        await expect(invoke(root)).rejects.toThrow(/does not export a `handler` function \(got undefined\)/);
+    });
+});
+/** The wire form of `NextResponse.next()`. */
+function next() {
+    return new Response(null, {
+        status: 200,
+        headers: { "x-middleware-next": "1" },
+    });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"middleware.test.js","sourceRoot":"","sources":["../../src/runtime/middleware.test.ts"],"names":[],"mappings":"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","sourcesContent":["import { mkdtemp, writeFile } from \"node:fs/promises\";\nimport { tmpdir } from \"node:os\";\nimport { join } from \"node:path\";\nimport { Dispatcher, DispatchRequest } from \"./dispatch\";\nimport { AdapterManifest } from \"./manifest\";\nimport {\n  MiddlewareHandler,\n  MiddlewarePerRequest,\n  MiddlewareRunner,\n} from \"./middleware\";\nimport appPlayground from \"../adapter/__fixtures__/app-playground.json\";\nimport {\n  BuildCompleteContext,\n  buildAdapterManifest,\n} from \"../adapter/build-outputs\";\n\nconst fixtureContext = structuredClone(\n  appPlayground,\n) as unknown as BuildCompleteContext;\n// The fixture's project dir is a synthetic `/repo/…` path, so the build cwd has\n// to be stated; see `assertBuildCwd`.\nconst manifest: AdapterManifest = buildAdapterManifest(fixtureContext, {\n  buildCwd: fixtureContext.projectDir,\n}).manifest;\n\nconst ORIGIN = \"https://example.test\";\n\nconst dispatcher = new Dispatcher({ manifest });\n\nfunction request(\n  url: string,\n  init: {\n    method?: string;\n    headers?: Record<string, string>;\n    body?: string;\n  } = {},\n): DispatchRequest {\n  return {\n    method: init.method ?? \"GET\",\n    url: new URL(url, ORIGIN),\n    headers: new Headers({ host: \"example.test\", ...init.headers }),\n    body: new ReadableStream({\n      start(controller) {\n        if (init.body !== undefined) {\n          controller.enqueue(new TextEncoder().encode(init.body));\n        }\n        controller.close();\n      },\n    }),\n  };\n}\n\nfunction runnerFor(handler: MiddlewareHandler) {\n  return new MiddlewareRunner({\n    middleware: manifest.middleware!,\n    root: \"/unused-because-loadHandler-is-set\",\n    loadHandler: async () => handler,\n  });\n}\n\n/** Dispatch a request through a `Dispatcher` backed by `handler`. */\nfunction dispatchThrough(\n  handler: MiddlewareHandler,\n  dispatchRequest: DispatchRequest,\n  perRequest?: MiddlewarePerRequest,\n) {\n  return dispatcher.dispatch({\n    ...dispatchRequest,\n    invokeMiddleware: runnerFor(handler).invokerFor(perRequest),\n  });\n}\n\ndescribe(\"MiddlewareRunner request construction\", () => {\n  it(\"gives middleware the real method, url and headers\", async () => {\n    const seen: Request[] = [];\n    await dispatchThrough(\n      async (incoming) => {\n        seen.push(incoming);\n        return next();\n      },\n      request(\"/isr/1?q=1\", { headers: { \"x-caller\": \"yes\" } }),\n    );\n    expect(seen).toHaveLength(1);\n    expect(seen[0].method).toBe(\"GET\");\n    expect(seen[0].url).toBe(`${ORIGIN}/isr/1?q=1`);\n    expect(seen[0].headers.get(\"x-caller\")).toBe(\"yes\");\n  });\n\n  it(\"attaches the body for methods that can have one\", async () => {\n    const bodies: (string | null)[] = [];\n    await dispatchThrough(\n      async (incoming) => {\n        bodies.push(await incoming.text());\n        return next();\n      },\n      request(\"/api/health\", { method: \"POST\", body: \"payload\" }),\n    );\n    expect(bodies).toEqual([\"payload\"]);\n  });\n\n  it(\"omits the body for GET and HEAD\", async () => {\n    // `new Request(url, { body })` throws for these, so the runner must not\n    // attach the stream at all.\n    for (const method of [\"GET\", \"HEAD\", \"get\"]) {\n      const seen: Request[] = [];\n      await dispatchThrough(\n        async (incoming) => {\n          seen.push(incoming);\n          return next();\n        },\n        request(\"/isr/1\", { method }),\n      );\n      expect(seen[0].body).toBeNull();\n    }\n  });\n\n  it(\"passes waitUntil straight through\", async () => {\n    const waited: Promise<unknown>[] = [];\n    await dispatchThrough(\n      async (_incoming, ctx) => {\n        ctx.waitUntil?.(Promise.resolve(\"logged\"));\n        return next();\n      },\n      request(\"/isr/1\"),\n      { waitUntil: (promise) => waited.push(promise) },\n    );\n    expect(waited).toHaveLength(1);\n  });\n\n  it(\"loads the handler at most once across requests\", async () => {\n    let loads = 0;\n    const runner = new MiddlewareRunner({\n      middleware: manifest.middleware!,\n      root: \"/unused\",\n      loadHandler: async () => {\n        loads += 1;\n        return async () => next();\n      },\n    });\n    const invokeMiddleware = runner.invokerFor();\n    await dispatcher.dispatch({ ...request(\"/isr/1\"), invokeMiddleware });\n    await dispatcher.dispatch({ ...request(\"/isr/2\"), invokeMiddleware });\n    // A fresh invoker for a later request must reuse the loaded handler.\n    await dispatcher.dispatch({\n      ...request(\"/isr/3\"),\n      invokeMiddleware: runner.invokerFor(),\n    });\n    expect(loads).toBe(1);\n  });\n\n  it(\"retries a load that failed instead of caching the rejection\", async () => {\n    // Middleware runs on every request, so a cached rejection is the whole app\n    // answering 500 for the life of the sandbox — over a load failure that may\n    // have nothing to do with the module (EMFILE under a cold-start burst, an\n    // allocation near the memory limit).\n    let loads = 0;\n    const runner = new MiddlewareRunner({\n      middleware: manifest.middleware!,\n      root: \"/unused\",\n      loadHandler: async () => {\n        loads += 1;\n        if (loads === 1) {\n          throw new Error(\"EMFILE\");\n        }\n        return async () => next();\n      },\n    });\n    const dispatch = () =>\n      dispatcher.dispatch({\n        ...request(\"/isr/1\"),\n        invokeMiddleware: runner.invokerFor(),\n      });\n\n    await expect(dispatch()).rejects.toThrow(/EMFILE/);\n    await expect(dispatch()).resolves.toBeDefined();\n    expect(loads).toBe(2);\n  });\n\n  it(\"attributes a middleware throw to middleware\", async () => {\n    await expect(\n      dispatchThrough(async () => {\n        throw new Error(\"boom\");\n      }, request(\"/isr/1\")),\n    ).rejects.toThrow(\n      /Middleware \\(.*middleware\\.js\\) threw while handling GET/,\n    );\n  });\n});\n\ndescribe(\"MiddlewareRunner response translation\", () => {\n  it(\"treats NextResponse.next() as a pass-through\", async () => {\n    const result = await dispatchThrough(async () => next(), request(\"/isr/1\"));\n    expect(result.kind).toBe(\"entrypoint\");\n  });\n\n  it(\"forwards request headers set via the x-middleware-* protocol\", async () => {\n    // This is the real wire format behind `NextResponse.next({ request: { headers } })`,\n    // and the reason dispatch captures `MiddlewareResult.requestHeaders`:\n    // `resolveRoutes` itself drops them.\n    const result = await dispatchThrough(\n      async () =>\n        new Response(null, {\n          status: 200,\n          headers: {\n            \"x-middleware-next\": \"1\",\n            \"x-middleware-override-headers\": \"host,x-user\",\n            \"x-middleware-request-host\": \"example.test\",\n            \"x-middleware-request-x-user\": \"42\",\n          },\n        }),\n      request(\"/isr/1\"),\n    );\n    expect(result.kind).toBe(\"entrypoint\");\n    if (result.kind !== \"entrypoint\") return;\n    expect(result.requestHeaders.get(\"x-user\")).toBe(\"42\");\n  });\n\n  it(\"returns response headers middleware set\", async () => {\n    const result = await dispatchThrough(\n      async () =>\n        new Response(null, {\n          status: 200,\n          headers: { \"x-middleware-next\": \"1\", \"x-flag\": \"on\" },\n        }),\n      request(\"/isr/1\"),\n    );\n    expect(result.responseHeaders.get(\"x-flag\")).toBe(\"on\");\n  });\n\n  it(\"turns an internal x-middleware-rewrite into the rewritten entrypoint\", async () => {\n    const result = await dispatchThrough(\n      async () =>\n        new Response(null, {\n          status: 200,\n          headers: { \"x-middleware-rewrite\": `${ORIGIN}/api/health` },\n        }),\n      request(\"/isr/1\"),\n    );\n    expect(result.kind).toBe(\"entrypoint\");\n    if (result.kind !== \"entrypoint\") return;\n    expect(result.resolvedPathname).toBe(\"/api/health\");\n  });\n\n  it(\"turns an external x-middleware-rewrite into a proxy target\", async () => {\n    const result = await dispatchThrough(\n      async () =>\n        new Response(null, {\n          status: 200,\n          headers: { \"x-middleware-rewrite\": \"https://upstream.test/x\" },\n        }),\n      request(\"/isr/1\"),\n    );\n    expect(result.kind).toBe(\"external-rewrite\");\n  });\n\n  it(\"turns a location header into a redirect\", async () => {\n    const result = await dispatchThrough(\n      async () =>\n        new Response(null, {\n          status: 307,\n          headers: { location: `${ORIGIN}/login` },\n        }),\n      request(\"/isr/1\"),\n    );\n    // A same-origin `location` comes back relative: `resolveRoutes` emits the\n    // path, not the absolute URL middleware wrote. Matches `next start`.\n    expect(result).toMatchObject({\n      kind: \"redirect\",\n      status: 307,\n      location: \"/login\",\n    });\n  });\n\n  it(\"treats a middleware-authored response as the response\", async () => {\n    // No `x-middleware-next` and no rewrite: middleware answered the request.\n    const result = await dispatchThrough(\n      async () => new Response(\"denied\", { status: 401 }),\n      request(\"/isr/1\"),\n    );\n    expect(result.kind).toBe(\"middleware-responded\");\n    if (result.kind !== \"middleware-responded\") return;\n    expect(result.response.status).toBe(401);\n    expect(await result.response.text()).toBe(\"denied\");\n  });\n});\n\ndescribe(\"MiddlewareRunner module loading\", () => {\n  /** Writes a CJS middleware module and returns the root to resolve it from. */\n  async function writeModule(source: string) {\n    const root = await mkdtemp(join(tmpdir(), \"cdk-nextjs-middleware-\"));\n    await writeFile(join(root, \"middleware.js\"), source);\n    return root;\n  }\n\n  const invoke = (root: string) =>\n    new MiddlewareRunner({\n      middleware: { id: \"/_middleware\", filePath: \"middleware.js\" },\n      root,\n    }).invokerFor()({\n      method: \"GET\",\n      url: new URL(`${ORIGIN}/isr/1`),\n      headers: new Headers({ host: \"example.test\" }),\n      requestBody: new ReadableStream({\n        start(controller) {\n          controller.close();\n        },\n      }),\n    });\n\n  it(\"loads a module that exports handler directly\", async () => {\n    const root = await writeModule(\n      `exports.handler = async () => new Response(null, { headers: { \"x-middleware-next\": \"1\", \"x-flag\": \"sync\" } });`,\n    );\n    const result = await invoke(root);\n    expect(result.responseHeaders?.get(\"x-flag\")).toBe(\"sync\");\n  });\n\n  it(\"awaits a module whose exports are a promise\", async () => {\n    // Turbopack's async-module shape: `module.exports` is a Promise. A real\n    // `.next/server/middleware.js` built by Turbopack looks exactly like this.\n    const root = await writeModule(\n      `module.exports = Promise.resolve({ handler: async () => new Response(null, { headers: { \"x-middleware-next\": \"1\", \"x-flag\": \"async\" } }) });`,\n    );\n    const result = await invoke(root);\n    expect(result.responseHeaders?.get(\"x-flag\")).toBe(\"async\");\n  });\n\n  it(\"reports a missing module as an incomplete package\", async () => {\n    const root = await mkdtemp(join(tmpdir(), \"cdk-nextjs-middleware-\"));\n    await expect(invoke(root)).rejects.toThrow(\n      /Could not load middleware from .*middleware\\.js.*deployment package is incomplete/s,\n    );\n  });\n\n  it(\"reports a module without a handler export\", async () => {\n    const root = await writeModule(`module.exports = { nope: 1 };`);\n    await expect(invoke(root)).rejects.toThrow(\n      /does not export a `handler` function \\(got undefined\\)/,\n    );\n  });\n});\n\n/** The wire form of `NextResponse.next()`. */\nfunction next(): Response {\n  return new Response(null, {\n    status: 200,\n    headers: { \"x-middleware-next\": \"1\" },\n  });\n}\n"]}

package/lib/runtime/next-modules.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Point `next` resolution at the staged Next.js project. Called once by
+ * `loadRuntime`, before anything can serve a request.
+ *
+ * @param projectDir absolute path to the staged project dir
+ * (`join(deploymentRoot, manifest.relativeProjectDir)`).
+ */
+export declare function useNextFrom(projectDir: string): void;
+/**
+ * The bootstrap Next.js exposes for adapters — "can be used to ensure Node.js
+ * APIs are setup as expected without requiring `next-server`", in its own words.
+ * It installs the globals, the `react`/`react-dom` require hook, and the
+ * `console`/`Error`/`Date`/crypto extensions that `next start` installs before it
+ * loads any route.
+ *
+ * Its most load-bearing effect is `globalThis.AsyncLocalStorage`, which
+ * `next/dist/server/app-render/async-local-storage.js` reads *at module scope* —
+ * whatever is loaded first wins, permanently.
+ *
+ * Without this, `next/dist/compiled/next-server/app-page-turbo.runtime.prod.js`
+ * requires `work-async-storage.external.js` before its own
+ * `route-module.js` gets to the bootstrap, and the app-render storage is created
+ * as Next's `FakeAsyncLocalStorage`, which throws "Invariant: AsyncLocalStorage
+ * accessed in runtime where it is not available" on the first dynamic render.
+ *
+ * It is easy to miss, because an app with middleware is accidentally fine:
+ * `next/dist/build/templates/middleware.js` requires the same bootstrap, and the
+ * runtime runs middleware before it loads a page entrypoint. Only an app with no
+ * middleware — and only on a dynamic app-page render — reaches the invariant.
+ *
+ * `next/dist/build/adapter/setup-node-env.external.js` is side-effect-only and
+ * idempotent (`node-environment.js` guards its own re-entry), so calling this
+ * more than once is harmless.
+ */
+export declare function setupNodeEnvironment(): void;
+/**
+ * Load the staged `.env` / `.env.production` into `process.env`, the way
+ * `NextNodeServer` does when `next start` constructs it. Nothing else would:
+ * the built entrypoints never call `loadEnvConfig`, and the runtime builds no
+ * `NextNodeServer`.
+ *
+ * Same semantics as `next start` because it is the same function — variables
+ * already in `process.env` (the Lambda or task environment) win over the files.
+ * `@next/env` is a dependency of `next`, not of the app, so it is resolved from
+ * `next`'s own directory; the adapter stages it on that basis
+ * (`addRuntimeNextClosure`).
+ */
+export declare function loadEnvFiles(projectDir: string): void;
+/**
+ * `require` a `next` submodule from the staged app.
+ *
+ * Pass the module's own type — `nextModule<typeof import("next/dist/...")>(...)` —
+ * so the call is as type-checked as a static import would be.
+ */
+export declare function nextModule<T>(specifier: string): T;

package/lib/runtime/next-modules.js

@@ -0,0 +1,124 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useNextFrom = useNextFrom;
+exports.setupNodeEnvironment = setupNodeEnvironment;
+exports.loadEnvFiles = loadEnvFiles;
+exports.nextModule = nextModule;
+/**
+ * Resolving the handful of `next` internals the runtime itself needs, out of the
+ * staged app rather than from next to the shell.
+ *
+ * `next` is deliberately external to both shell bundles: the deployment already
+ * carries the traced `next` files every built entrypoint requires, and a second
+ * bundled copy would be a different module instance — pinned to *cdk-nextjs's*
+ * `next` version rather than the consumer's.
+ *
+ * Marking it external is not enough on its own. esbuild turns
+ * `import { serveStatic } from "next/dist/server/serve-static.js"` into a real,
+ * hoisted `import` inside `cdk-nextjs-runtime/lambda.mjs`, which Node resolves by
+ * walking `cdk-nextjs-runtime/node_modules` and then `<deploymentRoot>/node_modules`
+ * — and under pnpm neither holds `next`. The only `next` in the staged tree is the
+ * relative symlink at `<projectDir>/node_modules/next` that the traced entrypoints
+ * resolve through, one directory *below* the deployment root. A hoisted npm/yarn
+ * monorepo puts it somewhere else again. Since those imports are hoisted, getting
+ * this wrong is not a degraded image route: the shell fails to load at all.
+ *
+ * So every such module is required through a `createRequire` anchored inside the
+ * staged project dir, which makes the runtime resolve `next` by the same walk the
+ * entrypoints do, for any package manager and any layout. That also means they
+ * cannot be imported at module scope; each caller resolves (and memoizes) on
+ * first use, after {@link useNextFrom}.
+ */
+const node_module_1 = require("node:module");
+const node_path_1 = require("node:path");
+let nextRequire;
+/**
+ * Point `next` resolution at the staged Next.js project. Called once by
+ * `loadRuntime`, before anything can serve a request.
+ *
+ * @param projectDir absolute path to the staged project dir
+ * (`join(deploymentRoot, manifest.relativeProjectDir)`).
+ */
+function useNextFrom(projectDir) {
+    // Anchored on a path *inside* `projectDir`, because `createRequire` starts its
+    // `node_modules` walk at the anchor's directory. The file needn't exist.
+    nextRequire = (0, node_module_1.createRequire)((0, node_path_1.join)(projectDir, "cdk-nextjs-next-resolver.cjs"));
+}
+/**
+ * The bootstrap Next.js exposes for adapters — "can be used to ensure Node.js
+ * APIs are setup as expected without requiring `next-server`", in its own words.
+ * It installs the globals, the `react`/`react-dom` require hook, and the
+ * `console`/`Error`/`Date`/crypto extensions that `next start` installs before it
+ * loads any route.
+ *
+ * Its most load-bearing effect is `globalThis.AsyncLocalStorage`, which
+ * `next/dist/server/app-render/async-local-storage.js` reads *at module scope* —
+ * whatever is loaded first wins, permanently.
+ *
+ * Without this, `next/dist/compiled/next-server/app-page-turbo.runtime.prod.js`
+ * requires `work-async-storage.external.js` before its own
+ * `route-module.js` gets to the bootstrap, and the app-render storage is created
+ * as Next's `FakeAsyncLocalStorage`, which throws "Invariant: AsyncLocalStorage
+ * accessed in runtime where it is not available" on the first dynamic render.
+ *
+ * It is easy to miss, because an app with middleware is accidentally fine:
+ * `next/dist/build/templates/middleware.js` requires the same bootstrap, and the
+ * runtime runs middleware before it loads a page entrypoint. Only an app with no
+ * middleware — and only on a dynamic app-page render — reaches the invariant.
+ *
+ * `next/dist/build/adapter/setup-node-env.external.js` is side-effect-only and
+ * idempotent (`node-environment.js` guards its own re-entry), so calling this
+ * more than once is harmless.
+ */
+function setupNodeEnvironment() {
+    nextModule("next/dist/build/adapter/setup-node-env.external.js");
+}
+/**
+ * Load the staged `.env` / `.env.production` into `process.env`, the way
+ * `NextNodeServer` does when `next start` constructs it. Nothing else would:
+ * the built entrypoints never call `loadEnvConfig`, and the runtime builds no
+ * `NextNodeServer`.
+ *
+ * Same semantics as `next start` because it is the same function — variables
+ * already in `process.env` (the Lambda or task environment) win over the files.
+ * `@next/env` is a dependency of `next`, not of the app, so it is resolved from
+ * `next`'s own directory; the adapter stages it on that basis
+ * (`addRuntimeNextClosure`).
+ */
+function loadEnvFiles(projectDir) {
+    const nextEnvRequire = (0, node_module_1.createRequire)(nextModuleResolve("next/package.json"));
+    // Typed locally: `@next/env` is `next`'s dependency, not a resolvable one here.
+    const { loadEnvConfig } = nextEnvRequire("@next/env");
+    loadEnvConfig(projectDir, false);
+}
+function nextModuleResolve(specifier) {
+    return nextRequireOrThrow(specifier).resolve(specifier);
+}
+function nextRequireOrThrow(specifier) {
+    if (!nextRequire) {
+        throw new Error(`Cannot load "${specifier}": \`next\` resolution has not been pointed at ` +
+            `the staged app yet. \`useNextFrom\` runs in \`loadRuntime\`, so this ` +
+            `means runtime code loaded a \`next\` module before the runtime was ` +
+            `loaded.`);
+    }
+    return nextRequire;
+}
+/**
+ * `require` a `next` submodule from the staged app.
+ *
+ * Pass the module's own type — `nextModule<typeof import("next/dist/...")>(...)` —
+ * so the call is as type-checked as a static import would be.
+ */
+function nextModule(specifier) {
+    const load = nextRequireOrThrow(specifier);
+    try {
+        return load(specifier);
+    }
+    catch (cause) {
+        throw new Error(`Could not resolve "${specifier}" from the deployed Next.js project. The ` +
+            `deployment package is missing part of the \`next\` closure that ` +
+            `\`next build\` traced, or \`node_modules/next\` resolves to a symlink ` +
+            `target that was not staged.`, { cause });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"next-modules.js","sourceRoot":"","sources":["../../src/runtime/next-modules.ts"],"names":[],"mappings":";;AAqCA,kCAIC;AA4BD,oDAEC;AAcD,oCAOC;AA0BD,gCAaC;AAnID;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,6CAA4C;AAC5C,yCAAiC;AAEjC,IAAI,WAAyD,CAAC;AAE9D;;;;;;GAMG;AACH,SAAgB,WAAW,CAAC,UAAkB;IAC5C,+EAA+E;IAC/E,yEAAyE;IACzE,WAAW,GAAG,IAAA,2BAAa,EAAC,IAAA,gBAAI,EAAC,UAAU,EAAE,8BAA8B,CAAC,CAAC,CAAC;AAChF,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,SAAgB,oBAAoB;IAClC,UAAU,CAAC,oDAAoD,CAAC,CAAC;AACnE,CAAC;AAED;;;;;;;;;;;GAWG;AACH,SAAgB,YAAY,CAAC,UAAkB;IAC7C,MAAM,cAAc,GAAG,IAAA,2BAAa,EAAC,iBAAiB,CAAC,mBAAmB,CAAC,CAAC,CAAC;IAC7E,gFAAgF;IAChF,MAAM,EAAE,aAAa,EAAE,GAAG,cAAc,CAAC,WAAW,CAEnD,CAAC;IACF,aAAa,CAAC,UAAU,EAAE,KAAK,CAAC,CAAC;AACnC,CAAC;AAED,SAAS,iBAAiB,CAAC,SAAiB;IAC1C,OAAO,kBAAkB,CAAC,SAAS,CAAC,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC;AAC1D,CAAC;AAED,SAAS,kBAAkB,CACzB,SAAiB;IAEjB,IAAI,CAAC,WAAW,EAAE,CAAC;QACjB,MAAM,IAAI,KAAK,CACb,gBAAgB,SAAS,iDAAiD;YACxE,uEAAuE;YACvE,qEAAqE;YACrE,SAAS,CACZ,CAAC;IACJ,CAAC;IACD,OAAO,WAAW,CAAC;AACrB,CAAC;AAED;;;;;GAKG;AACH,SAAgB,UAAU,CAAI,SAAiB;IAC7C,MAAM,IAAI,GAAG,kBAAkB,CAAC,SAAS,CAAC,CAAC;IAC3C,IAAI,CAAC;QACH,OAAO,IAAI,CAAC,SAAS,CAAM,CAAC;IAC9B,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,MAAM,IAAI,KAAK,CACb,sBAAsB,SAAS,2CAA2C;YACxE,kEAAkE;YAClE,wEAAwE;YACxE,6BAA6B,EAC/B,EAAE,KAAK,EAAE,CACV,CAAC;IACJ,CAAC;AACH,CAAC","sourcesContent":["/**\n * Resolving the handful of `next` internals the runtime itself needs, out of the\n * staged app rather than from next to the shell.\n *\n * `next` is deliberately external to both shell bundles: the deployment already\n * carries the traced `next` files every built entrypoint requires, and a second\n * bundled copy would be a different module instance — pinned to *cdk-nextjs's*\n * `next` version rather than the consumer's.\n *\n * Marking it external is not enough on its own. esbuild turns\n * `import { serveStatic } from \"next/dist/server/serve-static.js\"` into a real,\n * hoisted `import` inside `cdk-nextjs-runtime/lambda.mjs`, which Node resolves by\n * walking `cdk-nextjs-runtime/node_modules` and then `<deploymentRoot>/node_modules`\n * — and under pnpm neither holds `next`. The only `next` in the staged tree is the\n * relative symlink at `<projectDir>/node_modules/next` that the traced entrypoints\n * resolve through, one directory *below* the deployment root. A hoisted npm/yarn\n * monorepo puts it somewhere else again. Since those imports are hoisted, getting\n * this wrong is not a degraded image route: the shell fails to load at all.\n *\n * So every such module is required through a `createRequire` anchored inside the\n * staged project dir, which makes the runtime resolve `next` by the same walk the\n * entrypoints do, for any package manager and any layout. That also means they\n * cannot be imported at module scope; each caller resolves (and memoizes) on\n * first use, after {@link useNextFrom}.\n */\nimport { createRequire } from \"node:module\";\nimport { join } from \"node:path\";\n\nlet nextRequire: ReturnType<typeof createRequire> | undefined;\n\n/**\n * Point `next` resolution at the staged Next.js project. Called once by\n * `loadRuntime`, before anything can serve a request.\n *\n * @param projectDir absolute path to the staged project dir\n * (`join(deploymentRoot, manifest.relativeProjectDir)`).\n */\nexport function useNextFrom(projectDir: string): void {\n  // Anchored on a path *inside* `projectDir`, because `createRequire` starts its\n  // `node_modules` walk at the anchor's directory. The file needn't exist.\n  nextRequire = createRequire(join(projectDir, \"cdk-nextjs-next-resolver.cjs\"));\n}\n\n/**\n * The bootstrap Next.js exposes for adapters — \"can be used to ensure Node.js\n * APIs are setup as expected without requiring `next-server`\", in its own words.\n * It installs the globals, the `react`/`react-dom` require hook, and the\n * `console`/`Error`/`Date`/crypto extensions that `next start` installs before it\n * loads any route.\n *\n * Its most load-bearing effect is `globalThis.AsyncLocalStorage`, which\n * `next/dist/server/app-render/async-local-storage.js` reads *at module scope* —\n * whatever is loaded first wins, permanently.\n *\n * Without this, `next/dist/compiled/next-server/app-page-turbo.runtime.prod.js`\n * requires `work-async-storage.external.js` before its own\n * `route-module.js` gets to the bootstrap, and the app-render storage is created\n * as Next's `FakeAsyncLocalStorage`, which throws \"Invariant: AsyncLocalStorage\n * accessed in runtime where it is not available\" on the first dynamic render.\n *\n * It is easy to miss, because an app with middleware is accidentally fine:\n * `next/dist/build/templates/middleware.js` requires the same bootstrap, and the\n * runtime runs middleware before it loads a page entrypoint. Only an app with no\n * middleware — and only on a dynamic app-page render — reaches the invariant.\n *\n * `next/dist/build/adapter/setup-node-env.external.js` is side-effect-only and\n * idempotent (`node-environment.js` guards its own re-entry), so calling this\n * more than once is harmless.\n */\nexport function setupNodeEnvironment(): void {\n  nextModule(\"next/dist/build/adapter/setup-node-env.external.js\");\n}\n\n/**\n * Load the staged `.env` / `.env.production` into `process.env`, the way\n * `NextNodeServer` does when `next start` constructs it. Nothing else would:\n * the built entrypoints never call `loadEnvConfig`, and the runtime builds no\n * `NextNodeServer`.\n *\n * Same semantics as `next start` because it is the same function — variables\n * already in `process.env` (the Lambda or task environment) win over the files.\n * `@next/env` is a dependency of `next`, not of the app, so it is resolved from\n * `next`'s own directory; the adapter stages it on that basis\n * (`addRuntimeNextClosure`).\n */\nexport function loadEnvFiles(projectDir: string): void {\n  const nextEnvRequire = createRequire(nextModuleResolve(\"next/package.json\"));\n  // Typed locally: `@next/env` is `next`'s dependency, not a resolvable one here.\n  const { loadEnvConfig } = nextEnvRequire(\"@next/env\") as {\n    loadEnvConfig: (dir: string, dev?: boolean) => unknown;\n  };\n  loadEnvConfig(projectDir, false);\n}\n\nfunction nextModuleResolve(specifier: string): string {\n  return nextRequireOrThrow(specifier).resolve(specifier);\n}\n\nfunction nextRequireOrThrow(\n  specifier: string,\n): ReturnType<typeof createRequire> {\n  if (!nextRequire) {\n    throw new Error(\n      `Cannot load \"${specifier}\": \\`next\\` resolution has not been pointed at ` +\n        `the staged app yet. \\`useNextFrom\\` runs in \\`loadRuntime\\`, so this ` +\n        `means runtime code loaded a \\`next\\` module before the runtime was ` +\n        `loaded.`,\n    );\n  }\n  return nextRequire;\n}\n\n/**\n * `require` a `next` submodule from the staged app.\n *\n * Pass the module's own type — `nextModule<typeof import(\"next/dist/...\")>(...)` —\n * so the call is as type-checked as a static import would be.\n */\nexport function nextModule<T>(specifier: string): T {\n  const load = nextRequireOrThrow(specifier);\n  try {\n    return load(specifier) as T;\n  } catch (cause) {\n    throw new Error(\n      `Could not resolve \"${specifier}\" from the deployed Next.js project. The ` +\n        `deployment package is missing part of the \\`next\\` closure that ` +\n        `\\`next build\\` traced, or \\`node_modules/next\\` resolves to a symlink ` +\n        `target that was not staged.`,\n      { cause },\n    );\n  }\n}\n"]}

package/lib/runtime/next-modules.test.d.ts

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

package/lib/runtime/next-modules.test.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_path_1 = require("node:path");
+const next_modules_1 = require("./next-modules");
+/** This repo's own root, which has a `node_modules/next`, as a stand-in for a staged project dir. */
+const repoRoot = (0, node_path_1.join)(__dirname, "../..");
+describe("nextModule", () => {
+    it("resolves a next submodule out of the pointed-at project dir", () => {
+        (0, next_modules_1.useNextFrom)(repoRoot);
+        const { getExtension } = (0, next_modules_1.nextModule)("next/dist/server/serve-static.js");
+        expect(getExtension("image/webp")).toBe("webp");
+    });
+    it("explains that the deployment package is incomplete when resolution fails", () => {
+        (0, next_modules_1.useNextFrom)(repoRoot);
+        expect(() => (0, next_modules_1.nextModule)("next/dist/server/not-a-real-module.js")).toThrow(/Could not resolve .* from the deployed Next.js project/);
+    });
+    it("makes AsyncLocalStorage global, which app-render reads at module scope", () => {
+        // The symptom of skipping this is "Invariant: AsyncLocalStorage accessed in
+        // runtime where it is not available" on the first dynamic app-page render.
+        (0, next_modules_1.useNextFrom)(repoRoot);
+        (0, next_modules_1.setupNodeEnvironment)();
+        const polyfilled = globalThis;
+        expect(typeof polyfilled.AsyncLocalStorage).toBe("function");
+    });
+    it("explains that the runtime was not loaded when nothing pointed it anywhere", () => {
+        // `useNextFrom` is module state, so the uninitialized case needs a fresh copy
+        // of the module rather than a reset of this one.
+        jest.isolateModules(() => {
+            const fresh = jest.requireActual("./next-modules");
+            expect(() => fresh.nextModule("next/dist/server/serve-static.js")).toThrow(/resolution has not been pointed at the staged app yet/);
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,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

package/lib/runtime/public-files.d.ts

@@ -0,0 +1,32 @@
+import { AdapterManifest } from "./manifest";
+/** Where `public/` sits in the deployment root, as a POSIX key. */
+export declare function publicDirKey(manifest: AdapterManifest): string;
+/**
+ * Every file under `public/`, as `/`-separated paths relative to it, unencoded:
+ * `static/hello e2e.png`, `images/logo@2x.png`.
+ *
+ * Symlinks are followed, files and directories alike, because Next.js's
+ * `recursiveReadDir` follows them and so does everything that puts `public/` in
+ * front of a user: Docker `COPY` keeps a working link in the image, and CDK's
+ * asset staging uploads the target's bytes to S3. `Dirent.isFile()` describes the
+ * link, not its target, so filtering on it silently dropped them. A directory
+ * is not entered from inside itself, so a link cycle terminates.
+ */
+export declare function readPublicFiles(dir: string): string[];
+/** `public/` as the runtime serves it, and where its bytes are. */
+export interface PublicFiles {
+    readonly files: readonly string[];
+    /**
+     * `true` when `files` came from {@link PUBLIC_FILES_FILE_NAME}: every type
+     * but `NextjsRegionalContainers`. Their bytes are in S3.
+     */
+    readonly inS3: boolean;
+}
+/**
+ * The synth-time list when the deployment root has one, which is every type but
+ * `NextjsRegionalContainers`, and `public/` off disk otherwise. The list wins
+ * even when some of `public/` is on disk: a route that reads a `public/` file
+ * through `fs` gets that file traced into a Lambda root, and the rest of
+ * `public/` is still only in S3.
+ */
+export declare function resolvePublicFiles(deploymentRoot: string, manifest: AdapterManifest): PublicFiles;