cdk-nextjs 0.7.12 → 0.7.14

package/lib/nextjs-distribution.test.js

@@ -4,6 +4,9 @@ const node_vm_1 = require("node:vm");
 const aws_cdk_lib_1 = require("aws-cdk-lib");
 const assertions_1 = require("aws-cdk-lib/assertions");
 const aws_cloudfront_1 = require("aws-cdk-lib/aws-cloudfront");
+const aws_cloudfront_origins_1 = require("aws-cdk-lib/aws-cloudfront-origins");
+const aws_ec2_1 = require("aws-cdk-lib/aws-ec2");
+const aws_elasticloadbalancingv2_1 = require("aws-cdk-lib/aws-elasticloadbalancingv2");
 const aws_lambda_1 = require("aws-cdk-lib/aws-lambda");
 const aws_s3_1 = require("aws-cdk-lib/aws-s3");
 const function_groups_1 = require("./adapter/function-groups");
@@ -71,6 +74,137 @@ describe("NextjsDistribution function group behaviors", () => {
         new nextjs_distribution_1.NextjsDistribution(stack, "Distribution", distributionProps);
         expect(pathPatterns(stack)).toEqual(["_next/static*", "_next/image*"]);
     });
+    describe("service workers", () => {
+        const serviceWorkerPolicy = (stack) => {
+            const config = Object.values(assertions_1.Template.fromStack(stack).findResources("AWS::CloudFront::Distribution"))[0].Properties.DistributionConfig;
+            const behavior = config.CacheBehaviors.find(({ PathPattern }) => PathPattern.includes("service-worker"));
+            const policies = assertions_1.Template.fromStack(stack).findResources("AWS::CloudFront::ResponseHeadersPolicy");
+            return policies[behavior.ResponseHeadersPolicyId.Ref].Properties
+                .ResponseHeadersPolicyConfig;
+        };
+        it("sends Service-Worker-Allowed from a behavior ahead of _next/static*", () => {
+            // CloudFront stops at the first match, so after `_next/static*` it would
+            // never be reached.
+            const { stack, distributionProps } = setup([]);
+            new nextjs_distribution_1.NextjsDistribution(stack, "Distribution", {
+                ...distributionProps,
+                serviceWorkerAllowed: "/",
+            });
+            expect(pathPatterns(stack)).toEqual([
+                "_next/static/service-worker/*",
+                "_next/static*",
+                "_next/image*",
+            ]);
+            const policy = serviceWorkerPolicy(stack);
+            expect(policy.CustomHeadersConfig.Items).toEqual([
+                { Header: "Service-Worker-Allowed", Value: "/", Override: true },
+            ]);
+            // The security headers the other static behaviors send.
+            expect(policy.SecurityHeadersConfig.StrictTransportSecurity).toBeDefined();
+        });
+        it("prefixes the pattern with basePath", () => {
+            const { stack, distributionProps } = setup([], { basePath: "/base" });
+            new nextjs_distribution_1.NextjsDistribution(stack, "Distribution", {
+                ...distributionProps,
+                serviceWorkerAllowed: "/base",
+            });
+            expect(pathPatterns(stack)[0]).toBe("/base/_next/static/service-worker/*");
+            expect(serviceWorkerPolicy(stack).CustomHeadersConfig.Items).toEqual([
+                { Header: "Service-Worker-Allowed", Value: "/base", Override: true },
+            ]);
+        });
+        it("adds no behavior without service workers", () => {
+            const { stack, distributionProps } = setup([]);
+            new nextjs_distribution_1.NextjsDistribution(stack, "Distribution", distributionProps);
+            expect(pathPatterns(stack)).not.toContain("_next/static/service-worker/*");
+        });
+        it("keeps staticResponseHeadersPolicyProps, its custom headers included", () => {
+            const { stack, distributionProps } = setup([]);
+            new nextjs_distribution_1.NextjsDistribution(stack, "Distribution", {
+                ...distributionProps,
+                serviceWorkerAllowed: "/",
+                overrides: {
+                    staticResponseHeadersPolicyProps: {
+                        responseHeadersPolicyName: "static",
+                        customHeadersBehavior: {
+                            customHeaders: [{ header: "X-Team", value: "a", override: true }],
+                        },
+                    },
+                },
+            });
+            const policy = serviceWorkerPolicy(stack);
+            // Names are unique per account, so it can't share the static policy's.
+            expect(policy.Name).toBe("static-sw");
+            expect(policy.CustomHeadersConfig.Items).toEqual([
+                { Header: "X-Team", Value: "a", Override: true },
+                { Header: "Service-Worker-Allowed", Value: "/", Override: true },
+            ]);
+        });
+        it("keeps a suffixed policy name within CloudFront's 128 characters", () => {
+            const { stack, distributionProps } = setup([]);
+            new nextjs_distribution_1.NextjsDistribution(stack, "Distribution", {
+                ...distributionProps,
+                serviceWorkerAllowed: "/",
+                overrides: {
+                    staticResponseHeadersPolicyProps: {
+                        responseHeadersPolicyName: "a".repeat(128),
+                    },
+                },
+            });
+            expect(serviceWorkerPolicy(stack).Name).toBe(`${"a".repeat(125)}-sw`);
+        });
+        it("keeps a Service-Worker-Allowed the static override sets", () => {
+            const { stack, distributionProps } = setup([]);
+            new nextjs_distribution_1.NextjsDistribution(stack, "Distribution", {
+                ...distributionProps,
+                serviceWorkerAllowed: "/",
+                overrides: {
+                    staticResponseHeadersPolicyProps: {
+                        customHeadersBehavior: {
+                            customHeaders: [
+                                {
+                                    header: "service-worker-allowed",
+                                    value: "/app",
+                                    override: true,
+                                },
+                            ],
+                        },
+                    },
+                },
+            });
+            expect(serviceWorkerPolicy(stack).CustomHeadersConfig.Items).toEqual([
+                { Header: "service-worker-allowed", Value: "/app", Override: true },
+            ]);
+        });
+        it("warns and uses a replaced static policy as it is", () => {
+            const { stack, distributionProps } = setup([]);
+            const distribution = new nextjs_distribution_1.NextjsDistribution(stack, "Distribution", {
+                ...distributionProps,
+                serviceWorkerAllowed: "/",
+                overrides: {
+                    staticBehaviorOptions: {
+                        responseHeadersPolicy: aws_cloudfront_1.ResponseHeadersPolicy.fromResponseHeadersPolicyId(stack, "Custom", "custom-policy"),
+                    },
+                },
+            });
+            assertions_1.Annotations.fromStack(stack).hasWarning(`/${distribution.node.path}`, assertions_1.Match.stringLikeRegexp("Service-Worker-Allowed"));
+            const config = Object.values(assertions_1.Template.fromStack(stack).findResources("AWS::CloudFront::Distribution"))[0].Properties.DistributionConfig;
+            expect(config.CacheBehaviors[0]).toMatchObject({
+                PathPattern: "_next/static/service-worker/*",
+                ResponseHeadersPolicyId: "custom-policy",
+            });
+        });
+        it("counts its behavior against the budget", () => {
+            const { stack, distributionProps } = setup([], {
+                publicDirEntries: Array.from({ length: 72 }, (_, i) => `f${i}`),
+            });
+            // 3 fixed + 72 public = 75 fits; the service worker behavior makes 76.
+            expect(() => new nextjs_distribution_1.NextjsDistribution(stack, "Distribution", {
+                ...distributionProps,
+                serviceWorkerAllowed: "/",
+            })).toThrow(/needs 76 CloudFront cache behaviors/);
+        });
+    });
     it("lets the OAC principal list the bucket so a missing asset is a 404", () => {
         const { stack, distributionProps } = setup([]);
         new nextjs_distribution_1.NextjsDistribution(stack, "Distribution", distributionProps);
@@ -313,7 +447,7 @@ describe("NextjsDistribution function group behaviors", () => {
                     ],
                 },
             },
-        })).toThrow(/already associates a CloudFront function with viewer-request/);
+        })).toThrow(/associates a CloudFront function with viewer-request, but serving `assetPrefix`/);
     });
     const userFn = (stack, eventType) => ({
         eventType,
@@ -650,38 +784,38 @@ describe("the viewer-request CloudFront Function", () => {
         ["/foo//bar", "/foo/bar"],
         ["/basepath//to-sv", "/basepath/to-sv"],
         ["/a\\b", "/a/b"],
-    ])("redirects %s to %s with a 308", (uri, location) => {
-        expect(redirect(send(uri))).toEqual({ statusCode: 308, location });
+    ])("redirects %s to %s with a 308", async (uri, location) => {
+        expect(redirect(await send(uri))).toEqual({ statusCode: 308, location });
     });
-    it("keeps the query on the redirect, including repeated keys", () => {
+    it("keeps the query on the redirect, including repeated keys", async () => {
         // CloudFront's shape for a repeated key: `multiValue` holds every value,
         // the first included, and `value` repeats that first one.
-        const result = send("/x//y", {
+        const result = await send("/x//y", {
             json: { value: "true" },
             a: { value: "1", multiValue: [{ value: "1" }, { value: "2" }] },
             flag: { value: "" },
         });
         expect(redirect(result).location).toBe("/x/y?json=true&a=1&a=2&flag");
     });
-    it("passes percent-encoded query values through without re-encoding", () => {
+    it("passes percent-encoded query values through without re-encoding", async () => {
         // CloudFront hands the function the values still encoded, as sent.
-        const result = send("/x//y", {
+        const result = await send("/x//y", {
             a: { value: "%20b%26c" },
             p: { value: "1+2" },
         });
         expect(redirect(result).location).toBe("/x/y?a=%20b%26c&p=1+2");
     });
-    it("passes an ordinary path through with x-forwarded-host set", () => {
-        const result = send("/a/b");
+    it("passes an ordinary path through with x-forwarded-host set", async () => {
+        const result = (await send("/a/b"));
         expect(result.uri).toBe("/a/b");
         // CloudFront rewrites `host` to the origin domain, so the app would otherwise
         // build every absolute URL against the Function URL's hostname.
         expect(result.headers["x-forwarded-host"].value).toBe("a.test");
     });
-    it("overwrites a client-supplied x-forwarded-host", () => {
+    it("overwrites a client-supplied x-forwarded-host", async () => {
         // The runtime trusts this header behind the Function URL, so a viewer's
         // own value must not survive to build redirects or origin checks.
-        const result = handler({
+        const result = (await handler({
             request: {
                 uri: "/a",
                 querystring: {},
@@ -690,8 +824,354 @@ describe("the viewer-request CloudFront Function", () => {
                     "x-forwarded-host": { value: "evil.test" },
                 },
             },
+        }));
+        expect(result.headers["x-forwarded-host"].value).toBe("a.test");
+    });
+});
+/**
+ * `viewerRequestFunctionCode`, run as CloudFront would run it on each behavior,
+ * for the same reason as the suite above.
+ */
+describe("viewerRequestFunctionCode", () => {
+    const BASIC_AUTH = `
+    function viewerRequest(event) {
+      var auth = event.request.headers.authorization;
+      if (auth && auth.value === "Basic dXNlcjpwYXNz") return;
+      return {
+        statusCode: 401,
+        statusDescription: "Unauthorized",
+        headers: { "www-authenticate": { value: 'Basic realm="preview"' } },
+      };
+    }
+  `;
+    const AUTHORIZED = { authorization: "Basic dXNlcjpwYXNz" };
+    /** What `viewerRequestKeyValueStore` holds, as `cf.kvs()` would read it. */
+    const fakeCloudFrontModule = (values) => ({
+        kvs: () => ({
+            get: async (key) => {
+                if (!(key in values))
+                    throw new Error(`key not found: ${key}`);
+                return values[key];
+            },
+        }),
+    });
+    const synth = (props = {}) => {
+        const stack = new aws_cdk_lib_1.Stack(new aws_cdk_lib_1.App(), "TestStack");
+        const keyValueStore = props.keyValueStore
+            ? new aws_cloudfront_1.KeyValueStore(stack, "Kvs")
+            : undefined;
+        const compute = props.nextjsType === constants_1.NextjsType.GLOBAL_CONTAINERS
+            ? {
+                loadBalancer: new aws_elasticloadbalancingv2_1.ApplicationLoadBalancer(stack, "Alb", {
+                    vpc: new aws_ec2_1.Vpc(stack, "Vpc"),
+                }),
+            }
+            : {
+                functionUrl: new aws_lambda_1.FunctionUrl(stack, "Url", {
+                    function: new aws_lambda_1.Function(stack, "Fn", {
+                        code: aws_lambda_1.Code.fromInline("exports.handler = () => {};"),
+                        handler: "index.handler",
+                        runtime: aws_lambda_1.Runtime.NODEJS_22_X,
+                    }),
+                    authType: aws_lambda_1.FunctionUrlAuthType.AWS_IAM,
+                }),
+            };
+        new nextjs_distribution_1.NextjsDistribution(stack, "Distribution", {
+            ...compute,
+            assetsBucket: new aws_s3_1.Bucket(stack, "Assets"),
+            assetPrefix: props.assetPrefix,
+            basePath: props.basePath,
+            nextjsType: props.nextjsType ?? constants_1.NextjsType.GLOBAL_FUNCTIONS,
+            overrides: props.overrides?.(stack),
+            publicDirEntries: [{ name: "favicon.ico", isDirectory: false }],
+            viewerRequestFunctionCode: props.code === undefined
+                ? undefined
+                : aws_cloudfront_1.FunctionCode.fromInline(props.code),
+            viewerRequestKeyValueStore: keyValueStore,
+        });
+        const template = assertions_1.Template.fromStack(stack);
+        const functions = template.findResources("AWS::CloudFront::Function");
+        const config = Object.values(template.findResources("AWS::CloudFront::Distribution"))[0].Properties.DistributionConfig;
+        const behaviors = [
+            { PathPattern: "*", ...config.DefaultCacheBehavior },
+            ...config.CacheBehaviors,
+        ];
+        /** The viewer-request function on the behavior for `pathPattern`. */
+        const functionFor = (pathPattern) => {
+            const behavior = behaviors.find((it) => it.PathPattern === pathPattern);
+            const association = behavior.FunctionAssociations.find((it) => it.EventType === "viewer-request");
+            return functions[association.FunctionARN["Fn::GetAtt"][0]].Properties;
+        };
+        /**
+         * That function's handler, runnable. `node:vm` scripts can't `import`, so
+         * the `cloudfront` module is handed in as the binding the import makes.
+         */
+        const handlerFor = (pathPattern, kvsValues = {}) => {
+            const code = functionFor(pathPattern).FunctionCode.replace(/^\s*import cf from "cloudfront";/, "");
+            return (0, node_vm_1.runInNewContext)(`${code}\nhandler`, {
+                cf: fakeCloudFrontModule(kvsValues),
+            });
+        };
+        return { behaviors, functions, functionFor, handlerFor, stack };
+    };
+    const request = (uri, headers = {}) => ({
+        request: {
+            uri,
+            querystring: {},
+            headers: Object.fromEntries(Object.entries({ host: "a.test", ...headers }).map(([name, value]) => [
+                name,
+                { value },
+            ])),
+        },
+    });
+    const status = (result) => result.statusCode;
+    it.each([constants_1.NextjsType.GLOBAL_FUNCTIONS, constants_1.NextjsType.GLOBAL_CONTAINERS])("gates every behavior on %s, static assets included", async (nextjsType) => {
+        const { behaviors, handlerFor } = synth({ code: BASIC_AUTH, nextjsType });
+        expect(behaviors.map((it) => it.PathPattern).sort()).toEqual([
+            "*",
+            "_next/image*",
+            "_next/static*",
+            "favicon.ico",
+        ]);
+        for (const { PathPattern } of behaviors) {
+            const handler = handlerFor(PathPattern);
+            expect(status(await handler(request("/x")))).toBe(401);
+            const passed = (await handler(request("/x", AUTHORIZED)));
+            expect(passed.uri).toBe("/x");
+        }
+    });
+    it("shares one pass-through function between dynamic and static on Global Containers", () => {
+        const { behaviors, functions } = synth({
+            code: BASIC_AUTH,
+            nextjsType: constants_1.NextjsType.GLOBAL_CONTAINERS,
         });
+        const [logicalId, ...rest] = Object.keys(functions);
+        expect(rest).toHaveLength(0);
+        expect(behaviors.map((it) => it.PathPattern).sort()).toEqual([
+            "*",
+            "_next/image*",
+            "_next/static*",
+            "favicon.ico",
+        ]);
+        for (const { FunctionAssociations } of behaviors) {
+            expect(FunctionAssociations).toEqual([
+                {
+                    EventType: "viewer-request",
+                    FunctionARN: { "Fn::GetAtt": [logicalId, "FunctionARN"] },
+                },
+            ]);
+        }
+    });
+    it("accepts viewerRequest declared after another variable", async () => {
+        const handler = synth({
+            code: `var x = 1, viewerRequest = (event) => ({ statusCode: 401 });`,
+        }).handlerFor("_next/static*");
+        expect(status(await handler(request("/x")))).toBe(401);
+    });
+    it("accepts viewerRequest defined as a const arrow function", async () => {
+        const handler = synth({
+            code: `const viewerRequest = async (event) => ({ statusCode: 401 });`,
+        }).handlerFor("_next/static*");
+        expect(status(await handler(request("/x")))).toBe(401);
+    });
+    it("runs before the repeated-slash redirect", async () => {
+        // Otherwise `/a//b` would answer 308 to a viewer who never authenticated.
+        const handler = synth({ code: BASIC_AUTH }).handlerFor("*");
+        expect(status(await handler(request("/a//b")))).toBe(401);
+        expect(status(await handler(request("/a//b", AUTHORIZED)))).toBe(308);
+    });
+    it("associates the store with every function it runs in", () => {
+        const { behaviors, functionFor, functions } = synth({
+            code: BASIC_AUTH,
+            keyValueStore: true,
+            assetPrefix: "/cdn",
+        });
+        expect(Object.keys(functions)).toHaveLength(3);
+        for (const { PathPattern } of behaviors) {
+            const { FunctionConfig } = functionFor(PathPattern);
+            expect(FunctionConfig.Runtime).toBe("cloudfront-js-2.0");
+            expect(FunctionConfig.KeyValueStoreAssociations).toEqual([
+                { KeyValueStoreARN: { "Fn::GetAtt": [expect.any(String), "Arn"] } },
+            ]);
+        }
+    });
+    it("reads credentials from the KeyValueStore", async () => {
+        const handler = synth({
+            keyValueStore: true,
+            code: `import cf from "cloudfront";
+        const kvs = cf.kvs();
+        async function viewerRequest(event) {
+          const auth = event.request.headers.authorization;
+          if (auth && auth.value === "Basic " + (await kvs.get("basic-auth"))) {
+            return;
+          }
+          return { statusCode: 401, statusDescription: "Unauthorized" };
+        }
+      `,
+        }).handlerFor("_next/static*", { "basic-auth": "dXNlcjpwYXNz" });
+        expect(status(await handler(request("/x")))).toBe(401);
+        expect((await handler(request("/x", AUTHORIZED))).uri).toBe("/x");
+    });
+    it("refuses a KeyValueStore without code to read it", () => {
+        expect(() => synth({ keyValueStore: true })).toThrow(/`viewerRequestKeyValueStore` .* needs `viewerRequestFunctionCode`/);
+    });
+    it("can't keep a viewer's x-forwarded-host past cdk-nextjs's overwrite", async () => {
+        const handler = synth({
+            code: `
+        function viewerRequest(event) {
+          event.request.headers["x-forwarded-host"] = { value: "evil.test" };
+          return event.request;
+        }
+      `,
+        }).handlerFor("*");
+        const result = (await handler(request("/x")));
         expect(result.headers["x-forwarded-host"].value).toBe("a.test");
     });
+    it("carries on with a request it returns as a new object", async () => {
+        const handler = synth({
+            code: `
+        function viewerRequest(event) {
+          return { uri: "/y", querystring: {}, headers: event.request.headers };
+        }
+      `,
+        }).handlerFor("_next/static*");
+        expect((await handler(request("/x"))).uri).toBe("/y");
+    });
+    it("runs inside the assetPrefix rewrite, in place of the static function", async () => {
+        const { behaviors, handlerFor } = synth({
+            code: BASIC_AUTH,
+            assetPrefix: "/cdn",
+        });
+        const prefixed = behaviors.find((it) => it.PathPattern === "/cdn/_next/static*");
+        // One viewer-request function per behavior, or CloudFront rejects it.
+        expect(prefixed.FunctionAssociations.filter((it) => it.EventType === "viewer-request")).toHaveLength(1);
+        const handler = handlerFor("/cdn/_next/static*");
+        expect(status(await handler(request("/cdn/_next/static/a.js")))).toBe(401);
+        const passed = (await handler(request("/cdn/_next/static/a.js", AUTHORIZED)));
+        expect(passed.uri).toBe("/_next/static/a.js");
+    });
+    it("adds no functions when unset", () => {
+        const { behaviors, functions } = synth();
+        const staticBehavior = behaviors.find((it) => it.PathPattern === "_next/static*");
+        expect(staticBehavior.FunctionAssociations).toBeUndefined();
+        const [fn, ...rest] = Object.values(functions).map((it) => it.Properties);
+        expect(rest).toHaveLength(0);
+        // The marker is dropped, not left in the deployed function.
+        expect(fn.FunctionCode).toMatch(/^\s*async function handler\(event\) \{\n\s*const request/);
+        expect(fn.FunctionConfig.KeyValueStoreAssociations).toBeUndefined();
+    });
+    it.each([false, true])("runs every cdk-nextjs function on cloudfront-js-2.0 (hook set: %s)", (hooked) => {
+        const { functions } = synth({
+            code: hooked ? BASIC_AUTH : undefined,
+            assetPrefix: "/cdn",
+        });
+        const runtimes = Object.values(functions).map((it) => it.Properties.FunctionConfig.Runtime);
+        expect(runtimes).toHaveLength(hooked ? 3 : 2);
+        expect(new Set(runtimes)).toEqual(new Set(["cloudfront-js-2.0"]));
+    });
+    it.each(["dynamicBehaviorOptions", "imageBehaviorOptions"])("refuses a %s override that claims viewer-request on Global Containers", (overrideName) => {
+        expect(() => synth({
+            code: BASIC_AUTH,
+            nextjsType: constants_1.NextjsType.GLOBAL_CONTAINERS,
+            overrides: (stack) => ({
+                [overrideName]: {
+                    functionAssociations: [
+                        {
+                            eventType: aws_cloudfront_1.FunctionEventType.VIEWER_REQUEST,
+                            function: new aws_cloudfront_1.Function(stack, "UserFn", {
+                                code: aws_cloudfront_1.FunctionCode.fromInline("function handler(event) { return event.request; }"),
+                            }),
+                        },
+                    ],
+                },
+            }),
+        })).toThrow(new RegExp(`overrides\\.${overrideName}\\.functionAssociations.*viewerRequestFunctionCode`));
+    });
+    it("refuses a distributionProps.defaultBehavior override", () => {
+        expect(() => synth({
+            code: BASIC_AUTH,
+            overrides: () => ({
+                distributionProps: {
+                    defaultBehavior: {
+                        origin: new aws_cloudfront_origins_1.HttpOrigin("example.com"),
+                    },
+                },
+            }),
+        })).toThrow(/overrides\.distributionProps\.defaultBehavior/);
+    });
+    it("lets a basePath app replace the default behavior", () => {
+        expect(() => synth({
+            code: BASIC_AUTH,
+            basePath: "/app",
+            overrides: () => ({
+                distributionProps: {
+                    defaultBehavior: { origin: new aws_cloudfront_origins_1.HttpOrigin("example.com") },
+                },
+            }),
+        })).not.toThrow();
+    });
+    it("keeps cdk-nextjs's code out of the deployed indentation", () => {
+        const { functionFor } = synth({ code: BASIC_AUTH });
+        const code = functionFor("*").FunctionCode;
+        const own = code.slice(code.indexOf("async function handler"));
+        expect(own).not.toMatch(/^[ \t]/m);
+    });
+    it("warns, rather than measures, when the code contains a token", () => {
+        const { stack } = synth({
+            code: `function viewerRequest(event) { return ${aws_cdk_lib_1.Lazy.string({ produce: () => '"x"' })}; }`,
+        });
+        assertions_1.Annotations.fromStack(stack).hasWarning("*", assertions_1.Match.stringLikeRegexp("contains a CDK token"));
+    });
+    it("refuses a static override that already claims viewer-request", () => {
+        expect(() => synth({
+            code: BASIC_AUTH,
+            overrides: (stack) => ({
+                staticBehaviorOptions: {
+                    functionAssociations: [
+                        {
+                            eventType: aws_cloudfront_1.FunctionEventType.VIEWER_REQUEST,
+                            function: new aws_cloudfront_1.Function(stack, "UserFn", {
+                                code: aws_cloudfront_1.FunctionCode.fromInline("function handler(event) { return event.request; }"),
+                            }),
+                        },
+                    ],
+                },
+            }),
+        })).toThrow(/overrides\.staticBehaviorOptions\.functionAssociations/);
+    });
+    it.each([
+        ["no viewerRequest", "var x = 1;", /must define `viewerRequest\(event\)`/],
+        ...[
+            "function handler(event) {}",
+            "function* handler(event) {}",
+            "const handler = (event) => event.request;",
+            "let a = 1, handler = 2;",
+            "var handler = (event) => event.request;",
+            "var { handler } = { handler: (event) => event.request };",
+            'globalThis["handler"] = (event) => event.request;',
+            "var cdkNextjsHandler; handler = cdkNextjsHandler;",
+        ].map((declaration) => [
+            `handler in \`${declaration}\``,
+            `${declaration}\nfunction viewerRequest(event) {}`,
+            /uses the name `handler`/,
+        ]),
+        [
+            "viewerRequest only compared, never declared",
+            'const ok = typeof viewerRequest === "function";',
+            /must define `viewerRequest\(event\)`/,
+        ],
+        [
+            "viewerRequest only assigned as a property",
+            "const cfg = {}; cfg.viewerRequest = function (event) {};",
+            /must define `viewerRequest\(event\)`/,
+        ],
+        [
+            "more than fits in a CloudFront Function",
+            `function viewerRequest(event) {} /* ${"x".repeat(10 * 1024)} */`,
+            /over CloudFront's limit of 10240/,
+        ],
+    ])("refuses code with %s", (_name, code, error) => {
+        expect(() => synth({ code })).toThrow(error);
+    });
 });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"nextjs-distribution.test.js","sourceRoot":"","sources":["../src/nextjs-distribution.test.ts"],"names":[],"mappings":"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","sourcesContent":["import { runInNewContext } from \"node:vm\";\nimport { App, Duration, Stack } from \"aws-cdk-lib\";\nimport { Annotations, Match, Template } from \"aws-cdk-lib/assertions\";\nimport {\n  Function as CloudFrontFunction,\n  FunctionCode,\n  FunctionEventType,\n} from \"aws-cdk-lib/aws-cloudfront\";\nimport {\n  Code,\n  Function as LambdaFunction,\n  FunctionUrl,\n  FunctionUrlAuthType,\n  Runtime,\n} from \"aws-cdk-lib/aws-lambda\";\nimport { Bucket } from \"aws-cdk-lib/aws-s3\";\nimport { pathPatternsFor } from \"./adapter/function-groups\";\nimport { NextjsType } from \"./constants\";\nimport {\n  NextjsDistribution,\n  NextjsDistributionFunctionGroup,\n} from \"./nextjs-distribution\";\n\n/**\n * `functionGroups` routing at the edge. `NextjsBuild` is deliberately not\n * involved: which behaviors a group gets, and in what order, is the adapter's\n * decision (`function-groups.test.ts`), so these pass the behaviors in directly\n * and assert on what the distribution does with them.\n */\ndescribe(\"NextjsDistribution function group behaviors\", () => {\n  const setup = (\n    groupNames: string[],\n    props: {\n      routesFor?: (name: string) => string[];\n      publicDirEntries?: string[];\n      basePath?: string;\n      trailingSlash?: boolean;\n    } = {},\n  ) => {\n    const stack = new Stack(new App(), \"TestStack\");\n    const functionGroups: NextjsDistributionFunctionGroup[] = groupNames.map(\n      (name) => {\n        const fn = new LambdaFunction(stack, `Fn${name}`, {\n          code: Code.fromInline(\"exports.handler = () => {};\"),\n          handler: \"index.handler\",\n          runtime: Runtime.NODEJS_22_X,\n        });\n        return {\n          name,\n          functionUrl: new FunctionUrl(stack, `Url${name}`, {\n            function: fn,\n            authType: FunctionUrlAuthType.AWS_IAM,\n          }),\n        };\n      },\n    );\n    // In the order given: the build's list is already most specific first.\n    const functionGroupBehaviors = groupNames.flatMap((group) =>\n      (props.routesFor?.(group) ?? [`/${group}/**`]).flatMap((route) =>\n        pathPatternsFor(route, {\n          hasDataRoutes: false,\n          trailingSlash: props.trailingSlash,\n        }).map((pattern) => ({ group, route, pattern })),\n      ),\n    );\n    const defaultFn = new LambdaFunction(stack, \"FnDefault\", {\n      code: Code.fromInline(\"exports.handler = () => {};\"),\n      handler: \"index.handler\",\n      runtime: Runtime.NODEJS_22_X,\n    });\n    return {\n      stack,\n      functionGroups,\n      functionGroupBehaviors,\n      distributionProps: {\n        assetsBucket: new Bucket(stack, \"Assets\"),\n        basePath: props.basePath,\n        functionUrl: new FunctionUrl(stack, \"UrlDefault\", {\n          function: defaultFn,\n          authType: FunctionUrlAuthType.AWS_IAM,\n        }),\n        nextjsType: NextjsType.GLOBAL_FUNCTIONS,\n        publicDirEntries: (props.publicDirEntries ?? []).map((name) => ({\n          name,\n          isDirectory: false,\n        })),\n      },\n    };\n  };\n\n  const pathPatterns = (stack: Stack) => {\n    const distributions = Template.fromStack(stack).findResources(\n      \"AWS::CloudFront::Distribution\",\n    );\n    const config =\n      Object.values(distributions)[0].Properties.DistributionConfig;\n    return (config.CacheBehaviors as Array<{ PathPattern: string }>).map(\n      (behavior) => behavior.PathPattern,\n    );\n  };\n\n  it(\"adds nothing extra when there are no groups\", () => {\n    const { stack, distributionProps } = setup([]);\n    new NextjsDistribution(stack, \"Distribution\", distributionProps);\n    expect(pathPatterns(stack)).toEqual([\"_next/static*\", \"_next/image*\"]);\n  });\n\n  it(\"lets the OAC principal list the bucket so a missing asset is a 404\", () => {\n    const { stack, distributionProps } = setup([]);\n    new NextjsDistribution(stack, \"Distribution\", distributionProps);\n    Template.fromStack(stack).hasResourceProperties(\"AWS::S3::BucketPolicy\", {\n      PolicyDocument: {\n        Statement: Match.arrayWith([\n          Match.objectLike({\n            Action: [\"s3:GetObject\", \"s3:ListBucket\"],\n            Principal: { Service: \"cloudfront.amazonaws.com\" },\n          }),\n        ]),\n      },\n    });\n  });\n\n  it(\"adds group behaviors in the build's order, after the image behavior\", () => {\n    // CloudFront stops at the first matching behavior, so `api/*` ahead of\n    // `api/reports/*` would send every report request to the wrong function.\n    // The build sorted them when it checked them; re-sorting here could only\n    // disagree with that.\n    const { stack, functionGroups, functionGroupBehaviors, distributionProps } =\n      setup([\"reports\", \"api\"], {\n        routesFor: (name) =>\n          name === \"api\" ? [\"/api/**\"] : [\"/api/reports/**\"],\n      });\n    new NextjsDistribution(stack, \"Distribution\", {\n      ...distributionProps,\n      functionGroups,\n      functionGroupBehaviors,\n    });\n    expect(pathPatterns(stack)).toEqual([\n      \"_next/static*\",\n      \"_next/image*\",\n      \"api/reports/*\",\n      \"api/*\",\n    ]);\n  });\n\n  it(\"keeps the two slash variants distinct under a basePath\", () => {\n    // `getPathPattern` used to join through a helper that strips trailing\n    // slashes, so `pricing` and `pricing/` both became `/base/pricing`: two\n    // behaviors with the same path pattern, which CloudFront rejects at deploy\n    // with no hint that `trailingSlash` is what produced the duplicate.\n    const { stack, functionGroups, functionGroupBehaviors, distributionProps } =\n      setup([\"mkt\"], {\n        routesFor: () => [\"/pricing\"],\n        basePath: \"/base\",\n        trailingSlash: true,\n      });\n    new NextjsDistribution(stack, \"Distribution\", {\n      ...distributionProps,\n      functionGroups,\n      functionGroupBehaviors,\n    });\n    const patterns = pathPatterns(stack);\n    expect(patterns).toContain(\"/base/pricing\");\n    expect(patterns).toContain(\"/base/pricing/\");\n  });\n\n  it(\"counts the basePath behaviors against the budget\", () => {\n    const { stack, distributionProps } = setup([], {\n      basePath: \"/base\",\n      publicDirEntries: Array.from({ length: 21 }, (_, i) => `file${i}.txt`),\n    });\n    // 3 fixed + the 2 a basePath adds to stand in for the default behavior + 21\n    // public = 26. Counting only the 3 reported 24 and let the synth through, so\n    // the limit arrived as a CloudFront deploy failure.\n    expect(\n      () =>\n        new NextjsDistribution(stack, \"Distribution\", {\n          ...distributionProps,\n          maxCacheBehaviors: 25,\n        }),\n    ).toThrow(/26 CloudFront cache behaviors.*5 used by cdk-nextjs itself/s);\n  });\n\n  it(\"defaults the budget to CloudFront's quota of 75\", () => {\n    // The hard-coded 25 predated the quota's increase to 75.\n    const { stack, distributionProps } = setup([], {\n      publicDirEntries: Array.from({ length: 72 }, (_, i) => `file${i}.txt`),\n    });\n    expect(\n      () => new NextjsDistribution(stack, \"Distribution\", distributionProps),\n    ).not.toThrow();\n    const { stack: over, distributionProps: overProps } = setup([], {\n      publicDirEntries: Array.from({ length: 73 }, (_, i) => `file${i}.txt`),\n    });\n    expect(\n      () => new NextjsDistribution(over, \"Distribution\", overProps),\n    ).toThrow(\n      /76 CloudFront cache behaviors, over the limit of 75.*set `maxCacheBehaviors`/s,\n    );\n  });\n\n  it(\"honors a raised maxCacheBehaviors\", () => {\n    const { stack, distributionProps } = setup([], {\n      publicDirEntries: Array.from({ length: 97 }, (_, i) => `file${i}.txt`),\n    });\n    expect(\n      () =>\n        new NextjsDistribution(stack, \"Distribution\", {\n          ...distributionProps,\n          maxCacheBehaviors: 100,\n        }),\n    ).not.toThrow();\n  });\n\n  it(\"does not count basePath behaviors for a basePath of /\", () => {\n    // `basePath: \"/\"` normalizes to no basePath and adds no behaviors, so\n    // counting 2 for it could reject an app that is under the limit.\n    const { stack, distributionProps } = setup([], {\n      basePath: \"/\",\n      publicDirEntries: Array.from({ length: 22 }, (_, i) => `file${i}.txt`),\n    });\n    expect(\n      () =>\n        new NextjsDistribution(stack, \"Distribution\", {\n          ...distributionProps,\n          maxCacheBehaviors: 25,\n        }),\n    ).not.toThrow();\n  });\n\n  it(\"rejects a behavior for a group it was not given\", () => {\n    const { stack, functionGroupBehaviors, distributionProps } = setup([\"api\"]);\n    expect(\n      () =>\n        new NextjsDistribution(stack, \"Distribution\", {\n          ...distributionProps,\n          functionGroupBehaviors,\n        }),\n    ).toThrow(\n      /routes to function group \"api\", which is not in `functionGroups`/,\n    );\n  });\n\n  it(\"points each group's behaviors at that group's own origin\", () => {\n    const { stack, functionGroups, functionGroupBehaviors, distributionProps } =\n      setup([\"api\"], {\n        routesFor: () => [\"/api/**\", \"/health\"],\n      });\n    new NextjsDistribution(stack, \"Distribution\", {\n      ...distributionProps,\n      functionGroups,\n      functionGroupBehaviors,\n    });\n    const distributions = Template.fromStack(stack).findResources(\n      \"AWS::CloudFront::Distribution\",\n    );\n    const config =\n      Object.values(distributions)[0].Properties.DistributionConfig;\n    const behaviors = config.CacheBehaviors as Array<{\n      PathPattern: string;\n      TargetOriginId: string;\n    }>;\n    const groupOrigins = new Set(\n      behaviors\n        .filter((behavior) =>\n          [\"api/*\", \"health\"].includes(behavior.PathPattern),\n        )\n        .map((behavior) => behavior.TargetOriginId),\n    );\n    // One origin, shared by both of the group's patterns, and not the default's.\n    expect(groupOrigins.size).toBe(1);\n    expect(groupOrigins).not.toContain(\n      config.DefaultCacheBehavior.TargetOriginId,\n    );\n  });\n\n  it(\"prefixes group patterns with basePath\", () => {\n    const { stack, functionGroups, functionGroupBehaviors, distributionProps } =\n      setup([\"api\"], {\n        routesFor: () => [\"/api/**\"],\n        basePath: \"/base\",\n      });\n    new NextjsDistribution(stack, \"Distribution\", {\n      ...distributionProps,\n      functionGroups,\n      functionGroupBehaviors,\n    });\n    expect(pathPatterns(stack)).toContain(\"/base/api/*\");\n  });\n\n  it(\"names every claim on the behavior budget when it is exceeded\", () => {\n    const { stack, functionGroups, functionGroupBehaviors, distributionProps } =\n      setup([\"api\"], {\n        routesFor: () => [\"/api/**\"],\n        publicDirEntries: Array.from({ length: 22 }, (_, i) => `file${i}.txt`),\n      });\n    expect(\n      () =>\n        new NextjsDistribution(stack, \"Distribution\", {\n          ...distributionProps,\n          functionGroups,\n          functionGroupBehaviors,\n          maxCacheBehaviors: 25,\n        }),\n    ).toThrow(\n      /26 CloudFront cache behaviors.*1 for `functionGroups` patterns/s,\n    );\n  });\n\n  it(\"rejects a group pattern that duplicates a public/ directory's\", () => {\n    // `public/docs/` and `/docs/**` both deploy as `docs/*`: the synth\n    // succeeded and CloudFront rejected the deploy.\n    const { stack, functionGroups, functionGroupBehaviors, distributionProps } =\n      setup([\"docs\"]);\n    expect(\n      () =>\n        new NextjsDistribution(stack, \"Distribution\", {\n          ...distributionProps,\n          functionGroups,\n          functionGroupBehaviors,\n          publicDirEntries: [{ name: \"docs\", isDirectory: true }],\n        }),\n    ).toThrow(\n      /pattern \"\\/docs\\/\\*\\*\" \\(group \"docs\"\\) deploys as the path pattern \"docs\\/\\*\", which a top-level public\\/ entry already uses/,\n    );\n  });\n\n  it(\"rejects a group pattern a public/ directory's behavior would shadow\", () => {\n    // `docs/*` is added first, so `docs/guide/*` never matches.\n    const { stack, functionGroups, functionGroupBehaviors, distributionProps } =\n      setup([\"guide\"], {\n        routesFor: () => [\"/docs/guide/**\"],\n      });\n    expect(\n      () =>\n        new NextjsDistribution(stack, \"Distribution\", {\n          ...distributionProps,\n          functionGroups,\n          functionGroupBehaviors,\n          publicDirEntries: [{ name: \"docs\", isDirectory: true }],\n        }),\n    ).toThrow(/public\\/ entry behind \"docs\\/\\*\" is matched first/);\n  });\n\n  it(\"rejects an exact group pattern equal to a public/ file's, basePath included\", () => {\n    const { stack, functionGroups, functionGroupBehaviors, distributionProps } =\n      setup([\"mkt\"], {\n        routesFor: () => [\"/robots.txt\"],\n        basePath: \"/base\",\n      });\n    expect(\n      () =>\n        new NextjsDistribution(stack, \"Distribution\", {\n          ...distributionProps,\n          functionGroups,\n          functionGroupBehaviors,\n          publicDirEntries: [{ name: \"robots.txt\", isDirectory: false }],\n        }),\n    ).toThrow(/deploys as the path pattern \"\\/base\\/robots\\.txt\"/);\n  });\n\n  it(\"allows a group pattern beside a public/ entry it does not overlap\", () => {\n    // `/docs` exact is not under `docs/*`, and `docs/*` does not match `/docs`.\n    const { stack, functionGroups, functionGroupBehaviors, distributionProps } =\n      setup([\"docs\"], {\n        routesFor: () => [\"/docs\"],\n      });\n    new NextjsDistribution(stack, \"Distribution\", {\n      ...distributionProps,\n      functionGroups,\n      functionGroupBehaviors,\n      publicDirEntries: [{ name: \"docs\", isDirectory: true }],\n    });\n    expect(pathPatterns(stack)).toEqual(\n      expect.arrayContaining([\"docs/*\", \"docs\"]),\n    );\n  });\n\n  it(\"serves bundles under a path-style assetPrefix, rewriting the prefix away\", () => {\n    // Next.js emits `<assetPrefix>/_next/static/...` for every bundle while the\n    // objects keep their unprefixed S3 keys, so without a behavior of its own the\n    // request falls through to the compute origin and 404s — the deployment\n    // package carries no `.next/static`. Measured against\n    // `test/e2e/app-dir/asset-prefix`, where 2 of 7 cases failed on exactly that.\n    const { stack, distributionProps } = setup([]);\n    new NextjsDistribution(stack, \"Distribution\", {\n      ...distributionProps,\n      assetPrefix: \"/custom-asset-prefix\",\n    });\n    // Ahead of the bare `_next/static*` in nothing but list position; the two\n    // patterns cannot both match one request, so order does not matter here.\n    expect(pathPatterns(stack)).toEqual([\n      \"_next/static*\",\n      \"/custom-asset-prefix/_next/static*\",\n      \"_next/image*\",\n    ]);\n    const fns = Template.fromStack(stack).findResources(\n      \"AWS::CloudFront::Function\",\n    );\n    const code = Object.values(fns)\n      .map((fn) => fn.Properties.FunctionCode as string)\n      .find((it) => it.includes(\"request.uri.slice\"));\n    // `\"/custom-asset-prefix\".length`, so `/custom-asset-prefix/_next/static/x`\n    // reaches S3 as `_next/static/x`.\n    expect(code).toContain('\"\" + request.uri.slice(20)');\n  });\n\n  it(\"refuses an assetPrefix when an override already claims VIEWER_REQUEST\", () => {\n    // CloudFront permits one function per event type per behavior, so the\n    // rewrite and the override cannot coexist: the stack synthed cleanly and was\n    // rejected at deploy, naming neither the override nor `assetPrefix`.\n    const { stack, distributionProps } = setup([]);\n    expect(\n      () =>\n        new NextjsDistribution(stack, \"Distribution\", {\n          ...distributionProps,\n          assetPrefix: \"/cdn\",\n          overrides: {\n            staticBehaviorOptions: {\n              functionAssociations: [\n                {\n                  eventType: FunctionEventType.VIEWER_REQUEST,\n                  function: new CloudFrontFunction(stack, \"UserFn\", {\n                    code: FunctionCode.fromInline(\n                      \"function handler(event) { return event.request; }\",\n                    ),\n                  }),\n                },\n              ],\n            },\n          },\n        }),\n    ).toThrow(/already associates a CloudFront function with viewer-request/);\n  });\n\n  const userFn = (stack: Stack, eventType: FunctionEventType) => ({\n    eventType,\n    function: new CloudFrontFunction(stack, `UserFn${eventType}`, {\n      code: FunctionCode.fromInline(\n        \"function handler(event) { return event.request || event.response; }\",\n      ),\n    }),\n  });\n\n  it.each([\"dynamicBehaviorOptions\", \"imageBehaviorOptions\"] as const)(\n    \"refuses a %s override that would replace the x-forwarded-host function\",\n    (overrideName) => {\n      // The runtime trusts `x-forwarded-host` on Function URL events because\n      // this function overwrites it; replaced, a viewer's own header reaches it.\n      const { stack, distributionProps } = setup([]);\n      expect(\n        () =>\n          new NextjsDistribution(stack, \"Distribution\", {\n            ...distributionProps,\n            overrides: {\n              [overrideName]: {\n                functionAssociations: [\n                  userFn(stack, FunctionEventType.VIEWER_REQUEST),\n                ],\n              },\n            },\n          }),\n      ).toThrow(\n        new RegExp(`overrides\\\\.${overrideName}\\\\.functionAssociations`),\n      );\n    },\n  );\n\n  it(\"keeps the x-forwarded-host function next to an override's other associations\", () => {\n    const { stack, distributionProps } = setup([]);\n    new NextjsDistribution(stack, \"Distribution\", {\n      ...distributionProps,\n      overrides: {\n        dynamicBehaviorOptions: {\n          functionAssociations: [\n            userFn(stack, FunctionEventType.VIEWER_RESPONSE),\n          ],\n        },\n      },\n    });\n    const config = Object.values(\n      Template.fromStack(stack).findResources(\"AWS::CloudFront::Distribution\"),\n    )[0].Properties.DistributionConfig;\n    const eventTypes = (\n      config.DefaultCacheBehavior.FunctionAssociations as Array<{\n        EventType: string;\n      }>\n    ).map((association) => association.EventType);\n    expect(eventTypes.sort()).toEqual([\"viewer-request\", \"viewer-response\"]);\n  });\n\n  it(\"rewrites an assetPrefix back onto the basePath S3 keys\", () => {\n    const { stack, distributionProps } = setup([], { basePath: \"/base\" });\n    new NextjsDistribution(stack, \"Distribution\", {\n      ...distributionProps,\n      assetPrefix: \"/cdn\",\n    });\n    expect(pathPatterns(stack)).toContain(\"/cdn/_next/static*\");\n    const fns = Template.fromStack(stack).findResources(\n      \"AWS::CloudFront::Function\",\n    );\n    const code = Object.values(fns)\n      .map((fn) => fn.Properties.FunctionCode as string)\n      .find((it) => it.includes(\"request.uri.slice\"));\n    // The objects are at `base/_next/static/...`: `assetPrefix` replaces the\n    // `basePath` prefix in the URL, so the rewrite has to put it back.\n    expect(code).toContain('\"/base\" + request.uri.slice(4)');\n  });\n\n  it(\"serves bundles under the path an absolute assetPrefix carries\", () => {\n    // `next build` compiles a `/custom-asset-prefix/_next/:path+ → /_next/:path+`\n    // rewrite of its own for an absolute prefix with a path, so `next start` serves\n    // every bundle under that path as well. A CDN fronting this distribution there\n    // gets the same request, and without a behavior it reaches the compute origin\n    // and 404s. Measured against `test/e2e/app-dir/asset-prefix-absolute`, whose\n    // one case failed on exactly that.\n    for (const assetPrefix of [\n      \"https://example.vercel.sh/custom-asset-prefix\",\n      \"//example.vercel.sh/custom-asset-prefix/\",\n    ]) {\n      const { stack, distributionProps } = setup([]);\n      new NextjsDistribution(stack, \"Distribution\", {\n        ...distributionProps,\n        assetPrefix,\n      });\n      expect(pathPatterns(stack)).toContain(\n        \"/custom-asset-prefix/_next/static*\",\n      );\n      const code = Object.values(\n        Template.fromStack(stack).findResources(\"AWS::CloudFront::Function\"),\n      )\n        .map((fn) => fn.Properties.FunctionCode as string)\n        .find((it) => it.includes(\"request.uri.slice\"));\n      expect(code).toContain('\"\" + request.uri.slice(20)');\n    }\n  });\n\n  it(\"adds no behavior for an assetPrefix that needs none\", () => {\n    // An absolute prefix with no path of its own names an origin this distribution\n    // does not serve, and a prefix equal to the basePath one is what Next.js\n    // defaults to when `basePath` is set — `_next/static*` already resolves under\n    // it, and a duplicate pattern would make CloudFront reject the distribution.\n    for (const [assetPrefix, basePath] of [\n      [\"https://cdn.example.com\", undefined],\n      [\"https://cdn.example.com/\", undefined],\n      [\"//cdn.example.com\", undefined],\n      [\"/base\", \"/base\"],\n      [\"https://cdn.example.com/base\", \"/base\"],\n      [\"\", undefined],\n    ] as const) {\n      const { stack, distributionProps } = setup([], { basePath });\n      new NextjsDistribution(stack, \"Distribution\", {\n        ...distributionProps,\n        assetPrefix,\n      });\n      const patterns = pathPatterns(stack);\n      expect(patterns.filter((p) => p.includes(\"_next/static\"))).toHaveLength(\n        1,\n      );\n      // The x-forwarded-host function is always there on function compute; the\n      // rewrite one should not be.\n      const codes = Object.values(\n        Template.fromStack(stack).findResources(\"AWS::CloudFront::Function\"),\n      ).map((fn) => fn.Properties.FunctionCode as string);\n      expect(codes.some((it) => it.includes(\"request.uri.slice\"))).toBe(false);\n    }\n  });\n\n  it(\"counts the assetPrefix behavior against the budget\", () => {\n    const { stack, distributionProps } = setup([], {\n      publicDirEntries: Array.from({ length: 22 }, (_, i) => `file${i}.txt`),\n    });\n    // 3 fixed + 22 public = 25, exactly the limit; the assetPrefix one is the\n    // 26th, and a limit error that did not count it would come as a deploy\n    // failure instead.\n    expect(\n      () =>\n        new NextjsDistribution(stack, \"Distribution\", {\n          ...distributionProps,\n          assetPrefix: \"/cdn\",\n          maxCacheBehaviors: 25,\n        }),\n    ).toThrow(/26 CloudFront cache behaviors.*4 used by cdk-nextjs itself/s);\n  });\n\n  it(\"does not cache a dynamic response that sends no Cache-Control\", () => {\n    // CDK's `CachePolicy` default is a day, which cached every route handler\n    // without a `Cache-Control` - `/api/echo` in app-playground - for 24 hours.\n    const { stack, distributionProps } = setup([]);\n    new NextjsDistribution(stack, \"Distribution\", distributionProps);\n    Template.fromStack(stack).hasResourceProperties(\n      \"AWS::CloudFront::CachePolicy\",\n      {\n        CachePolicyConfig: Match.objectLike({\n          Comment: Match.stringLikeRegexp(\"Dynamic\"),\n          DefaultTTL: 0,\n          MinTTL: 0,\n        }),\n      },\n    );\n  });\n\n  it(\"wildcards a public/ name CloudFront cannot spell\", () => {\n    // `public/hello world.jpg` is a valid Next.js asset, but a space cannot appear\n    // in a path pattern, so cdk-nextjs threw at synth and the app could not be\n    // deployed at all. CloudFront matches the *decoded* path, and `?` matches one\n    // byte of it, so one `?` per UTF-8 byte is the narrowest pattern that\n    // matches. Not one per percent-encoded character: `hello???world.jpg`\n    // deploys and then never matches, which is a 404 rather than a synth error.\n    const { stack, distributionProps } = setup([], {\n      publicDirEntries: [\"hello world.jpg\", \"äöüščří.png\", \"favicon.ico\"],\n    });\n    new NextjsDistribution(stack, \"Distribution\", distributionProps);\n    expect(pathPatterns(stack)).toEqual(\n      expect.arrayContaining([\n        \"hello?world.jpg\",\n        // 7 characters, 2 UTF-8 bytes each.\n        `${\"?\".repeat(14)}.png`,\n        \"favicon.ico\",\n      ]),\n    );\n  });\n\n  it(\"wildcards a public/ directory name the same way\", () => {\n    const { stack, distributionProps } = setup([]);\n    new NextjsDistribution(stack, \"Distribution\", {\n      ...distributionProps,\n      publicDirEntries: [{ name: \"my images\", isDirectory: true }],\n    });\n    expect(pathPatterns(stack)).toContain(\"my?images/*\");\n  });\n\n  it(\"rejects a public/ name too long to express as a path pattern\", () => {\n    const { stack, distributionProps } = setup([], {\n      publicDirEntries: [`${\"ä\".repeat(130)}.png`],\n    });\n    expect(\n      () => new NextjsDistribution(stack, \"Distribution\", distributionProps),\n    ).toThrow(/needs a 264-character CloudFront path pattern/);\n  });\n\n  it(\"skips a public/ entry whose pattern would be wildcards alone\", () => {\n    // `фото/` is `????????/*`, which matches any 8-byte first segment. Public\n    // behaviors are added ahead of the compute ones, so `/products/42` would go\n    // to S3 and 403. The entry gets no behavior and a warning instead.\n    const { stack, distributionProps } = setup([]);\n    new NextjsDistribution(stack, \"Distribution\", {\n      ...distributionProps,\n      publicDirEntries: [\n        { name: \"фото\", isDirectory: true },\n        { name: \"图\", isDirectory: false },\n        { name: \"фото-1\", isDirectory: true },\n      ],\n    });\n    const patterns = pathPatterns(stack);\n    expect(patterns).not.toContain(`${\"?\".repeat(8)}/*`);\n    expect(patterns).not.toContain(\"???\");\n    // One literal character keeps a pattern narrow enough to keep.\n    expect(patterns).toContain(`${\"?\".repeat(8)}-1/*`);\n    Annotations.fromStack(stack).hasWarning(\n      \"*\",\n      Match.stringLikeRegexp('\"фото\", \"图\"'),\n    );\n  });\n\n  it(\"does not count a skipped public/ entry against the budget\", () => {\n    const { stack, distributionProps } = setup([], {\n      publicDirEntries: [\n        ...Array.from({ length: 22 }, (_, i) => `file${i}.txt`),\n        \"图\",\n      ],\n    });\n    // 3 fixed + 22 = 25, exactly the limit; the skipped entry adds nothing.\n    expect(\n      () =>\n        new NextjsDistribution(stack, \"Distribution\", {\n          ...distributionProps,\n          maxCacheBehaviors: 25,\n        }),\n    ).not.toThrow();\n  });\n\n  it(\"checks the length of the final pattern, basePath and /* included\", () => {\n    // 83 three-byte characters + \".pdf\" is a 253-character pattern on its own,\n    // under the limit; `/docs/` in front takes it to 259, which CloudFront\n    // rejects at deploy.\n    const name = `${\"图\".repeat(83)}.pdf`;\n    const { stack, distributionProps } = setup([], {\n      publicDirEntries: [name],\n    });\n    expect(\n      () =>\n        new NextjsDistribution(stack, \"Distribution\", {\n          ...distributionProps,\n          basePath: \"/docs\",\n        }),\n    ).toThrow(/needs a 259-character CloudFront path pattern/);\n\n    const { stack: dirStack, distributionProps: dirProps } = setup([]);\n    expect(\n      () =>\n        new NextjsDistribution(dirStack, \"Distribution\", {\n          ...dirProps,\n          // 254 characters, under the limit until the `/*`.\n          publicDirEntries: [\n            { name: `ab${\"图\".repeat(84)}`, isDirectory: true },\n          ],\n        }),\n    ).toThrow(/needs a 256-character/);\n  });\n\n  it(\"drops the cache key when an override disables dynamic caching\", () => {\n    // CloudFront rejects a policy that caches nothing but keys on headers. CDK\n    // used to raise `maxTtl: 0` to the day-long default, so the override\n    // deployed; with a default of 0 it is honored, and must stay deployable.\n    const { stack, distributionProps } = setup([]);\n    new NextjsDistribution(stack, \"Distribution\", {\n      ...distributionProps,\n      overrides: {\n        dynamicCachePolicyProps: { maxTtl: Duration.seconds(0) },\n      },\n    });\n    Template.fromStack(stack).hasResourceProperties(\n      \"AWS::CloudFront::CachePolicy\",\n      {\n        CachePolicyConfig: Match.objectLike({\n          Comment: Match.stringLikeRegexp(\"Dynamic\"),\n          DefaultTTL: 0,\n          MaxTTL: 0,\n          MinTTL: 0,\n          ParametersInCacheKeyAndForwardedToOrigin: {\n            CookiesConfig: { CookieBehavior: \"none\" },\n            EnableAcceptEncodingBrotli: false,\n            EnableAcceptEncodingGzip: false,\n            HeadersConfig: { HeaderBehavior: \"none\" },\n            QueryStringsConfig: { QueryStringBehavior: \"none\" },\n          },\n        }),\n      },\n    );\n  });\n\n  it(\"keeps the cache key when a zero maxTtl is raised by another TTL\", () => {\n    // CDK raises `maxTtl` to `defaultTtl`, so this policy caches for an hour.\n    // Dropping the key for it would serve one viewer's page to every viewer.\n    const { stack, distributionProps } = setup([]);\n    new NextjsDistribution(stack, \"Distribution\", {\n      ...distributionProps,\n      overrides: {\n        dynamicCachePolicyProps: {\n          maxTtl: Duration.seconds(0),\n          defaultTtl: Duration.hours(1),\n        },\n      },\n    });\n    Template.fromStack(stack).hasResourceProperties(\n      \"AWS::CloudFront::CachePolicy\",\n      {\n        CachePolicyConfig: Match.objectLike({\n          Comment: Match.stringLikeRegexp(\"Dynamic\"),\n          MaxTTL: 3600,\n          ParametersInCacheKeyAndForwardedToOrigin: Match.objectLike({\n            CookiesConfig: { CookieBehavior: \"all\" },\n            QueryStringsConfig: { QueryStringBehavior: \"all\" },\n          }),\n        }),\n      },\n    );\n  });\n\n  it(\"keys the dynamic cache only on headers the origin reads\", () => {\n    // `x-matched-path` is stripped by the runtime and `x-next-cache-tags` is\n    // never sent by viewers: keying on either spends a header slot and lets a\n    // client fragment the cache for nothing.\n    const { stack, distributionProps } = setup([]);\n    new NextjsDistribution(stack, \"Distribution\", distributionProps);\n    const policies = Template.fromStack(stack).findResources(\n      \"AWS::CloudFront::CachePolicy\",\n      {\n        Properties: {\n          CachePolicyConfig: { Comment: Match.stringLikeRegexp(\"Dynamic\") },\n        },\n      },\n    );\n    const [policy] = Object.values(policies);\n    const headers: string[] =\n      policy.Properties.CachePolicyConfig\n        .ParametersInCacheKeyAndForwardedToOrigin.HeadersConfig.Headers;\n    expect(headers).not.toContain(\"x-matched-path\");\n    expect(headers).not.toContain(\"x-next-cache-tags\");\n    expect(headers).toContain(\"rsc\");\n  });\n\n  it(\"rejects splitting on a deployment type that cannot route it\", () => {\n    const { stack, functionGroups, functionGroupBehaviors, distributionProps } =\n      setup([\"api\"]);\n    expect(\n      () =>\n        new NextjsDistribution(stack, \"Distribution\", {\n          ...distributionProps,\n          nextjsType: NextjsType.GLOBAL_CONTAINERS,\n          loadBalancer: undefined,\n          functionGroups,\n          functionGroupBehaviors,\n        }),\n    ).toThrow(/only supported by NextjsGlobalFunctions/);\n  });\n});\n\n/**\n * The viewer-request function, run as CloudFront would run it.\n *\n * It is authored as a string inside a TypeScript template literal, so every\n * backslash in it is escaped twice - and a regex that collapses slashes is nothing\n * but backslashes. Asserting on behavior rather than on the text is what catches an\n * escaping mistake, which a snapshot would happily record.\n */\ndescribe(\"the viewer-request CloudFront Function\", () => {\n  interface QueryValue {\n    value: string;\n    multiValue?: Array<{ value: string }>;\n  }\n  interface FunctionRequest {\n    uri: string;\n    querystring: Record<string, QueryValue>;\n    headers: Record<string, { value: string }>;\n  }\n  type FunctionResult =\n    | FunctionRequest\n    | { statusCode: number; headers: Record<string, { value: string }> };\n\n  const handler = (() => {\n    const stack = new Stack(new App(), \"FnStack\");\n    const fn = new LambdaFunction(stack, \"Fn\", {\n      code: Code.fromInline(\"exports.handler = () => {};\"),\n      handler: \"index.handler\",\n      runtime: Runtime.NODEJS_22_X,\n    });\n    new NextjsDistribution(stack, \"Distribution\", {\n      assetsBucket: new Bucket(stack, \"Assets\"),\n      functionUrl: new FunctionUrl(stack, \"Url\", {\n        function: fn,\n        authType: FunctionUrlAuthType.AWS_IAM,\n      }),\n      nextjsType: NextjsType.GLOBAL_FUNCTIONS,\n      publicDirEntries: [],\n    });\n    const functions = Template.fromStack(stack).findResources(\n      \"AWS::CloudFront::Function\",\n    );\n    const code = Object.values(functions)[0].Properties.FunctionCode as string;\n    return runInNewContext(`${code}\\nhandler`) as (event: {\n      request: FunctionRequest;\n    }) => FunctionResult;\n  })();\n\n  const send = (\n    uri: string,\n    querystring: Record<string, QueryValue> = {},\n  ): FunctionResult =>\n    handler({\n      request: { uri, querystring, headers: { host: { value: \"a.test\" } } },\n    });\n\n  const redirect = (result: FunctionResult) => ({\n    statusCode: (result as { statusCode: number }).statusCode,\n    location: result.headers.location?.value,\n  });\n\n  it.each([\n    [\"//\", \"/\"],\n    [\"///\", \"/\"],\n    [\"/foo//bar\", \"/foo/bar\"],\n    [\"/basepath//to-sv\", \"/basepath/to-sv\"],\n    [\"/a\\\\b\", \"/a/b\"],\n  ])(\"redirects %s to %s with a 308\", (uri, location) => {\n    expect(redirect(send(uri))).toEqual({ statusCode: 308, location });\n  });\n\n  it(\"keeps the query on the redirect, including repeated keys\", () => {\n    // CloudFront's shape for a repeated key: `multiValue` holds every value,\n    // the first included, and `value` repeats that first one.\n    const result = send(\"/x//y\", {\n      json: { value: \"true\" },\n      a: { value: \"1\", multiValue: [{ value: \"1\" }, { value: \"2\" }] },\n      flag: { value: \"\" },\n    });\n    expect(redirect(result).location).toBe(\"/x/y?json=true&a=1&a=2&flag\");\n  });\n\n  it(\"passes percent-encoded query values through without re-encoding\", () => {\n    // CloudFront hands the function the values still encoded, as sent.\n    const result = send(\"/x//y\", {\n      a: { value: \"%20b%26c\" },\n      p: { value: \"1+2\" },\n    });\n    expect(redirect(result).location).toBe(\"/x/y?a=%20b%26c&p=1+2\");\n  });\n\n  it(\"passes an ordinary path through with x-forwarded-host set\", () => {\n    const result = send(\"/a/b\") as FunctionRequest;\n    expect(result.uri).toBe(\"/a/b\");\n    // CloudFront rewrites `host` to the origin domain, so the app would otherwise\n    // build every absolute URL against the Function URL's hostname.\n    expect(result.headers[\"x-forwarded-host\"].value).toBe(\"a.test\");\n  });\n\n  it(\"overwrites a client-supplied x-forwarded-host\", () => {\n    // The runtime trusts this header behind the Function URL, so a viewer's\n    // own value must not survive to build redirects or origin checks.\n    const result = handler({\n      request: {\n        uri: \"/a\",\n        querystring: {},\n        headers: {\n          host: { value: \"a.test\" },\n          \"x-forwarded-host\": { value: \"evil.test\" },\n        },\n      },\n    }) as FunctionRequest;\n    expect(result.headers[\"x-forwarded-host\"].value).toBe(\"a.test\");\n  });\n});\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"nextjs-distribution.test.js","sourceRoot":"","sources":["../src/nextjs-distribution.test.ts"],"names":[],"mappings":"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","sourcesContent":["import { runInNewContext } from \"node:vm\";\nimport { App, Duration, Lazy, Stack } from \"aws-cdk-lib\";\nimport { Annotations, Match, Template } from \"aws-cdk-lib/assertions\";\nimport {\n  Function as CloudFrontFunction,\n  FunctionCode,\n  FunctionEventType,\n  KeyValueStore,\n  ResponseHeadersPolicy,\n} from \"aws-cdk-lib/aws-cloudfront\";\nimport { HttpOrigin } from \"aws-cdk-lib/aws-cloudfront-origins\";\nimport { Vpc } from \"aws-cdk-lib/aws-ec2\";\nimport { ApplicationLoadBalancer } from \"aws-cdk-lib/aws-elasticloadbalancingv2\";\nimport {\n  Code,\n  Function as LambdaFunction,\n  FunctionUrl,\n  FunctionUrlAuthType,\n  Runtime,\n} from \"aws-cdk-lib/aws-lambda\";\nimport { Bucket } from \"aws-cdk-lib/aws-s3\";\nimport { pathPatternsFor } from \"./adapter/function-groups\";\nimport { NextjsType } from \"./constants\";\nimport {\n  NextjsDistribution,\n  NextjsDistributionFunctionGroup,\n  NextjsDistributionOverrides,\n} from \"./nextjs-distribution\";\n\n/**\n * `functionGroups` routing at the edge. `NextjsBuild` is deliberately not\n * involved: which behaviors a group gets, and in what order, is the adapter's\n * decision (`function-groups.test.ts`), so these pass the behaviors in directly\n * and assert on what the distribution does with them.\n */\ndescribe(\"NextjsDistribution function group behaviors\", () => {\n  const setup = (\n    groupNames: string[],\n    props: {\n      routesFor?: (name: string) => string[];\n      publicDirEntries?: string[];\n      basePath?: string;\n      trailingSlash?: boolean;\n    } = {},\n  ) => {\n    const stack = new Stack(new App(), \"TestStack\");\n    const functionGroups: NextjsDistributionFunctionGroup[] = groupNames.map(\n      (name) => {\n        const fn = new LambdaFunction(stack, `Fn${name}`, {\n          code: Code.fromInline(\"exports.handler = () => {};\"),\n          handler: \"index.handler\",\n          runtime: Runtime.NODEJS_22_X,\n        });\n        return {\n          name,\n          functionUrl: new FunctionUrl(stack, `Url${name}`, {\n            function: fn,\n            authType: FunctionUrlAuthType.AWS_IAM,\n          }),\n        };\n      },\n    );\n    // In the order given: the build's list is already most specific first.\n    const functionGroupBehaviors = groupNames.flatMap((group) =>\n      (props.routesFor?.(group) ?? [`/${group}/**`]).flatMap((route) =>\n        pathPatternsFor(route, {\n          hasDataRoutes: false,\n          trailingSlash: props.trailingSlash,\n        }).map((pattern) => ({ group, route, pattern })),\n      ),\n    );\n    const defaultFn = new LambdaFunction(stack, \"FnDefault\", {\n      code: Code.fromInline(\"exports.handler = () => {};\"),\n      handler: \"index.handler\",\n      runtime: Runtime.NODEJS_22_X,\n    });\n    return {\n      stack,\n      functionGroups,\n      functionGroupBehaviors,\n      distributionProps: {\n        assetsBucket: new Bucket(stack, \"Assets\"),\n        basePath: props.basePath,\n        functionUrl: new FunctionUrl(stack, \"UrlDefault\", {\n          function: defaultFn,\n          authType: FunctionUrlAuthType.AWS_IAM,\n        }),\n        nextjsType: NextjsType.GLOBAL_FUNCTIONS,\n        publicDirEntries: (props.publicDirEntries ?? []).map((name) => ({\n          name,\n          isDirectory: false,\n        })),\n      },\n    };\n  };\n\n  const pathPatterns = (stack: Stack) => {\n    const distributions = Template.fromStack(stack).findResources(\n      \"AWS::CloudFront::Distribution\",\n    );\n    const config =\n      Object.values(distributions)[0].Properties.DistributionConfig;\n    return (config.CacheBehaviors as Array<{ PathPattern: string }>).map(\n      (behavior) => behavior.PathPattern,\n    );\n  };\n\n  it(\"adds nothing extra when there are no groups\", () => {\n    const { stack, distributionProps } = setup([]);\n    new NextjsDistribution(stack, \"Distribution\", distributionProps);\n    expect(pathPatterns(stack)).toEqual([\"_next/static*\", \"_next/image*\"]);\n  });\n\n  describe(\"service workers\", () => {\n    const serviceWorkerPolicy = (stack: Stack) => {\n      const config = Object.values(\n        Template.fromStack(stack).findResources(\n          \"AWS::CloudFront::Distribution\",\n        ),\n      )[0].Properties.DistributionConfig;\n      const behavior = (\n        config.CacheBehaviors as Array<{\n          PathPattern: string;\n          ResponseHeadersPolicyId: { Ref: string };\n        }>\n      ).find(({ PathPattern }) => PathPattern.includes(\"service-worker\"))!;\n      const policies = Template.fromStack(stack).findResources(\n        \"AWS::CloudFront::ResponseHeadersPolicy\",\n      );\n      return policies[behavior.ResponseHeadersPolicyId.Ref].Properties\n        .ResponseHeadersPolicyConfig;\n    };\n\n    it(\"sends Service-Worker-Allowed from a behavior ahead of _next/static*\", () => {\n      // CloudFront stops at the first match, so after `_next/static*` it would\n      // never be reached.\n      const { stack, distributionProps } = setup([]);\n      new NextjsDistribution(stack, \"Distribution\", {\n        ...distributionProps,\n        serviceWorkerAllowed: \"/\",\n      });\n      expect(pathPatterns(stack)).toEqual([\n        \"_next/static/service-worker/*\",\n        \"_next/static*\",\n        \"_next/image*\",\n      ]);\n      const policy = serviceWorkerPolicy(stack);\n      expect(policy.CustomHeadersConfig.Items).toEqual([\n        { Header: \"Service-Worker-Allowed\", Value: \"/\", Override: true },\n      ]);\n      // The security headers the other static behaviors send.\n      expect(\n        policy.SecurityHeadersConfig.StrictTransportSecurity,\n      ).toBeDefined();\n    });\n\n    it(\"prefixes the pattern with basePath\", () => {\n      const { stack, distributionProps } = setup([], { basePath: \"/base\" });\n      new NextjsDistribution(stack, \"Distribution\", {\n        ...distributionProps,\n        serviceWorkerAllowed: \"/base\",\n      });\n      expect(pathPatterns(stack)[0]).toBe(\n        \"/base/_next/static/service-worker/*\",\n      );\n      expect(serviceWorkerPolicy(stack).CustomHeadersConfig.Items).toEqual([\n        { Header: \"Service-Worker-Allowed\", Value: \"/base\", Override: true },\n      ]);\n    });\n\n    it(\"adds no behavior without service workers\", () => {\n      const { stack, distributionProps } = setup([]);\n      new NextjsDistribution(stack, \"Distribution\", distributionProps);\n      expect(pathPatterns(stack)).not.toContain(\n        \"_next/static/service-worker/*\",\n      );\n    });\n\n    it(\"keeps staticResponseHeadersPolicyProps, its custom headers included\", () => {\n      const { stack, distributionProps } = setup([]);\n      new NextjsDistribution(stack, \"Distribution\", {\n        ...distributionProps,\n        serviceWorkerAllowed: \"/\",\n        overrides: {\n          staticResponseHeadersPolicyProps: {\n            responseHeadersPolicyName: \"static\",\n            customHeadersBehavior: {\n              customHeaders: [{ header: \"X-Team\", value: \"a\", override: true }],\n            },\n          },\n        },\n      });\n      const policy = serviceWorkerPolicy(stack);\n      // Names are unique per account, so it can't share the static policy's.\n      expect(policy.Name).toBe(\"static-sw\");\n      expect(policy.CustomHeadersConfig.Items).toEqual([\n        { Header: \"X-Team\", Value: \"a\", Override: true },\n        { Header: \"Service-Worker-Allowed\", Value: \"/\", Override: true },\n      ]);\n    });\n\n    it(\"keeps a suffixed policy name within CloudFront's 128 characters\", () => {\n      const { stack, distributionProps } = setup([]);\n      new NextjsDistribution(stack, \"Distribution\", {\n        ...distributionProps,\n        serviceWorkerAllowed: \"/\",\n        overrides: {\n          staticResponseHeadersPolicyProps: {\n            responseHeadersPolicyName: \"a\".repeat(128),\n          },\n        },\n      });\n      expect(serviceWorkerPolicy(stack).Name).toBe(`${\"a\".repeat(125)}-sw`);\n    });\n\n    it(\"keeps a Service-Worker-Allowed the static override sets\", () => {\n      const { stack, distributionProps } = setup([]);\n      new NextjsDistribution(stack, \"Distribution\", {\n        ...distributionProps,\n        serviceWorkerAllowed: \"/\",\n        overrides: {\n          staticResponseHeadersPolicyProps: {\n            customHeadersBehavior: {\n              customHeaders: [\n                {\n                  header: \"service-worker-allowed\",\n                  value: \"/app\",\n                  override: true,\n                },\n              ],\n            },\n          },\n        },\n      });\n      expect(serviceWorkerPolicy(stack).CustomHeadersConfig.Items).toEqual([\n        { Header: \"service-worker-allowed\", Value: \"/app\", Override: true },\n      ]);\n    });\n\n    it(\"warns and uses a replaced static policy as it is\", () => {\n      const { stack, distributionProps } = setup([]);\n      const distribution = new NextjsDistribution(stack, \"Distribution\", {\n        ...distributionProps,\n        serviceWorkerAllowed: \"/\",\n        overrides: {\n          staticBehaviorOptions: {\n            responseHeadersPolicy:\n              ResponseHeadersPolicy.fromResponseHeadersPolicyId(\n                stack,\n                \"Custom\",\n                \"custom-policy\",\n              ),\n          },\n        },\n      });\n      Annotations.fromStack(stack).hasWarning(\n        `/${distribution.node.path}`,\n        Match.stringLikeRegexp(\"Service-Worker-Allowed\"),\n      );\n      const config = Object.values(\n        Template.fromStack(stack).findResources(\n          \"AWS::CloudFront::Distribution\",\n        ),\n      )[0].Properties.DistributionConfig;\n      expect(config.CacheBehaviors[0]).toMatchObject({\n        PathPattern: \"_next/static/service-worker/*\",\n        ResponseHeadersPolicyId: \"custom-policy\",\n      });\n    });\n\n    it(\"counts its behavior against the budget\", () => {\n      const { stack, distributionProps } = setup([], {\n        publicDirEntries: Array.from({ length: 72 }, (_, i) => `f${i}`),\n      });\n      // 3 fixed + 72 public = 75 fits; the service worker behavior makes 76.\n      expect(\n        () =>\n          new NextjsDistribution(stack, \"Distribution\", {\n            ...distributionProps,\n            serviceWorkerAllowed: \"/\",\n          }),\n      ).toThrow(/needs 76 CloudFront cache behaviors/);\n    });\n  });\n\n  it(\"lets the OAC principal list the bucket so a missing asset is a 404\", () => {\n    const { stack, distributionProps } = setup([]);\n    new NextjsDistribution(stack, \"Distribution\", distributionProps);\n    Template.fromStack(stack).hasResourceProperties(\"AWS::S3::BucketPolicy\", {\n      PolicyDocument: {\n        Statement: Match.arrayWith([\n          Match.objectLike({\n            Action: [\"s3:GetObject\", \"s3:ListBucket\"],\n            Principal: { Service: \"cloudfront.amazonaws.com\" },\n          }),\n        ]),\n      },\n    });\n  });\n\n  it(\"adds group behaviors in the build's order, after the image behavior\", () => {\n    // CloudFront stops at the first matching behavior, so `api/*` ahead of\n    // `api/reports/*` would send every report request to the wrong function.\n    // The build sorted them when it checked them; re-sorting here could only\n    // disagree with that.\n    const { stack, functionGroups, functionGroupBehaviors, distributionProps } =\n      setup([\"reports\", \"api\"], {\n        routesFor: (name) =>\n          name === \"api\" ? [\"/api/**\"] : [\"/api/reports/**\"],\n      });\n    new NextjsDistribution(stack, \"Distribution\", {\n      ...distributionProps,\n      functionGroups,\n      functionGroupBehaviors,\n    });\n    expect(pathPatterns(stack)).toEqual([\n      \"_next/static*\",\n      \"_next/image*\",\n      \"api/reports/*\",\n      \"api/*\",\n    ]);\n  });\n\n  it(\"keeps the two slash variants distinct under a basePath\", () => {\n    // `getPathPattern` used to join through a helper that strips trailing\n    // slashes, so `pricing` and `pricing/` both became `/base/pricing`: two\n    // behaviors with the same path pattern, which CloudFront rejects at deploy\n    // with no hint that `trailingSlash` is what produced the duplicate.\n    const { stack, functionGroups, functionGroupBehaviors, distributionProps } =\n      setup([\"mkt\"], {\n        routesFor: () => [\"/pricing\"],\n        basePath: \"/base\",\n        trailingSlash: true,\n      });\n    new NextjsDistribution(stack, \"Distribution\", {\n      ...distributionProps,\n      functionGroups,\n      functionGroupBehaviors,\n    });\n    const patterns = pathPatterns(stack);\n    expect(patterns).toContain(\"/base/pricing\");\n    expect(patterns).toContain(\"/base/pricing/\");\n  });\n\n  it(\"counts the basePath behaviors against the budget\", () => {\n    const { stack, distributionProps } = setup([], {\n      basePath: \"/base\",\n      publicDirEntries: Array.from({ length: 21 }, (_, i) => `file${i}.txt`),\n    });\n    // 3 fixed + the 2 a basePath adds to stand in for the default behavior + 21\n    // public = 26. Counting only the 3 reported 24 and let the synth through, so\n    // the limit arrived as a CloudFront deploy failure.\n    expect(\n      () =>\n        new NextjsDistribution(stack, \"Distribution\", {\n          ...distributionProps,\n          maxCacheBehaviors: 25,\n        }),\n    ).toThrow(/26 CloudFront cache behaviors.*5 used by cdk-nextjs itself/s);\n  });\n\n  it(\"defaults the budget to CloudFront's quota of 75\", () => {\n    // The hard-coded 25 predated the quota's increase to 75.\n    const { stack, distributionProps } = setup([], {\n      publicDirEntries: Array.from({ length: 72 }, (_, i) => `file${i}.txt`),\n    });\n    expect(\n      () => new NextjsDistribution(stack, \"Distribution\", distributionProps),\n    ).not.toThrow();\n    const { stack: over, distributionProps: overProps } = setup([], {\n      publicDirEntries: Array.from({ length: 73 }, (_, i) => `file${i}.txt`),\n    });\n    expect(\n      () => new NextjsDistribution(over, \"Distribution\", overProps),\n    ).toThrow(\n      /76 CloudFront cache behaviors, over the limit of 75.*set `maxCacheBehaviors`/s,\n    );\n  });\n\n  it(\"honors a raised maxCacheBehaviors\", () => {\n    const { stack, distributionProps } = setup([], {\n      publicDirEntries: Array.from({ length: 97 }, (_, i) => `file${i}.txt`),\n    });\n    expect(\n      () =>\n        new NextjsDistribution(stack, \"Distribution\", {\n          ...distributionProps,\n          maxCacheBehaviors: 100,\n        }),\n    ).not.toThrow();\n  });\n\n  it(\"does not count basePath behaviors for a basePath of /\", () => {\n    // `basePath: \"/\"` normalizes to no basePath and adds no behaviors, so\n    // counting 2 for it could reject an app that is under the limit.\n    const { stack, distributionProps } = setup([], {\n      basePath: \"/\",\n      publicDirEntries: Array.from({ length: 22 }, (_, i) => `file${i}.txt`),\n    });\n    expect(\n      () =>\n        new NextjsDistribution(stack, \"Distribution\", {\n          ...distributionProps,\n          maxCacheBehaviors: 25,\n        }),\n    ).not.toThrow();\n  });\n\n  it(\"rejects a behavior for a group it was not given\", () => {\n    const { stack, functionGroupBehaviors, distributionProps } = setup([\"api\"]);\n    expect(\n      () =>\n        new NextjsDistribution(stack, \"Distribution\", {\n          ...distributionProps,\n          functionGroupBehaviors,\n        }),\n    ).toThrow(\n      /routes to function group \"api\", which is not in `functionGroups`/,\n    );\n  });\n\n  it(\"points each group's behaviors at that group's own origin\", () => {\n    const { stack, functionGroups, functionGroupBehaviors, distributionProps } =\n      setup([\"api\"], {\n        routesFor: () => [\"/api/**\", \"/health\"],\n      });\n    new NextjsDistribution(stack, \"Distribution\", {\n      ...distributionProps,\n      functionGroups,\n      functionGroupBehaviors,\n    });\n    const distributions = Template.fromStack(stack).findResources(\n      \"AWS::CloudFront::Distribution\",\n    );\n    const config =\n      Object.values(distributions)[0].Properties.DistributionConfig;\n    const behaviors = config.CacheBehaviors as Array<{\n      PathPattern: string;\n      TargetOriginId: string;\n    }>;\n    const groupOrigins = new Set(\n      behaviors\n        .filter((behavior) =>\n          [\"api/*\", \"health\"].includes(behavior.PathPattern),\n        )\n        .map((behavior) => behavior.TargetOriginId),\n    );\n    // One origin, shared by both of the group's patterns, and not the default's.\n    expect(groupOrigins.size).toBe(1);\n    expect(groupOrigins).not.toContain(\n      config.DefaultCacheBehavior.TargetOriginId,\n    );\n  });\n\n  it(\"prefixes group patterns with basePath\", () => {\n    const { stack, functionGroups, functionGroupBehaviors, distributionProps } =\n      setup([\"api\"], {\n        routesFor: () => [\"/api/**\"],\n        basePath: \"/base\",\n      });\n    new NextjsDistribution(stack, \"Distribution\", {\n      ...distributionProps,\n      functionGroups,\n      functionGroupBehaviors,\n    });\n    expect(pathPatterns(stack)).toContain(\"/base/api/*\");\n  });\n\n  it(\"names every claim on the behavior budget when it is exceeded\", () => {\n    const { stack, functionGroups, functionGroupBehaviors, distributionProps } =\n      setup([\"api\"], {\n        routesFor: () => [\"/api/**\"],\n        publicDirEntries: Array.from({ length: 22 }, (_, i) => `file${i}.txt`),\n      });\n    expect(\n      () =>\n        new NextjsDistribution(stack, \"Distribution\", {\n          ...distributionProps,\n          functionGroups,\n          functionGroupBehaviors,\n          maxCacheBehaviors: 25,\n        }),\n    ).toThrow(\n      /26 CloudFront cache behaviors.*1 for `functionGroups` patterns/s,\n    );\n  });\n\n  it(\"rejects a group pattern that duplicates a public/ directory's\", () => {\n    // `public/docs/` and `/docs/**` both deploy as `docs/*`: the synth\n    // succeeded and CloudFront rejected the deploy.\n    const { stack, functionGroups, functionGroupBehaviors, distributionProps } =\n      setup([\"docs\"]);\n    expect(\n      () =>\n        new NextjsDistribution(stack, \"Distribution\", {\n          ...distributionProps,\n          functionGroups,\n          functionGroupBehaviors,\n          publicDirEntries: [{ name: \"docs\", isDirectory: true }],\n        }),\n    ).toThrow(\n      /pattern \"\\/docs\\/\\*\\*\" \\(group \"docs\"\\) deploys as the path pattern \"docs\\/\\*\", which a top-level public\\/ entry already uses/,\n    );\n  });\n\n  it(\"rejects a group pattern a public/ directory's behavior would shadow\", () => {\n    // `docs/*` is added first, so `docs/guide/*` never matches.\n    const { stack, functionGroups, functionGroupBehaviors, distributionProps } =\n      setup([\"guide\"], {\n        routesFor: () => [\"/docs/guide/**\"],\n      });\n    expect(\n      () =>\n        new NextjsDistribution(stack, \"Distribution\", {\n          ...distributionProps,\n          functionGroups,\n          functionGroupBehaviors,\n          publicDirEntries: [{ name: \"docs\", isDirectory: true }],\n        }),\n    ).toThrow(/public\\/ entry behind \"docs\\/\\*\" is matched first/);\n  });\n\n  it(\"rejects an exact group pattern equal to a public/ file's, basePath included\", () => {\n    const { stack, functionGroups, functionGroupBehaviors, distributionProps } =\n      setup([\"mkt\"], {\n        routesFor: () => [\"/robots.txt\"],\n        basePath: \"/base\",\n      });\n    expect(\n      () =>\n        new NextjsDistribution(stack, \"Distribution\", {\n          ...distributionProps,\n          functionGroups,\n          functionGroupBehaviors,\n          publicDirEntries: [{ name: \"robots.txt\", isDirectory: false }],\n        }),\n    ).toThrow(/deploys as the path pattern \"\\/base\\/robots\\.txt\"/);\n  });\n\n  it(\"allows a group pattern beside a public/ entry it does not overlap\", () => {\n    // `/docs` exact is not under `docs/*`, and `docs/*` does not match `/docs`.\n    const { stack, functionGroups, functionGroupBehaviors, distributionProps } =\n      setup([\"docs\"], {\n        routesFor: () => [\"/docs\"],\n      });\n    new NextjsDistribution(stack, \"Distribution\", {\n      ...distributionProps,\n      functionGroups,\n      functionGroupBehaviors,\n      publicDirEntries: [{ name: \"docs\", isDirectory: true }],\n    });\n    expect(pathPatterns(stack)).toEqual(\n      expect.arrayContaining([\"docs/*\", \"docs\"]),\n    );\n  });\n\n  it(\"serves bundles under a path-style assetPrefix, rewriting the prefix away\", () => {\n    // Next.js emits `<assetPrefix>/_next/static/...` for every bundle while the\n    // objects keep their unprefixed S3 keys, so without a behavior of its own the\n    // request falls through to the compute origin and 404s — the deployment\n    // package carries no `.next/static`. Measured against\n    // `test/e2e/app-dir/asset-prefix`, where 2 of 7 cases failed on exactly that.\n    const { stack, distributionProps } = setup([]);\n    new NextjsDistribution(stack, \"Distribution\", {\n      ...distributionProps,\n      assetPrefix: \"/custom-asset-prefix\",\n    });\n    // Ahead of the bare `_next/static*` in nothing but list position; the two\n    // patterns cannot both match one request, so order does not matter here.\n    expect(pathPatterns(stack)).toEqual([\n      \"_next/static*\",\n      \"/custom-asset-prefix/_next/static*\",\n      \"_next/image*\",\n    ]);\n    const fns = Template.fromStack(stack).findResources(\n      \"AWS::CloudFront::Function\",\n    );\n    const code = Object.values(fns)\n      .map((fn) => fn.Properties.FunctionCode as string)\n      .find((it) => it.includes(\"request.uri.slice\"));\n    // `\"/custom-asset-prefix\".length`, so `/custom-asset-prefix/_next/static/x`\n    // reaches S3 as `_next/static/x`.\n    expect(code).toContain('\"\" + request.uri.slice(20)');\n  });\n\n  it(\"refuses an assetPrefix when an override already claims VIEWER_REQUEST\", () => {\n    // CloudFront permits one function per event type per behavior, so the\n    // rewrite and the override cannot coexist: the stack synthed cleanly and was\n    // rejected at deploy, naming neither the override nor `assetPrefix`.\n    const { stack, distributionProps } = setup([]);\n    expect(\n      () =>\n        new NextjsDistribution(stack, \"Distribution\", {\n          ...distributionProps,\n          assetPrefix: \"/cdn\",\n          overrides: {\n            staticBehaviorOptions: {\n              functionAssociations: [\n                {\n                  eventType: FunctionEventType.VIEWER_REQUEST,\n                  function: new CloudFrontFunction(stack, \"UserFn\", {\n                    code: FunctionCode.fromInline(\n                      \"function handler(event) { return event.request; }\",\n                    ),\n                  }),\n                },\n              ],\n            },\n          },\n        }),\n    ).toThrow(\n      /associates a CloudFront function with viewer-request, but serving `assetPrefix`/,\n    );\n  });\n\n  const userFn = (stack: Stack, eventType: FunctionEventType) => ({\n    eventType,\n    function: new CloudFrontFunction(stack, `UserFn${eventType}`, {\n      code: FunctionCode.fromInline(\n        \"function handler(event) { return event.request || event.response; }\",\n      ),\n    }),\n  });\n\n  it.each([\"dynamicBehaviorOptions\", \"imageBehaviorOptions\"] as const)(\n    \"refuses a %s override that would replace the x-forwarded-host function\",\n    (overrideName) => {\n      // The runtime trusts `x-forwarded-host` on Function URL events because\n      // this function overwrites it; replaced, a viewer's own header reaches it.\n      const { stack, distributionProps } = setup([]);\n      expect(\n        () =>\n          new NextjsDistribution(stack, \"Distribution\", {\n            ...distributionProps,\n            overrides: {\n              [overrideName]: {\n                functionAssociations: [\n                  userFn(stack, FunctionEventType.VIEWER_REQUEST),\n                ],\n              },\n            },\n          }),\n      ).toThrow(\n        new RegExp(`overrides\\\\.${overrideName}\\\\.functionAssociations`),\n      );\n    },\n  );\n\n  it(\"keeps the x-forwarded-host function next to an override's other associations\", () => {\n    const { stack, distributionProps } = setup([]);\n    new NextjsDistribution(stack, \"Distribution\", {\n      ...distributionProps,\n      overrides: {\n        dynamicBehaviorOptions: {\n          functionAssociations: [\n            userFn(stack, FunctionEventType.VIEWER_RESPONSE),\n          ],\n        },\n      },\n    });\n    const config = Object.values(\n      Template.fromStack(stack).findResources(\"AWS::CloudFront::Distribution\"),\n    )[0].Properties.DistributionConfig;\n    const eventTypes = (\n      config.DefaultCacheBehavior.FunctionAssociations as Array<{\n        EventType: string;\n      }>\n    ).map((association) => association.EventType);\n    expect(eventTypes.sort()).toEqual([\"viewer-request\", \"viewer-response\"]);\n  });\n\n  it(\"rewrites an assetPrefix back onto the basePath S3 keys\", () => {\n    const { stack, distributionProps } = setup([], { basePath: \"/base\" });\n    new NextjsDistribution(stack, \"Distribution\", {\n      ...distributionProps,\n      assetPrefix: \"/cdn\",\n    });\n    expect(pathPatterns(stack)).toContain(\"/cdn/_next/static*\");\n    const fns = Template.fromStack(stack).findResources(\n      \"AWS::CloudFront::Function\",\n    );\n    const code = Object.values(fns)\n      .map((fn) => fn.Properties.FunctionCode as string)\n      .find((it) => it.includes(\"request.uri.slice\"));\n    // The objects are at `base/_next/static/...`: `assetPrefix` replaces the\n    // `basePath` prefix in the URL, so the rewrite has to put it back.\n    expect(code).toContain('\"/base\" + request.uri.slice(4)');\n  });\n\n  it(\"serves bundles under the path an absolute assetPrefix carries\", () => {\n    // `next build` compiles a `/custom-asset-prefix/_next/:path+ → /_next/:path+`\n    // rewrite of its own for an absolute prefix with a path, so `next start` serves\n    // every bundle under that path as well. A CDN fronting this distribution there\n    // gets the same request, and without a behavior it reaches the compute origin\n    // and 404s. Measured against `test/e2e/app-dir/asset-prefix-absolute`, whose\n    // one case failed on exactly that.\n    for (const assetPrefix of [\n      \"https://example.vercel.sh/custom-asset-prefix\",\n      \"//example.vercel.sh/custom-asset-prefix/\",\n    ]) {\n      const { stack, distributionProps } = setup([]);\n      new NextjsDistribution(stack, \"Distribution\", {\n        ...distributionProps,\n        assetPrefix,\n      });\n      expect(pathPatterns(stack)).toContain(\n        \"/custom-asset-prefix/_next/static*\",\n      );\n      const code = Object.values(\n        Template.fromStack(stack).findResources(\"AWS::CloudFront::Function\"),\n      )\n        .map((fn) => fn.Properties.FunctionCode as string)\n        .find((it) => it.includes(\"request.uri.slice\"));\n      expect(code).toContain('\"\" + request.uri.slice(20)');\n    }\n  });\n\n  it(\"adds no behavior for an assetPrefix that needs none\", () => {\n    // An absolute prefix with no path of its own names an origin this distribution\n    // does not serve, and a prefix equal to the basePath one is what Next.js\n    // defaults to when `basePath` is set — `_next/static*` already resolves under\n    // it, and a duplicate pattern would make CloudFront reject the distribution.\n    for (const [assetPrefix, basePath] of [\n      [\"https://cdn.example.com\", undefined],\n      [\"https://cdn.example.com/\", undefined],\n      [\"//cdn.example.com\", undefined],\n      [\"/base\", \"/base\"],\n      [\"https://cdn.example.com/base\", \"/base\"],\n      [\"\", undefined],\n    ] as const) {\n      const { stack, distributionProps } = setup([], { basePath });\n      new NextjsDistribution(stack, \"Distribution\", {\n        ...distributionProps,\n        assetPrefix,\n      });\n      const patterns = pathPatterns(stack);\n      expect(patterns.filter((p) => p.includes(\"_next/static\"))).toHaveLength(\n        1,\n      );\n      // The x-forwarded-host function is always there on function compute; the\n      // rewrite one should not be.\n      const codes = Object.values(\n        Template.fromStack(stack).findResources(\"AWS::CloudFront::Function\"),\n      ).map((fn) => fn.Properties.FunctionCode as string);\n      expect(codes.some((it) => it.includes(\"request.uri.slice\"))).toBe(false);\n    }\n  });\n\n  it(\"counts the assetPrefix behavior against the budget\", () => {\n    const { stack, distributionProps } = setup([], {\n      publicDirEntries: Array.from({ length: 22 }, (_, i) => `file${i}.txt`),\n    });\n    // 3 fixed + 22 public = 25, exactly the limit; the assetPrefix one is the\n    // 26th, and a limit error that did not count it would come as a deploy\n    // failure instead.\n    expect(\n      () =>\n        new NextjsDistribution(stack, \"Distribution\", {\n          ...distributionProps,\n          assetPrefix: \"/cdn\",\n          maxCacheBehaviors: 25,\n        }),\n    ).toThrow(/26 CloudFront cache behaviors.*4 used by cdk-nextjs itself/s);\n  });\n\n  it(\"does not cache a dynamic response that sends no Cache-Control\", () => {\n    // CDK's `CachePolicy` default is a day, which cached every route handler\n    // without a `Cache-Control` - `/api/echo` in app-playground - for 24 hours.\n    const { stack, distributionProps } = setup([]);\n    new NextjsDistribution(stack, \"Distribution\", distributionProps);\n    Template.fromStack(stack).hasResourceProperties(\n      \"AWS::CloudFront::CachePolicy\",\n      {\n        CachePolicyConfig: Match.objectLike({\n          Comment: Match.stringLikeRegexp(\"Dynamic\"),\n          DefaultTTL: 0,\n          MinTTL: 0,\n        }),\n      },\n    );\n  });\n\n  it(\"wildcards a public/ name CloudFront cannot spell\", () => {\n    // `public/hello world.jpg` is a valid Next.js asset, but a space cannot appear\n    // in a path pattern, so cdk-nextjs threw at synth and the app could not be\n    // deployed at all. CloudFront matches the *decoded* path, and `?` matches one\n    // byte of it, so one `?` per UTF-8 byte is the narrowest pattern that\n    // matches. Not one per percent-encoded character: `hello???world.jpg`\n    // deploys and then never matches, which is a 404 rather than a synth error.\n    const { stack, distributionProps } = setup([], {\n      publicDirEntries: [\"hello world.jpg\", \"äöüščří.png\", \"favicon.ico\"],\n    });\n    new NextjsDistribution(stack, \"Distribution\", distributionProps);\n    expect(pathPatterns(stack)).toEqual(\n      expect.arrayContaining([\n        \"hello?world.jpg\",\n        // 7 characters, 2 UTF-8 bytes each.\n        `${\"?\".repeat(14)}.png`,\n        \"favicon.ico\",\n      ]),\n    );\n  });\n\n  it(\"wildcards a public/ directory name the same way\", () => {\n    const { stack, distributionProps } = setup([]);\n    new NextjsDistribution(stack, \"Distribution\", {\n      ...distributionProps,\n      publicDirEntries: [{ name: \"my images\", isDirectory: true }],\n    });\n    expect(pathPatterns(stack)).toContain(\"my?images/*\");\n  });\n\n  it(\"rejects a public/ name too long to express as a path pattern\", () => {\n    const { stack, distributionProps } = setup([], {\n      publicDirEntries: [`${\"ä\".repeat(130)}.png`],\n    });\n    expect(\n      () => new NextjsDistribution(stack, \"Distribution\", distributionProps),\n    ).toThrow(/needs a 264-character CloudFront path pattern/);\n  });\n\n  it(\"skips a public/ entry whose pattern would be wildcards alone\", () => {\n    // `фото/` is `????????/*`, which matches any 8-byte first segment. Public\n    // behaviors are added ahead of the compute ones, so `/products/42` would go\n    // to S3 and 403. The entry gets no behavior and a warning instead.\n    const { stack, distributionProps } = setup([]);\n    new NextjsDistribution(stack, \"Distribution\", {\n      ...distributionProps,\n      publicDirEntries: [\n        { name: \"фото\", isDirectory: true },\n        { name: \"图\", isDirectory: false },\n        { name: \"фото-1\", isDirectory: true },\n      ],\n    });\n    const patterns = pathPatterns(stack);\n    expect(patterns).not.toContain(`${\"?\".repeat(8)}/*`);\n    expect(patterns).not.toContain(\"???\");\n    // One literal character keeps a pattern narrow enough to keep.\n    expect(patterns).toContain(`${\"?\".repeat(8)}-1/*`);\n    Annotations.fromStack(stack).hasWarning(\n      \"*\",\n      Match.stringLikeRegexp('\"фото\", \"图\"'),\n    );\n  });\n\n  it(\"does not count a skipped public/ entry against the budget\", () => {\n    const { stack, distributionProps } = setup([], {\n      publicDirEntries: [\n        ...Array.from({ length: 22 }, (_, i) => `file${i}.txt`),\n        \"图\",\n      ],\n    });\n    // 3 fixed + 22 = 25, exactly the limit; the skipped entry adds nothing.\n    expect(\n      () =>\n        new NextjsDistribution(stack, \"Distribution\", {\n          ...distributionProps,\n          maxCacheBehaviors: 25,\n        }),\n    ).not.toThrow();\n  });\n\n  it(\"checks the length of the final pattern, basePath and /* included\", () => {\n    // 83 three-byte characters + \".pdf\" is a 253-character pattern on its own,\n    // under the limit; `/docs/` in front takes it to 259, which CloudFront\n    // rejects at deploy.\n    const name = `${\"图\".repeat(83)}.pdf`;\n    const { stack, distributionProps } = setup([], {\n      publicDirEntries: [name],\n    });\n    expect(\n      () =>\n        new NextjsDistribution(stack, \"Distribution\", {\n          ...distributionProps,\n          basePath: \"/docs\",\n        }),\n    ).toThrow(/needs a 259-character CloudFront path pattern/);\n\n    const { stack: dirStack, distributionProps: dirProps } = setup([]);\n    expect(\n      () =>\n        new NextjsDistribution(dirStack, \"Distribution\", {\n          ...dirProps,\n          // 254 characters, under the limit until the `/*`.\n          publicDirEntries: [\n            { name: `ab${\"图\".repeat(84)}`, isDirectory: true },\n          ],\n        }),\n    ).toThrow(/needs a 256-character/);\n  });\n\n  it(\"drops the cache key when an override disables dynamic caching\", () => {\n    // CloudFront rejects a policy that caches nothing but keys on headers. CDK\n    // used to raise `maxTtl: 0` to the day-long default, so the override\n    // deployed; with a default of 0 it is honored, and must stay deployable.\n    const { stack, distributionProps } = setup([]);\n    new NextjsDistribution(stack, \"Distribution\", {\n      ...distributionProps,\n      overrides: {\n        dynamicCachePolicyProps: { maxTtl: Duration.seconds(0) },\n      },\n    });\n    Template.fromStack(stack).hasResourceProperties(\n      \"AWS::CloudFront::CachePolicy\",\n      {\n        CachePolicyConfig: Match.objectLike({\n          Comment: Match.stringLikeRegexp(\"Dynamic\"),\n          DefaultTTL: 0,\n          MaxTTL: 0,\n          MinTTL: 0,\n          ParametersInCacheKeyAndForwardedToOrigin: {\n            CookiesConfig: { CookieBehavior: \"none\" },\n            EnableAcceptEncodingBrotli: false,\n            EnableAcceptEncodingGzip: false,\n            HeadersConfig: { HeaderBehavior: \"none\" },\n            QueryStringsConfig: { QueryStringBehavior: \"none\" },\n          },\n        }),\n      },\n    );\n  });\n\n  it(\"keeps the cache key when a zero maxTtl is raised by another TTL\", () => {\n    // CDK raises `maxTtl` to `defaultTtl`, so this policy caches for an hour.\n    // Dropping the key for it would serve one viewer's page to every viewer.\n    const { stack, distributionProps } = setup([]);\n    new NextjsDistribution(stack, \"Distribution\", {\n      ...distributionProps,\n      overrides: {\n        dynamicCachePolicyProps: {\n          maxTtl: Duration.seconds(0),\n          defaultTtl: Duration.hours(1),\n        },\n      },\n    });\n    Template.fromStack(stack).hasResourceProperties(\n      \"AWS::CloudFront::CachePolicy\",\n      {\n        CachePolicyConfig: Match.objectLike({\n          Comment: Match.stringLikeRegexp(\"Dynamic\"),\n          MaxTTL: 3600,\n          ParametersInCacheKeyAndForwardedToOrigin: Match.objectLike({\n            CookiesConfig: { CookieBehavior: \"all\" },\n            QueryStringsConfig: { QueryStringBehavior: \"all\" },\n          }),\n        }),\n      },\n    );\n  });\n\n  it(\"keys the dynamic cache only on headers the origin reads\", () => {\n    // `x-matched-path` is stripped by the runtime and `x-next-cache-tags` is\n    // never sent by viewers: keying on either spends a header slot and lets a\n    // client fragment the cache for nothing.\n    const { stack, distributionProps } = setup([]);\n    new NextjsDistribution(stack, \"Distribution\", distributionProps);\n    const policies = Template.fromStack(stack).findResources(\n      \"AWS::CloudFront::CachePolicy\",\n      {\n        Properties: {\n          CachePolicyConfig: { Comment: Match.stringLikeRegexp(\"Dynamic\") },\n        },\n      },\n    );\n    const [policy] = Object.values(policies);\n    const headers: string[] =\n      policy.Properties.CachePolicyConfig\n        .ParametersInCacheKeyAndForwardedToOrigin.HeadersConfig.Headers;\n    expect(headers).not.toContain(\"x-matched-path\");\n    expect(headers).not.toContain(\"x-next-cache-tags\");\n    expect(headers).toContain(\"rsc\");\n  });\n\n  it(\"rejects splitting on a deployment type that cannot route it\", () => {\n    const { stack, functionGroups, functionGroupBehaviors, distributionProps } =\n      setup([\"api\"]);\n    expect(\n      () =>\n        new NextjsDistribution(stack, \"Distribution\", {\n          ...distributionProps,\n          nextjsType: NextjsType.GLOBAL_CONTAINERS,\n          loadBalancer: undefined,\n          functionGroups,\n          functionGroupBehaviors,\n        }),\n    ).toThrow(/only supported by NextjsGlobalFunctions/);\n  });\n});\n\n/**\n * The viewer-request function, run as CloudFront would run it.\n *\n * It is authored as a string inside a TypeScript template literal, so every\n * backslash in it is escaped twice - and a regex that collapses slashes is nothing\n * but backslashes. Asserting on behavior rather than on the text is what catches an\n * escaping mistake, which a snapshot would happily record.\n */\ndescribe(\"the viewer-request CloudFront Function\", () => {\n  interface QueryValue {\n    value: string;\n    multiValue?: Array<{ value: string }>;\n  }\n  interface FunctionRequest {\n    uri: string;\n    querystring: Record<string, QueryValue>;\n    headers: Record<string, { value: string }>;\n  }\n  type FunctionResult =\n    | FunctionRequest\n    | { statusCode: number; headers: Record<string, { value: string }> };\n\n  const handler = (() => {\n    const stack = new Stack(new App(), \"FnStack\");\n    const fn = new LambdaFunction(stack, \"Fn\", {\n      code: Code.fromInline(\"exports.handler = () => {};\"),\n      handler: \"index.handler\",\n      runtime: Runtime.NODEJS_22_X,\n    });\n    new NextjsDistribution(stack, \"Distribution\", {\n      assetsBucket: new Bucket(stack, \"Assets\"),\n      functionUrl: new FunctionUrl(stack, \"Url\", {\n        function: fn,\n        authType: FunctionUrlAuthType.AWS_IAM,\n      }),\n      nextjsType: NextjsType.GLOBAL_FUNCTIONS,\n      publicDirEntries: [],\n    });\n    const functions = Template.fromStack(stack).findResources(\n      \"AWS::CloudFront::Function\",\n    );\n    const code = Object.values(functions)[0].Properties.FunctionCode as string;\n    return runInNewContext(`${code}\\nhandler`) as (event: {\n      request: FunctionRequest;\n    }) => Promise<FunctionResult>;\n  })();\n\n  const send = (\n    uri: string,\n    querystring: Record<string, QueryValue> = {},\n  ): Promise<FunctionResult> =>\n    handler({\n      request: { uri, querystring, headers: { host: { value: \"a.test\" } } },\n    });\n\n  const redirect = (result: FunctionResult) => ({\n    statusCode: (result as { statusCode: number }).statusCode,\n    location: result.headers.location?.value,\n  });\n\n  it.each([\n    [\"//\", \"/\"],\n    [\"///\", \"/\"],\n    [\"/foo//bar\", \"/foo/bar\"],\n    [\"/basepath//to-sv\", \"/basepath/to-sv\"],\n    [\"/a\\\\b\", \"/a/b\"],\n  ])(\"redirects %s to %s with a 308\", async (uri, location) => {\n    expect(redirect(await send(uri))).toEqual({ statusCode: 308, location });\n  });\n\n  it(\"keeps the query on the redirect, including repeated keys\", async () => {\n    // CloudFront's shape for a repeated key: `multiValue` holds every value,\n    // the first included, and `value` repeats that first one.\n    const result = await send(\"/x//y\", {\n      json: { value: \"true\" },\n      a: { value: \"1\", multiValue: [{ value: \"1\" }, { value: \"2\" }] },\n      flag: { value: \"\" },\n    });\n    expect(redirect(result).location).toBe(\"/x/y?json=true&a=1&a=2&flag\");\n  });\n\n  it(\"passes percent-encoded query values through without re-encoding\", async () => {\n    // CloudFront hands the function the values still encoded, as sent.\n    const result = await send(\"/x//y\", {\n      a: { value: \"%20b%26c\" },\n      p: { value: \"1+2\" },\n    });\n    expect(redirect(result).location).toBe(\"/x/y?a=%20b%26c&p=1+2\");\n  });\n\n  it(\"passes an ordinary path through with x-forwarded-host set\", async () => {\n    const result = (await send(\"/a/b\")) as FunctionRequest;\n    expect(result.uri).toBe(\"/a/b\");\n    // CloudFront rewrites `host` to the origin domain, so the app would otherwise\n    // build every absolute URL against the Function URL's hostname.\n    expect(result.headers[\"x-forwarded-host\"].value).toBe(\"a.test\");\n  });\n\n  it(\"overwrites a client-supplied x-forwarded-host\", async () => {\n    // The runtime trusts this header behind the Function URL, so a viewer's\n    // own value must not survive to build redirects or origin checks.\n    const result = (await handler({\n      request: {\n        uri: \"/a\",\n        querystring: {},\n        headers: {\n          host: { value: \"a.test\" },\n          \"x-forwarded-host\": { value: \"evil.test\" },\n        },\n      },\n    })) as FunctionRequest;\n    expect(result.headers[\"x-forwarded-host\"].value).toBe(\"a.test\");\n  });\n});\n\n/**\n * `viewerRequestFunctionCode`, run as CloudFront would run it on each behavior,\n * for the same reason as the suite above.\n */\ndescribe(\"viewerRequestFunctionCode\", () => {\n  const BASIC_AUTH = `\n    function viewerRequest(event) {\n      var auth = event.request.headers.authorization;\n      if (auth && auth.value === \"Basic dXNlcjpwYXNz\") return;\n      return {\n        statusCode: 401,\n        statusDescription: \"Unauthorized\",\n        headers: { \"www-authenticate\": { value: 'Basic realm=\"preview\"' } },\n      };\n    }\n  `;\n  const AUTHORIZED = { authorization: \"Basic dXNlcjpwYXNz\" };\n\n  interface FunctionRequest {\n    uri: string;\n    querystring: Record<string, { value: string }>;\n    headers: Record<string, { value: string }>;\n  }\n  type FunctionResult =\n    | FunctionRequest\n    | { statusCode: number; headers: Record<string, { value: string }> };\n  type Handler = (event: {\n    request: FunctionRequest;\n  }) => Promise<FunctionResult>;\n  /** What `viewerRequestKeyValueStore` holds, as `cf.kvs()` would read it. */\n  const fakeCloudFrontModule = (values: Record<string, string>) => ({\n    kvs: () => ({\n      get: async (key: string) => {\n        if (!(key in values)) throw new Error(`key not found: ${key}`);\n        return values[key];\n      },\n    }),\n  });\n  interface Behavior {\n    PathPattern: string;\n    FunctionAssociations?: Array<{\n      EventType: string;\n      FunctionARN: { \"Fn::GetAtt\": [string, string] };\n    }>;\n  }\n\n  const synth = (\n    props: {\n      code?: string;\n      nextjsType?: NextjsType;\n      assetPrefix?: string;\n      basePath?: string;\n      keyValueStore?: boolean;\n      overrides?: (stack: Stack) => NextjsDistributionOverrides;\n    } = {},\n  ) => {\n    const stack = new Stack(new App(), \"TestStack\");\n    const keyValueStore = props.keyValueStore\n      ? new KeyValueStore(stack, \"Kvs\")\n      : undefined;\n    const compute =\n      props.nextjsType === NextjsType.GLOBAL_CONTAINERS\n        ? {\n            loadBalancer: new ApplicationLoadBalancer(stack, \"Alb\", {\n              vpc: new Vpc(stack, \"Vpc\"),\n            }),\n          }\n        : {\n            functionUrl: new FunctionUrl(stack, \"Url\", {\n              function: new LambdaFunction(stack, \"Fn\", {\n                code: Code.fromInline(\"exports.handler = () => {};\"),\n                handler: \"index.handler\",\n                runtime: Runtime.NODEJS_22_X,\n              }),\n              authType: FunctionUrlAuthType.AWS_IAM,\n            }),\n          };\n    new NextjsDistribution(stack, \"Distribution\", {\n      ...compute,\n      assetsBucket: new Bucket(stack, \"Assets\"),\n      assetPrefix: props.assetPrefix,\n      basePath: props.basePath,\n      nextjsType: props.nextjsType ?? NextjsType.GLOBAL_FUNCTIONS,\n      overrides: props.overrides?.(stack),\n      publicDirEntries: [{ name: \"favicon.ico\", isDirectory: false }],\n      viewerRequestFunctionCode:\n        props.code === undefined\n          ? undefined\n          : FunctionCode.fromInline(props.code),\n      viewerRequestKeyValueStore: keyValueStore,\n    });\n    const template = Template.fromStack(stack);\n    const functions = template.findResources(\"AWS::CloudFront::Function\");\n    const config = Object.values(\n      template.findResources(\"AWS::CloudFront::Distribution\"),\n    )[0].Properties.DistributionConfig;\n    const behaviors: Behavior[] = [\n      { PathPattern: \"*\", ...config.DefaultCacheBehavior },\n      ...config.CacheBehaviors,\n    ];\n    /** The viewer-request function on the behavior for `pathPattern`. */\n    const functionFor = (pathPattern: string) => {\n      const behavior = behaviors.find((it) => it.PathPattern === pathPattern)!;\n      const association = behavior.FunctionAssociations!.find(\n        (it) => it.EventType === \"viewer-request\",\n      )!;\n      return functions[association.FunctionARN[\"Fn::GetAtt\"][0]].Properties;\n    };\n    /**\n     * That function's handler, runnable. `node:vm` scripts can't `import`, so\n     * the `cloudfront` module is handed in as the binding the import makes.\n     */\n    const handlerFor = (\n      pathPattern: string,\n      kvsValues: Record<string, string> = {},\n    ): Handler => {\n      const code = (functionFor(pathPattern).FunctionCode as string).replace(\n        /^\\s*import cf from \"cloudfront\";/,\n        \"\",\n      );\n      return runInNewContext(`${code}\\nhandler`, {\n        cf: fakeCloudFrontModule(kvsValues),\n      }) as Handler;\n    };\n    return { behaviors, functions, functionFor, handlerFor, stack };\n  };\n\n  const request = (uri: string, headers: Record<string, string> = {}) => ({\n    request: {\n      uri,\n      querystring: {},\n      headers: Object.fromEntries(\n        Object.entries({ host: \"a.test\", ...headers }).map(([name, value]) => [\n          name,\n          { value },\n        ]),\n      ),\n    },\n  });\n  const status = (result: FunctionResult) =>\n    (result as { statusCode?: number }).statusCode;\n\n  it.each([NextjsType.GLOBAL_FUNCTIONS, NextjsType.GLOBAL_CONTAINERS])(\n    \"gates every behavior on %s, static assets included\",\n    async (nextjsType) => {\n      const { behaviors, handlerFor } = synth({ code: BASIC_AUTH, nextjsType });\n      expect(behaviors.map((it) => it.PathPattern).sort()).toEqual([\n        \"*\",\n        \"_next/image*\",\n        \"_next/static*\",\n        \"favicon.ico\",\n      ]);\n      for (const { PathPattern } of behaviors) {\n        const handler = handlerFor(PathPattern);\n        expect(status(await handler(request(\"/x\")))).toBe(401);\n        const passed = (await handler(\n          request(\"/x\", AUTHORIZED),\n        )) as FunctionRequest;\n        expect(passed.uri).toBe(\"/x\");\n      }\n    },\n  );\n\n  it(\"shares one pass-through function between dynamic and static on Global Containers\", () => {\n    const { behaviors, functions } = synth({\n      code: BASIC_AUTH,\n      nextjsType: NextjsType.GLOBAL_CONTAINERS,\n    });\n    const [logicalId, ...rest] = Object.keys(functions);\n    expect(rest).toHaveLength(0);\n    expect(behaviors.map((it) => it.PathPattern).sort()).toEqual([\n      \"*\",\n      \"_next/image*\",\n      \"_next/static*\",\n      \"favicon.ico\",\n    ]);\n    for (const { FunctionAssociations } of behaviors) {\n      expect(FunctionAssociations).toEqual([\n        {\n          EventType: \"viewer-request\",\n          FunctionARN: { \"Fn::GetAtt\": [logicalId, \"FunctionARN\"] },\n        },\n      ]);\n    }\n  });\n\n  it(\"accepts viewerRequest declared after another variable\", async () => {\n    const handler = synth({\n      code: `var x = 1, viewerRequest = (event) => ({ statusCode: 401 });`,\n    }).handlerFor(\"_next/static*\");\n    expect(status(await handler(request(\"/x\")))).toBe(401);\n  });\n\n  it(\"accepts viewerRequest defined as a const arrow function\", async () => {\n    const handler = synth({\n      code: `const viewerRequest = async (event) => ({ statusCode: 401 });`,\n    }).handlerFor(\"_next/static*\");\n    expect(status(await handler(request(\"/x\")))).toBe(401);\n  });\n\n  it(\"runs before the repeated-slash redirect\", async () => {\n    // Otherwise `/a//b` would answer 308 to a viewer who never authenticated.\n    const handler = synth({ code: BASIC_AUTH }).handlerFor(\"*\");\n    expect(status(await handler(request(\"/a//b\")))).toBe(401);\n    expect(status(await handler(request(\"/a//b\", AUTHORIZED)))).toBe(308);\n  });\n\n  it(\"associates the store with every function it runs in\", () => {\n    const { behaviors, functionFor, functions } = synth({\n      code: BASIC_AUTH,\n      keyValueStore: true,\n      assetPrefix: \"/cdn\",\n    });\n    expect(Object.keys(functions)).toHaveLength(3);\n    for (const { PathPattern } of behaviors) {\n      const { FunctionConfig } = functionFor(PathPattern);\n      expect(FunctionConfig.Runtime).toBe(\"cloudfront-js-2.0\");\n      expect(FunctionConfig.KeyValueStoreAssociations).toEqual([\n        { KeyValueStoreARN: { \"Fn::GetAtt\": [expect.any(String), \"Arn\"] } },\n      ]);\n    }\n  });\n\n  it(\"reads credentials from the KeyValueStore\", async () => {\n    const handler = synth({\n      keyValueStore: true,\n      code: `import cf from \"cloudfront\";\n        const kvs = cf.kvs();\n        async function viewerRequest(event) {\n          const auth = event.request.headers.authorization;\n          if (auth && auth.value === \"Basic \" + (await kvs.get(\"basic-auth\"))) {\n            return;\n          }\n          return { statusCode: 401, statusDescription: \"Unauthorized\" };\n        }\n      `,\n    }).handlerFor(\"_next/static*\", { \"basic-auth\": \"dXNlcjpwYXNz\" });\n    expect(status(await handler(request(\"/x\")))).toBe(401);\n    expect(\n      ((await handler(request(\"/x\", AUTHORIZED))) as FunctionRequest).uri,\n    ).toBe(\"/x\");\n  });\n\n  it(\"refuses a KeyValueStore without code to read it\", () => {\n    expect(() => synth({ keyValueStore: true })).toThrow(\n      /`viewerRequestKeyValueStore` .* needs `viewerRequestFunctionCode`/,\n    );\n  });\n\n  it(\"can't keep a viewer's x-forwarded-host past cdk-nextjs's overwrite\", async () => {\n    const handler = synth({\n      code: `\n        function viewerRequest(event) {\n          event.request.headers[\"x-forwarded-host\"] = { value: \"evil.test\" };\n          return event.request;\n        }\n      `,\n    }).handlerFor(\"*\");\n    const result = (await handler(request(\"/x\"))) as FunctionRequest;\n    expect(result.headers[\"x-forwarded-host\"].value).toBe(\"a.test\");\n  });\n\n  it(\"carries on with a request it returns as a new object\", async () => {\n    const handler = synth({\n      code: `\n        function viewerRequest(event) {\n          return { uri: \"/y\", querystring: {}, headers: event.request.headers };\n        }\n      `,\n    }).handlerFor(\"_next/static*\");\n    expect(((await handler(request(\"/x\"))) as FunctionRequest).uri).toBe(\"/y\");\n  });\n\n  it(\"runs inside the assetPrefix rewrite, in place of the static function\", async () => {\n    const { behaviors, handlerFor } = synth({\n      code: BASIC_AUTH,\n      assetPrefix: \"/cdn\",\n    });\n    const prefixed = behaviors.find(\n      (it) => it.PathPattern === \"/cdn/_next/static*\",\n    )!;\n    // One viewer-request function per behavior, or CloudFront rejects it.\n    expect(\n      prefixed.FunctionAssociations!.filter(\n        (it) => it.EventType === \"viewer-request\",\n      ),\n    ).toHaveLength(1);\n    const handler = handlerFor(\"/cdn/_next/static*\");\n    expect(status(await handler(request(\"/cdn/_next/static/a.js\")))).toBe(401);\n    const passed = (await handler(\n      request(\"/cdn/_next/static/a.js\", AUTHORIZED),\n    )) as FunctionRequest;\n    expect(passed.uri).toBe(\"/_next/static/a.js\");\n  });\n\n  it(\"adds no functions when unset\", () => {\n    const { behaviors, functions } = synth();\n    const staticBehavior = behaviors.find(\n      (it) => it.PathPattern === \"_next/static*\",\n    )!;\n    expect(staticBehavior.FunctionAssociations).toBeUndefined();\n    const [fn, ...rest] = Object.values(functions).map((it) => it.Properties);\n    expect(rest).toHaveLength(0);\n    // The marker is dropped, not left in the deployed function.\n    expect(fn.FunctionCode).toMatch(\n      /^\\s*async function handler\\(event\\) \\{\\n\\s*const request/,\n    );\n    expect(fn.FunctionConfig.KeyValueStoreAssociations).toBeUndefined();\n  });\n\n  it.each([false, true])(\n    \"runs every cdk-nextjs function on cloudfront-js-2.0 (hook set: %s)\",\n    (hooked) => {\n      const { functions } = synth({\n        code: hooked ? BASIC_AUTH : undefined,\n        assetPrefix: \"/cdn\",\n      });\n      const runtimes = Object.values(functions).map(\n        (it) => it.Properties.FunctionConfig.Runtime,\n      );\n      expect(runtimes).toHaveLength(hooked ? 3 : 2);\n      expect(new Set(runtimes)).toEqual(new Set([\"cloudfront-js-2.0\"]));\n    },\n  );\n\n  it.each([\"dynamicBehaviorOptions\", \"imageBehaviorOptions\"] as const)(\n    \"refuses a %s override that claims viewer-request on Global Containers\",\n    (overrideName) => {\n      expect(() =>\n        synth({\n          code: BASIC_AUTH,\n          nextjsType: NextjsType.GLOBAL_CONTAINERS,\n          overrides: (stack) => ({\n            [overrideName]: {\n              functionAssociations: [\n                {\n                  eventType: FunctionEventType.VIEWER_REQUEST,\n                  function: new CloudFrontFunction(stack, \"UserFn\", {\n                    code: FunctionCode.fromInline(\n                      \"function handler(event) { return event.request; }\",\n                    ),\n                  }),\n                },\n              ],\n            },\n          }),\n        }),\n      ).toThrow(\n        new RegExp(\n          `overrides\\\\.${overrideName}\\\\.functionAssociations.*viewerRequestFunctionCode`,\n        ),\n      );\n    },\n  );\n\n  it(\"refuses a distributionProps.defaultBehavior override\", () => {\n    expect(() =>\n      synth({\n        code: BASIC_AUTH,\n        overrides: () => ({\n          distributionProps: {\n            defaultBehavior: {\n              origin: new HttpOrigin(\"example.com\"),\n            },\n          },\n        }),\n      }),\n    ).toThrow(/overrides\\.distributionProps\\.defaultBehavior/);\n  });\n\n  it(\"lets a basePath app replace the default behavior\", () => {\n    expect(() =>\n      synth({\n        code: BASIC_AUTH,\n        basePath: \"/app\",\n        overrides: () => ({\n          distributionProps: {\n            defaultBehavior: { origin: new HttpOrigin(\"example.com\") },\n          },\n        }),\n      }),\n    ).not.toThrow();\n  });\n\n  it(\"keeps cdk-nextjs's code out of the deployed indentation\", () => {\n    const { functionFor } = synth({ code: BASIC_AUTH });\n    const code = functionFor(\"*\").FunctionCode as string;\n    const own = code.slice(code.indexOf(\"async function handler\"));\n    expect(own).not.toMatch(/^[ \\t]/m);\n  });\n\n  it(\"warns, rather than measures, when the code contains a token\", () => {\n    const { stack } = synth({\n      code: `function viewerRequest(event) { return ${Lazy.string({ produce: () => '\"x\"' })}; }`,\n    });\n    Annotations.fromStack(stack).hasWarning(\n      \"*\",\n      Match.stringLikeRegexp(\"contains a CDK token\"),\n    );\n  });\n\n  it(\"refuses a static override that already claims viewer-request\", () => {\n    expect(() =>\n      synth({\n        code: BASIC_AUTH,\n        overrides: (stack) => ({\n          staticBehaviorOptions: {\n            functionAssociations: [\n              {\n                eventType: FunctionEventType.VIEWER_REQUEST,\n                function: new CloudFrontFunction(stack, \"UserFn\", {\n                  code: FunctionCode.fromInline(\n                    \"function handler(event) { return event.request; }\",\n                  ),\n                }),\n              },\n            ],\n          },\n        }),\n      }),\n    ).toThrow(/overrides\\.staticBehaviorOptions\\.functionAssociations/);\n  });\n\n  it.each([\n    [\"no viewerRequest\", \"var x = 1;\", /must define `viewerRequest\\(event\\)`/],\n    ...[\n      \"function handler(event) {}\",\n      \"function* handler(event) {}\",\n      \"const handler = (event) => event.request;\",\n      \"let a = 1, handler = 2;\",\n      \"var handler = (event) => event.request;\",\n      \"var { handler } = { handler: (event) => event.request };\",\n      'globalThis[\"handler\"] = (event) => event.request;',\n      \"var cdkNextjsHandler; handler = cdkNextjsHandler;\",\n    ].map((declaration): [string, string, RegExp] => [\n      `handler in \\`${declaration}\\``,\n      `${declaration}\\nfunction viewerRequest(event) {}`,\n      /uses the name `handler`/,\n    ]),\n    [\n      \"viewerRequest only compared, never declared\",\n      'const ok = typeof viewerRequest === \"function\";',\n      /must define `viewerRequest\\(event\\)`/,\n    ],\n    [\n      \"viewerRequest only assigned as a property\",\n      \"const cfg = {}; cfg.viewerRequest = function (event) {};\",\n      /must define `viewerRequest\\(event\\)`/,\n    ],\n    [\n      \"more than fits in a CloudFront Function\",\n      `function viewerRequest(event) {} /* ${\"x\".repeat(10 * 1024)} */`,\n      /over CloudFront's limit of 10240/,\n    ],\n  ])(\"refuses code with %s\", (_name, code, error) => {\n    expect(() => synth({ code })).toThrow(error);\n  });\n});\n"]}