cdk-nextjs 0.6.2 → 0.7.0

package/lib/nextjs-distribution.test.js

@@ -0,0 +1,697 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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_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");
+const constants_1 = require("./constants");
+const nextjs_distribution_1 = require("./nextjs-distribution");
+/**
+ * `functionGroups` routing at the edge. `NextjsBuild` is deliberately not
+ * involved: which behaviors a group gets, and in what order, is the adapter's
+ * decision (`function-groups.test.ts`), so these pass the behaviors in directly
+ * and assert on what the distribution does with them.
+ */
+describe("NextjsDistribution function group behaviors", () => {
+    const setup = (groupNames, props = {}) => {
+        const stack = new aws_cdk_lib_1.Stack(new aws_cdk_lib_1.App(), "TestStack");
+        const functionGroups = groupNames.map((name) => {
+            const fn = new aws_lambda_1.Function(stack, `Fn${name}`, {
+                code: aws_lambda_1.Code.fromInline("exports.handler = () => {};"),
+                handler: "index.handler",
+                runtime: aws_lambda_1.Runtime.NODEJS_22_X,
+            });
+            return {
+                name,
+                functionUrl: new aws_lambda_1.FunctionUrl(stack, `Url${name}`, {
+                    function: fn,
+                    authType: aws_lambda_1.FunctionUrlAuthType.AWS_IAM,
+                }),
+            };
+        });
+        // In the order given: the build's list is already most specific first.
+        const functionGroupBehaviors = groupNames.flatMap((group) => (props.routesFor?.(group) ?? [`/${group}/**`]).flatMap((route) => (0, function_groups_1.pathPatternsFor)(route, {
+            hasDataRoutes: false,
+            trailingSlash: props.trailingSlash,
+        }).map((pattern) => ({ group, route, pattern }))));
+        const defaultFn = new aws_lambda_1.Function(stack, "FnDefault", {
+            code: aws_lambda_1.Code.fromInline("exports.handler = () => {};"),
+            handler: "index.handler",
+            runtime: aws_lambda_1.Runtime.NODEJS_22_X,
+        });
+        return {
+            stack,
+            functionGroups,
+            functionGroupBehaviors,
+            distributionProps: {
+                assetsBucket: new aws_s3_1.Bucket(stack, "Assets"),
+                basePath: props.basePath,
+                functionUrl: new aws_lambda_1.FunctionUrl(stack, "UrlDefault", {
+                    function: defaultFn,
+                    authType: aws_lambda_1.FunctionUrlAuthType.AWS_IAM,
+                }),
+                nextjsType: constants_1.NextjsType.GLOBAL_FUNCTIONS,
+                publicDirEntries: (props.publicDirEntries ?? []).map((name) => ({
+                    name,
+                    isDirectory: false,
+                })),
+            },
+        };
+    };
+    const pathPatterns = (stack) => {
+        const distributions = assertions_1.Template.fromStack(stack).findResources("AWS::CloudFront::Distribution");
+        const config = Object.values(distributions)[0].Properties.DistributionConfig;
+        return config.CacheBehaviors.map((behavior) => behavior.PathPattern);
+    };
+    it("adds nothing extra when there are no groups", () => {
+        const { stack, distributionProps } = setup([]);
+        new nextjs_distribution_1.NextjsDistribution(stack, "Distribution", distributionProps);
+        expect(pathPatterns(stack)).toEqual(["_next/static*", "_next/image*"]);
+    });
+    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);
+        assertions_1.Template.fromStack(stack).hasResourceProperties("AWS::S3::BucketPolicy", {
+            PolicyDocument: {
+                Statement: assertions_1.Match.arrayWith([
+                    assertions_1.Match.objectLike({
+                        Action: ["s3:GetObject", "s3:ListBucket"],
+                        Principal: { Service: "cloudfront.amazonaws.com" },
+                    }),
+                ]),
+            },
+        });
+    });
+    it("adds group behaviors in the build's order, after the image behavior", () => {
+        // CloudFront stops at the first matching behavior, so `api/*` ahead of
+        // `api/reports/*` would send every report request to the wrong function.
+        // The build sorted them when it checked them; re-sorting here could only
+        // disagree with that.
+        const { stack, functionGroups, functionGroupBehaviors, distributionProps } = setup(["reports", "api"], {
+            routesFor: (name) => name === "api" ? ["/api/**"] : ["/api/reports/**"],
+        });
+        new nextjs_distribution_1.NextjsDistribution(stack, "Distribution", {
+            ...distributionProps,
+            functionGroups,
+            functionGroupBehaviors,
+        });
+        expect(pathPatterns(stack)).toEqual([
+            "_next/static*",
+            "_next/image*",
+            "api/reports/*",
+            "api/*",
+        ]);
+    });
+    it("keeps the two slash variants distinct under a basePath", () => {
+        // `getPathPattern` used to join through a helper that strips trailing
+        // slashes, so `pricing` and `pricing/` both became `/base/pricing`: two
+        // behaviors with the same path pattern, which CloudFront rejects at deploy
+        // with no hint that `trailingSlash` is what produced the duplicate.
+        const { stack, functionGroups, functionGroupBehaviors, distributionProps } = setup(["mkt"], {
+            routesFor: () => ["/pricing"],
+            basePath: "/base",
+            trailingSlash: true,
+        });
+        new nextjs_distribution_1.NextjsDistribution(stack, "Distribution", {
+            ...distributionProps,
+            functionGroups,
+            functionGroupBehaviors,
+        });
+        const patterns = pathPatterns(stack);
+        expect(patterns).toContain("/base/pricing");
+        expect(patterns).toContain("/base/pricing/");
+    });
+    it("counts the basePath behaviors against the budget", () => {
+        const { stack, distributionProps } = setup([], {
+            basePath: "/base",
+            publicDirEntries: Array.from({ length: 21 }, (_, i) => `file${i}.txt`),
+        });
+        // 3 fixed + the 2 a basePath adds to stand in for the default behavior + 21
+        // public = 26. Counting only the 3 reported 24 and let the synth through, so
+        // the limit arrived as a CloudFront deploy failure.
+        expect(() => new nextjs_distribution_1.NextjsDistribution(stack, "Distribution", {
+            ...distributionProps,
+            maxCacheBehaviors: 25,
+        })).toThrow(/26 CloudFront cache behaviors.*5 used by cdk-nextjs itself/s);
+    });
+    it("defaults the budget to CloudFront's quota of 75", () => {
+        // The hard-coded 25 predated the quota's increase to 75.
+        const { stack, distributionProps } = setup([], {
+            publicDirEntries: Array.from({ length: 72 }, (_, i) => `file${i}.txt`),
+        });
+        expect(() => new nextjs_distribution_1.NextjsDistribution(stack, "Distribution", distributionProps)).not.toThrow();
+        const { stack: over, distributionProps: overProps } = setup([], {
+            publicDirEntries: Array.from({ length: 73 }, (_, i) => `file${i}.txt`),
+        });
+        expect(() => new nextjs_distribution_1.NextjsDistribution(over, "Distribution", overProps)).toThrow(/76 CloudFront cache behaviors, over the limit of 75.*set `maxCacheBehaviors`/s);
+    });
+    it("honors a raised maxCacheBehaviors", () => {
+        const { stack, distributionProps } = setup([], {
+            publicDirEntries: Array.from({ length: 97 }, (_, i) => `file${i}.txt`),
+        });
+        expect(() => new nextjs_distribution_1.NextjsDistribution(stack, "Distribution", {
+            ...distributionProps,
+            maxCacheBehaviors: 100,
+        })).not.toThrow();
+    });
+    it("does not count basePath behaviors for a basePath of /", () => {
+        // `basePath: "/"` normalizes to no basePath and adds no behaviors, so
+        // counting 2 for it could reject an app that is under the limit.
+        const { stack, distributionProps } = setup([], {
+            basePath: "/",
+            publicDirEntries: Array.from({ length: 22 }, (_, i) => `file${i}.txt`),
+        });
+        expect(() => new nextjs_distribution_1.NextjsDistribution(stack, "Distribution", {
+            ...distributionProps,
+            maxCacheBehaviors: 25,
+        })).not.toThrow();
+    });
+    it("rejects a behavior for a group it was not given", () => {
+        const { stack, functionGroupBehaviors, distributionProps } = setup(["api"]);
+        expect(() => new nextjs_distribution_1.NextjsDistribution(stack, "Distribution", {
+            ...distributionProps,
+            functionGroupBehaviors,
+        })).toThrow(/routes to function group "api", which is not in `functionGroups`/);
+    });
+    it("points each group's behaviors at that group's own origin", () => {
+        const { stack, functionGroups, functionGroupBehaviors, distributionProps } = setup(["api"], {
+            routesFor: () => ["/api/**", "/health"],
+        });
+        new nextjs_distribution_1.NextjsDistribution(stack, "Distribution", {
+            ...distributionProps,
+            functionGroups,
+            functionGroupBehaviors,
+        });
+        const distributions = assertions_1.Template.fromStack(stack).findResources("AWS::CloudFront::Distribution");
+        const config = Object.values(distributions)[0].Properties.DistributionConfig;
+        const behaviors = config.CacheBehaviors;
+        const groupOrigins = new Set(behaviors
+            .filter((behavior) => ["api/*", "health"].includes(behavior.PathPattern))
+            .map((behavior) => behavior.TargetOriginId));
+        // One origin, shared by both of the group's patterns, and not the default's.
+        expect(groupOrigins.size).toBe(1);
+        expect(groupOrigins).not.toContain(config.DefaultCacheBehavior.TargetOriginId);
+    });
+    it("prefixes group patterns with basePath", () => {
+        const { stack, functionGroups, functionGroupBehaviors, distributionProps } = setup(["api"], {
+            routesFor: () => ["/api/**"],
+            basePath: "/base",
+        });
+        new nextjs_distribution_1.NextjsDistribution(stack, "Distribution", {
+            ...distributionProps,
+            functionGroups,
+            functionGroupBehaviors,
+        });
+        expect(pathPatterns(stack)).toContain("/base/api/*");
+    });
+    it("names every claim on the behavior budget when it is exceeded", () => {
+        const { stack, functionGroups, functionGroupBehaviors, distributionProps } = setup(["api"], {
+            routesFor: () => ["/api/**"],
+            publicDirEntries: Array.from({ length: 22 }, (_, i) => `file${i}.txt`),
+        });
+        expect(() => new nextjs_distribution_1.NextjsDistribution(stack, "Distribution", {
+            ...distributionProps,
+            functionGroups,
+            functionGroupBehaviors,
+            maxCacheBehaviors: 25,
+        })).toThrow(/26 CloudFront cache behaviors.*1 for `functionGroups` patterns/s);
+    });
+    it("rejects a group pattern that duplicates a public/ directory's", () => {
+        // `public/docs/` and `/docs/**` both deploy as `docs/*`: the synth
+        // succeeded and CloudFront rejected the deploy.
+        const { stack, functionGroups, functionGroupBehaviors, distributionProps } = setup(["docs"]);
+        expect(() => new nextjs_distribution_1.NextjsDistribution(stack, "Distribution", {
+            ...distributionProps,
+            functionGroups,
+            functionGroupBehaviors,
+            publicDirEntries: [{ name: "docs", isDirectory: true }],
+        })).toThrow(/pattern "\/docs\/\*\*" \(group "docs"\) deploys as the path pattern "docs\/\*", which a top-level public\/ entry already uses/);
+    });
+    it("rejects a group pattern a public/ directory's behavior would shadow", () => {
+        // `docs/*` is added first, so `docs/guide/*` never matches.
+        const { stack, functionGroups, functionGroupBehaviors, distributionProps } = setup(["guide"], {
+            routesFor: () => ["/docs/guide/**"],
+        });
+        expect(() => new nextjs_distribution_1.NextjsDistribution(stack, "Distribution", {
+            ...distributionProps,
+            functionGroups,
+            functionGroupBehaviors,
+            publicDirEntries: [{ name: "docs", isDirectory: true }],
+        })).toThrow(/public\/ entry behind "docs\/\*" is matched first/);
+    });
+    it("rejects an exact group pattern equal to a public/ file's, basePath included", () => {
+        const { stack, functionGroups, functionGroupBehaviors, distributionProps } = setup(["mkt"], {
+            routesFor: () => ["/robots.txt"],
+            basePath: "/base",
+        });
+        expect(() => new nextjs_distribution_1.NextjsDistribution(stack, "Distribution", {
+            ...distributionProps,
+            functionGroups,
+            functionGroupBehaviors,
+            publicDirEntries: [{ name: "robots.txt", isDirectory: false }],
+        })).toThrow(/deploys as the path pattern "\/base\/robots\.txt"/);
+    });
+    it("allows a group pattern beside a public/ entry it does not overlap", () => {
+        // `/docs` exact is not under `docs/*`, and `docs/*` does not match `/docs`.
+        const { stack, functionGroups, functionGroupBehaviors, distributionProps } = setup(["docs"], {
+            routesFor: () => ["/docs"],
+        });
+        new nextjs_distribution_1.NextjsDistribution(stack, "Distribution", {
+            ...distributionProps,
+            functionGroups,
+            functionGroupBehaviors,
+            publicDirEntries: [{ name: "docs", isDirectory: true }],
+        });
+        expect(pathPatterns(stack)).toEqual(expect.arrayContaining(["docs/*", "docs"]));
+    });
+    it("serves bundles under a path-style assetPrefix, rewriting the prefix away", () => {
+        // Next.js emits `<assetPrefix>/_next/static/...` for every bundle while the
+        // objects keep their unprefixed S3 keys, so without a behavior of its own the
+        // request falls through to the compute origin and 404s — the deployment
+        // package carries no `.next/static`. Measured against
+        // `test/e2e/app-dir/asset-prefix`, where 2 of 7 cases failed on exactly that.
+        const { stack, distributionProps } = setup([]);
+        new nextjs_distribution_1.NextjsDistribution(stack, "Distribution", {
+            ...distributionProps,
+            assetPrefix: "/custom-asset-prefix",
+        });
+        // Ahead of the bare `_next/static*` in nothing but list position; the two
+        // patterns cannot both match one request, so order does not matter here.
+        expect(pathPatterns(stack)).toEqual([
+            "_next/static*",
+            "/custom-asset-prefix/_next/static*",
+            "_next/image*",
+        ]);
+        const fns = assertions_1.Template.fromStack(stack).findResources("AWS::CloudFront::Function");
+        const code = Object.values(fns)
+            .map((fn) => fn.Properties.FunctionCode)
+            .find((it) => it.includes("request.uri.slice"));
+        // `"/custom-asset-prefix".length`, so `/custom-asset-prefix/_next/static/x`
+        // reaches S3 as `_next/static/x`.
+        expect(code).toContain('"" + request.uri.slice(20)');
+    });
+    it("refuses an assetPrefix when an override already claims VIEWER_REQUEST", () => {
+        // CloudFront permits one function per event type per behavior, so the
+        // rewrite and the override cannot coexist: the stack synthed cleanly and was
+        // rejected at deploy, naming neither the override nor `assetPrefix`.
+        const { stack, distributionProps } = setup([]);
+        expect(() => new nextjs_distribution_1.NextjsDistribution(stack, "Distribution", {
+            ...distributionProps,
+            assetPrefix: "/cdn",
+            overrides: {
+                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(/already associates a CloudFront function with viewer-request/);
+    });
+    const userFn = (stack, eventType) => ({
+        eventType,
+        function: new aws_cloudfront_1.Function(stack, `UserFn${eventType}`, {
+            code: aws_cloudfront_1.FunctionCode.fromInline("function handler(event) { return event.request || event.response; }"),
+        }),
+    });
+    it.each(["dynamicBehaviorOptions", "imageBehaviorOptions"])("refuses a %s override that would replace the x-forwarded-host function", (overrideName) => {
+        // The runtime trusts `x-forwarded-host` on Function URL events because
+        // this function overwrites it; replaced, a viewer's own header reaches it.
+        const { stack, distributionProps } = setup([]);
+        expect(() => new nextjs_distribution_1.NextjsDistribution(stack, "Distribution", {
+            ...distributionProps,
+            overrides: {
+                [overrideName]: {
+                    functionAssociations: [
+                        userFn(stack, aws_cloudfront_1.FunctionEventType.VIEWER_REQUEST),
+                    ],
+                },
+            },
+        })).toThrow(new RegExp(`overrides\\.${overrideName}\\.functionAssociations`));
+    });
+    it("keeps the x-forwarded-host function next to an override's other associations", () => {
+        const { stack, distributionProps } = setup([]);
+        new nextjs_distribution_1.NextjsDistribution(stack, "Distribution", {
+            ...distributionProps,
+            overrides: {
+                dynamicBehaviorOptions: {
+                    functionAssociations: [
+                        userFn(stack, aws_cloudfront_1.FunctionEventType.VIEWER_RESPONSE),
+                    ],
+                },
+            },
+        });
+        const config = Object.values(assertions_1.Template.fromStack(stack).findResources("AWS::CloudFront::Distribution"))[0].Properties.DistributionConfig;
+        const eventTypes = config.DefaultCacheBehavior.FunctionAssociations.map((association) => association.EventType);
+        expect(eventTypes.sort()).toEqual(["viewer-request", "viewer-response"]);
+    });
+    it("rewrites an assetPrefix back onto the basePath S3 keys", () => {
+        const { stack, distributionProps } = setup([], { basePath: "/base" });
+        new nextjs_distribution_1.NextjsDistribution(stack, "Distribution", {
+            ...distributionProps,
+            assetPrefix: "/cdn",
+        });
+        expect(pathPatterns(stack)).toContain("/cdn/_next/static*");
+        const fns = assertions_1.Template.fromStack(stack).findResources("AWS::CloudFront::Function");
+        const code = Object.values(fns)
+            .map((fn) => fn.Properties.FunctionCode)
+            .find((it) => it.includes("request.uri.slice"));
+        // The objects are at `base/_next/static/...`: `assetPrefix` replaces the
+        // `basePath` prefix in the URL, so the rewrite has to put it back.
+        expect(code).toContain('"/base" + request.uri.slice(4)');
+    });
+    it("serves bundles under the path an absolute assetPrefix carries", () => {
+        // `next build` compiles a `/custom-asset-prefix/_next/:path+ → /_next/:path+`
+        // rewrite of its own for an absolute prefix with a path, so `next start` serves
+        // every bundle under that path as well. A CDN fronting this distribution there
+        // gets the same request, and without a behavior it reaches the compute origin
+        // and 404s. Measured against `test/e2e/app-dir/asset-prefix-absolute`, whose
+        // one case failed on exactly that.
+        for (const assetPrefix of [
+            "https://example.vercel.sh/custom-asset-prefix",
+            "//example.vercel.sh/custom-asset-prefix/",
+        ]) {
+            const { stack, distributionProps } = setup([]);
+            new nextjs_distribution_1.NextjsDistribution(stack, "Distribution", {
+                ...distributionProps,
+                assetPrefix,
+            });
+            expect(pathPatterns(stack)).toContain("/custom-asset-prefix/_next/static*");
+            const code = Object.values(assertions_1.Template.fromStack(stack).findResources("AWS::CloudFront::Function"))
+                .map((fn) => fn.Properties.FunctionCode)
+                .find((it) => it.includes("request.uri.slice"));
+            expect(code).toContain('"" + request.uri.slice(20)');
+        }
+    });
+    it("adds no behavior for an assetPrefix that needs none", () => {
+        // An absolute prefix with no path of its own names an origin this distribution
+        // does not serve, and a prefix equal to the basePath one is what Next.js
+        // defaults to when `basePath` is set — `_next/static*` already resolves under
+        // it, and a duplicate pattern would make CloudFront reject the distribution.
+        for (const [assetPrefix, basePath] of [
+            ["https://cdn.example.com", undefined],
+            ["https://cdn.example.com/", undefined],
+            ["//cdn.example.com", undefined],
+            ["/base", "/base"],
+            ["https://cdn.example.com/base", "/base"],
+            ["", undefined],
+        ]) {
+            const { stack, distributionProps } = setup([], { basePath });
+            new nextjs_distribution_1.NextjsDistribution(stack, "Distribution", {
+                ...distributionProps,
+                assetPrefix,
+            });
+            const patterns = pathPatterns(stack);
+            expect(patterns.filter((p) => p.includes("_next/static"))).toHaveLength(1);
+            // The x-forwarded-host function is always there on function compute; the
+            // rewrite one should not be.
+            const codes = Object.values(assertions_1.Template.fromStack(stack).findResources("AWS::CloudFront::Function")).map((fn) => fn.Properties.FunctionCode);
+            expect(codes.some((it) => it.includes("request.uri.slice"))).toBe(false);
+        }
+    });
+    it("counts the assetPrefix behavior against the budget", () => {
+        const { stack, distributionProps } = setup([], {
+            publicDirEntries: Array.from({ length: 22 }, (_, i) => `file${i}.txt`),
+        });
+        // 3 fixed + 22 public = 25, exactly the limit; the assetPrefix one is the
+        // 26th, and a limit error that did not count it would come as a deploy
+        // failure instead.
+        expect(() => new nextjs_distribution_1.NextjsDistribution(stack, "Distribution", {
+            ...distributionProps,
+            assetPrefix: "/cdn",
+            maxCacheBehaviors: 25,
+        })).toThrow(/26 CloudFront cache behaviors.*4 used by cdk-nextjs itself/s);
+    });
+    it("does not cache a dynamic response that sends no Cache-Control", () => {
+        // CDK's `CachePolicy` default is a day, which cached every route handler
+        // without a `Cache-Control` - `/api/echo` in app-playground - for 24 hours.
+        const { stack, distributionProps } = setup([]);
+        new nextjs_distribution_1.NextjsDistribution(stack, "Distribution", distributionProps);
+        assertions_1.Template.fromStack(stack).hasResourceProperties("AWS::CloudFront::CachePolicy", {
+            CachePolicyConfig: assertions_1.Match.objectLike({
+                Comment: assertions_1.Match.stringLikeRegexp("Dynamic"),
+                DefaultTTL: 0,
+                MinTTL: 0,
+            }),
+        });
+    });
+    it("wildcards a public/ name CloudFront cannot spell", () => {
+        // `public/hello world.jpg` is a valid Next.js asset, but a space cannot appear
+        // in a path pattern, so cdk-nextjs threw at synth and the app could not be
+        // deployed at all. CloudFront matches the *decoded* path, and `?` matches one
+        // byte of it, so one `?` per UTF-8 byte is the narrowest pattern that
+        // matches. Not one per percent-encoded character: `hello???world.jpg`
+        // deploys and then never matches, which is a 404 rather than a synth error.
+        const { stack, distributionProps } = setup([], {
+            publicDirEntries: ["hello world.jpg", "äöüščří.png", "favicon.ico"],
+        });
+        new nextjs_distribution_1.NextjsDistribution(stack, "Distribution", distributionProps);
+        expect(pathPatterns(stack)).toEqual(expect.arrayContaining([
+            "hello?world.jpg",
+            // 7 characters, 2 UTF-8 bytes each.
+            `${"?".repeat(14)}.png`,
+            "favicon.ico",
+        ]));
+    });
+    it("wildcards a public/ directory name the same way", () => {
+        const { stack, distributionProps } = setup([]);
+        new nextjs_distribution_1.NextjsDistribution(stack, "Distribution", {
+            ...distributionProps,
+            publicDirEntries: [{ name: "my images", isDirectory: true }],
+        });
+        expect(pathPatterns(stack)).toContain("my?images/*");
+    });
+    it("rejects a public/ name too long to express as a path pattern", () => {
+        const { stack, distributionProps } = setup([], {
+            publicDirEntries: [`${"ä".repeat(130)}.png`],
+        });
+        expect(() => new nextjs_distribution_1.NextjsDistribution(stack, "Distribution", distributionProps)).toThrow(/needs a 264-character CloudFront path pattern/);
+    });
+    it("skips a public/ entry whose pattern would be wildcards alone", () => {
+        // `фото/` is `????????/*`, which matches any 8-byte first segment. Public
+        // behaviors are added ahead of the compute ones, so `/products/42` would go
+        // to S3 and 403. The entry gets no behavior and a warning instead.
+        const { stack, distributionProps } = setup([]);
+        new nextjs_distribution_1.NextjsDistribution(stack, "Distribution", {
+            ...distributionProps,
+            publicDirEntries: [
+                { name: "фото", isDirectory: true },
+                { name: "图", isDirectory: false },
+                { name: "фото-1", isDirectory: true },
+            ],
+        });
+        const patterns = pathPatterns(stack);
+        expect(patterns).not.toContain(`${"?".repeat(8)}/*`);
+        expect(patterns).not.toContain("???");
+        // One literal character keeps a pattern narrow enough to keep.
+        expect(patterns).toContain(`${"?".repeat(8)}-1/*`);
+        assertions_1.Annotations.fromStack(stack).hasWarning("*", assertions_1.Match.stringLikeRegexp('"фото", "图"'));
+    });
+    it("does not count a skipped public/ entry against the budget", () => {
+        const { stack, distributionProps } = setup([], {
+            publicDirEntries: [
+                ...Array.from({ length: 22 }, (_, i) => `file${i}.txt`),
+                "图",
+            ],
+        });
+        // 3 fixed + 22 = 25, exactly the limit; the skipped entry adds nothing.
+        expect(() => new nextjs_distribution_1.NextjsDistribution(stack, "Distribution", {
+            ...distributionProps,
+            maxCacheBehaviors: 25,
+        })).not.toThrow();
+    });
+    it("checks the length of the final pattern, basePath and /* included", () => {
+        // 83 three-byte characters + ".pdf" is a 253-character pattern on its own,
+        // under the limit; `/docs/` in front takes it to 259, which CloudFront
+        // rejects at deploy.
+        const name = `${"图".repeat(83)}.pdf`;
+        const { stack, distributionProps } = setup([], {
+            publicDirEntries: [name],
+        });
+        expect(() => new nextjs_distribution_1.NextjsDistribution(stack, "Distribution", {
+            ...distributionProps,
+            basePath: "/docs",
+        })).toThrow(/needs a 259-character CloudFront path pattern/);
+        const { stack: dirStack, distributionProps: dirProps } = setup([]);
+        expect(() => new nextjs_distribution_1.NextjsDistribution(dirStack, "Distribution", {
+            ...dirProps,
+            // 254 characters, under the limit until the `/*`.
+            publicDirEntries: [
+                { name: `ab${"图".repeat(84)}`, isDirectory: true },
+            ],
+        })).toThrow(/needs a 256-character/);
+    });
+    it("drops the cache key when an override disables dynamic caching", () => {
+        // CloudFront rejects a policy that caches nothing but keys on headers. CDK
+        // used to raise `maxTtl: 0` to the day-long default, so the override
+        // deployed; with a default of 0 it is honored, and must stay deployable.
+        const { stack, distributionProps } = setup([]);
+        new nextjs_distribution_1.NextjsDistribution(stack, "Distribution", {
+            ...distributionProps,
+            overrides: {
+                dynamicCachePolicyProps: { maxTtl: aws_cdk_lib_1.Duration.seconds(0) },
+            },
+        });
+        assertions_1.Template.fromStack(stack).hasResourceProperties("AWS::CloudFront::CachePolicy", {
+            CachePolicyConfig: assertions_1.Match.objectLike({
+                Comment: assertions_1.Match.stringLikeRegexp("Dynamic"),
+                DefaultTTL: 0,
+                MaxTTL: 0,
+                MinTTL: 0,
+                ParametersInCacheKeyAndForwardedToOrigin: {
+                    CookiesConfig: { CookieBehavior: "none" },
+                    EnableAcceptEncodingBrotli: false,
+                    EnableAcceptEncodingGzip: false,
+                    HeadersConfig: { HeaderBehavior: "none" },
+                    QueryStringsConfig: { QueryStringBehavior: "none" },
+                },
+            }),
+        });
+    });
+    it("keeps the cache key when a zero maxTtl is raised by another TTL", () => {
+        // CDK raises `maxTtl` to `defaultTtl`, so this policy caches for an hour.
+        // Dropping the key for it would serve one viewer's page to every viewer.
+        const { stack, distributionProps } = setup([]);
+        new nextjs_distribution_1.NextjsDistribution(stack, "Distribution", {
+            ...distributionProps,
+            overrides: {
+                dynamicCachePolicyProps: {
+                    maxTtl: aws_cdk_lib_1.Duration.seconds(0),
+                    defaultTtl: aws_cdk_lib_1.Duration.hours(1),
+                },
+            },
+        });
+        assertions_1.Template.fromStack(stack).hasResourceProperties("AWS::CloudFront::CachePolicy", {
+            CachePolicyConfig: assertions_1.Match.objectLike({
+                Comment: assertions_1.Match.stringLikeRegexp("Dynamic"),
+                MaxTTL: 3600,
+                ParametersInCacheKeyAndForwardedToOrigin: assertions_1.Match.objectLike({
+                    CookiesConfig: { CookieBehavior: "all" },
+                    QueryStringsConfig: { QueryStringBehavior: "all" },
+                }),
+            }),
+        });
+    });
+    it("keys the dynamic cache only on headers the origin reads", () => {
+        // `x-matched-path` is stripped by the runtime and `x-next-cache-tags` is
+        // never sent by viewers: keying on either spends a header slot and lets a
+        // client fragment the cache for nothing.
+        const { stack, distributionProps } = setup([]);
+        new nextjs_distribution_1.NextjsDistribution(stack, "Distribution", distributionProps);
+        const policies = assertions_1.Template.fromStack(stack).findResources("AWS::CloudFront::CachePolicy", {
+            Properties: {
+                CachePolicyConfig: { Comment: assertions_1.Match.stringLikeRegexp("Dynamic") },
+            },
+        });
+        const [policy] = Object.values(policies);
+        const headers = policy.Properties.CachePolicyConfig
+            .ParametersInCacheKeyAndForwardedToOrigin.HeadersConfig.Headers;
+        expect(headers).not.toContain("x-matched-path");
+        expect(headers).not.toContain("x-next-cache-tags");
+        expect(headers).toContain("rsc");
+    });
+    it("rejects splitting on a deployment type that cannot route it", () => {
+        const { stack, functionGroups, functionGroupBehaviors, distributionProps } = setup(["api"]);
+        expect(() => new nextjs_distribution_1.NextjsDistribution(stack, "Distribution", {
+            ...distributionProps,
+            nextjsType: constants_1.NextjsType.GLOBAL_CONTAINERS,
+            loadBalancer: undefined,
+            functionGroups,
+            functionGroupBehaviors,
+        })).toThrow(/only supported by NextjsGlobalFunctions/);
+    });
+});
+/**
+ * The viewer-request function, run as CloudFront would run it.
+ *
+ * It is authored as a string inside a TypeScript template literal, so every
+ * backslash in it is escaped twice - and a regex that collapses slashes is nothing
+ * but backslashes. Asserting on behavior rather than on the text is what catches an
+ * escaping mistake, which a snapshot would happily record.
+ */
+describe("the viewer-request CloudFront Function", () => {
+    const handler = (() => {
+        const stack = new aws_cdk_lib_1.Stack(new aws_cdk_lib_1.App(), "FnStack");
+        const fn = 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,
+        });
+        new nextjs_distribution_1.NextjsDistribution(stack, "Distribution", {
+            assetsBucket: new aws_s3_1.Bucket(stack, "Assets"),
+            functionUrl: new aws_lambda_1.FunctionUrl(stack, "Url", {
+                function: fn,
+                authType: aws_lambda_1.FunctionUrlAuthType.AWS_IAM,
+            }),
+            nextjsType: constants_1.NextjsType.GLOBAL_FUNCTIONS,
+            publicDirEntries: [],
+        });
+        const functions = assertions_1.Template.fromStack(stack).findResources("AWS::CloudFront::Function");
+        const code = Object.values(functions)[0].Properties.FunctionCode;
+        return (0, node_vm_1.runInNewContext)(`${code}\nhandler`);
+    })();
+    const send = (uri, querystring = {}) => handler({
+        request: { uri, querystring, headers: { host: { value: "a.test" } } },
+    });
+    const redirect = (result) => ({
+        statusCode: result.statusCode,
+        location: result.headers.location?.value,
+    });
+    it.each([
+        ["//", "/"],
+        ["///", "/"],
+        ["/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 });
+    });
+    it("keeps the query on the redirect, including repeated keys", () => {
+        // 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", {
+            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", () => {
+        // CloudFront hands the function the values still encoded, as sent.
+        const result = 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");
+        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", () => {
+        // 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({
+            request: {
+                uri: "/a",
+                querystring: {},
+                headers: {
+                    host: { value: "a.test" },
+                    "x-forwarded-host": { value: "evil.test" },
+                },
+            },
+        });
+        expect(result.headers["x-forwarded-host"].value).toBe("a.test");
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"nextjs-distribution.test.js","sourceRoot":"","sources":["../src/nextjs-distribution.test.ts"],"names":[],"mappings":";;AAAA,qCAA0C;AAC1C,6CAAmD;AACnD,uDAAsE;AACtE,+DAIoC;AACpC,uDAMgC;AAChC,+CAA4C;AAC5C,+DAA4D;AAC5D,2CAAyC;AACzC,+DAG+B;AAE/B;;;;;GAKG;AACH,QAAQ,CAAC,6CAA6C,EAAE,GAAG,EAAE;IAC3D,MAAM,KAAK,GAAG,CACZ,UAAoB,EACpB,QAKI,EAAE,EACN,EAAE;QACF,MAAM,KAAK,GAAG,IAAI,mBAAK,CAAC,IAAI,iBAAG,EAAE,EAAE,WAAW,CAAC,CAAC;QAChD,MAAM,cAAc,GAAsC,UAAU,CAAC,GAAG,CACtE,CAAC,IAAI,EAAE,EAAE;YACP,MAAM,EAAE,GAAG,IAAI,qBAAc,CAAC,KAAK,EAAE,KAAK,IAAI,EAAE,EAAE;gBAChD,IAAI,EAAE,iBAAI,CAAC,UAAU,CAAC,6BAA6B,CAAC;gBACpD,OAAO,EAAE,eAAe;gBACxB,OAAO,EAAE,oBAAO,CAAC,WAAW;aAC7B,CAAC,CAAC;YACH,OAAO;gBACL,IAAI;gBACJ,WAAW,EAAE,IAAI,wBAAW,CAAC,KAAK,EAAE,MAAM,IAAI,EAAE,EAAE;oBAChD,QAAQ,EAAE,EAAE;oBACZ,QAAQ,EAAE,gCAAmB,CAAC,OAAO;iBACtC,CAAC;aACH,CAAC;QACJ,CAAC,CACF,CAAC;QACF,uEAAuE;QACvE,MAAM,sBAAsB,GAAG,UAAU,CAAC,OAAO,CAAC,CAAC,KAAK,EAAE,EAAE,CAC1D,CAAC,KAAK,CAAC,SAAS,EAAE,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,KAAK,KAAK,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,KAAK,EAAE,EAAE,CAC/D,IAAA,iCAAe,EAAC,KAAK,EAAE;YACrB,aAAa,EAAE,KAAK;YACpB,aAAa,EAAE,KAAK,CAAC,aAAa;SACnC,CAAC,CAAC,GAAG,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,CAAC,EAAE,KAAK,EAAE,KAAK,EAAE,OAAO,EAAE,CAAC,CAAC,CACjD,CACF,CAAC;QACF,MAAM,SAAS,GAAG,IAAI,qBAAc,CAAC,KAAK,EAAE,WAAW,EAAE;YACvD,IAAI,EAAE,iBAAI,CAAC,UAAU,CAAC,6BAA6B,CAAC;YACpD,OAAO,EAAE,eAAe;YACxB,OAAO,EAAE,oBAAO,CAAC,WAAW;SAC7B,CAAC,CAAC;QACH,OAAO;YACL,KAAK;YACL,cAAc;YACd,sBAAsB;YACtB,iBAAiB,EAAE;gBACjB,YAAY,EAAE,IAAI,eAAM,CAAC,KAAK,EAAE,QAAQ,CAAC;gBACzC,QAAQ,EAAE,KAAK,CAAC,QAAQ;gBACxB,WAAW,EAAE,IAAI,wBAAW,CAAC,KAAK,EAAE,YAAY,EAAE;oBAChD,QAAQ,EAAE,SAAS;oBACnB,QAAQ,EAAE,gCAAmB,CAAC,OAAO;iBACtC,CAAC;gBACF,UAAU,EAAE,sBAAU,CAAC,gBAAgB;gBACvC,gBAAgB,EAAE,CAAC,KAAK,CAAC,gBAAgB,IAAI,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC;oBAC9D,IAAI;oBACJ,WAAW,EAAE,KAAK;iBACnB,CAAC,CAAC;aACJ;SACF,CAAC;IACJ,CAAC,CAAC;IAEF,MAAM,YAAY,GAAG,CAAC,KAAY,EAAE,EAAE;QACpC,MAAM,aAAa,GAAG,qBAAQ,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC,aAAa,CAC3D,+BAA+B,CAChC,CAAC;QACF,MAAM,MAAM,GACV,MAAM,CAAC,MAAM,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,CAAC,UAAU,CAAC,kBAAkB,CAAC;QAChE,OAAQ,MAAM,CAAC,cAAiD,CAAC,GAAG,CAClE,CAAC,QAAQ,EAAE,EAAE,CAAC,QAAQ,CAAC,WAAW,CACnC,CAAC;IACJ,CAAC,CAAC;IAEF,EAAE,CAAC,6CAA6C,EAAE,GAAG,EAAE;QACrD,MAAM,EAAE,KAAK,EAAE,iBAAiB,EAAE,GAAG,KAAK,CAAC,EAAE,CAAC,CAAC;QAC/C,IAAI,wCAAkB,CAAC,KAAK,EAAE,cAAc,EAAE,iBAAiB,CAAC,CAAC;QACjE,MAAM,CAAC,YAAY,CAAC,KAAK,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,eAAe,EAAE,cAAc,CAAC,CAAC,CAAC;IACzE,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,oEAAoE,EAAE,GAAG,EAAE;QAC5E,MAAM,EAAE,KAAK,EAAE,iBAAiB,EAAE,GAAG,KAAK,CAAC,EAAE,CAAC,CAAC;QAC/C,IAAI,wCAAkB,CAAC,KAAK,EAAE,cAAc,EAAE,iBAAiB,CAAC,CAAC;QACjE,qBAAQ,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC,qBAAqB,CAAC,uBAAuB,EAAE;YACvE,cAAc,EAAE;gBACd,SAAS,EAAE,kBAAK,CAAC,SAAS,CAAC;oBACzB,kBAAK,CAAC,UAAU,CAAC;wBACf,MAAM,EAAE,CAAC,cAAc,EAAE,eAAe,CAAC;wBACzC,SAAS,EAAE,EAAE,OAAO,EAAE,0BAA0B,EAAE;qBACnD,CAAC;iBACH,CAAC;aACH;SACF,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,qEAAqE,EAAE,GAAG,EAAE;QAC7E,uEAAuE;QACvE,yEAAyE;QACzE,yEAAyE;QACzE,sBAAsB;QACtB,MAAM,EAAE,KAAK,EAAE,cAAc,EAAE,sBAAsB,EAAE,iBAAiB,EAAE,GACxE,KAAK,CAAC,CAAC,SAAS,EAAE,KAAK,CAAC,EAAE;YACxB,SAAS,EAAE,CAAC,IAAI,EAAE,EAAE,CAClB,IAAI,KAAK,KAAK,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC,iBAAiB,CAAC;SACrD,CAAC,CAAC;QACL,IAAI,wCAAkB,CAAC,KAAK,EAAE,cAAc,EAAE;YAC5C,GAAG,iBAAiB;YACpB,cAAc;YACd,sBAAsB;SACvB,CAAC,CAAC;QACH,MAAM,CAAC,YAAY,CAAC,KAAK,CAAC,CAAC,CAAC,OAAO,CAAC;YAClC,eAAe;YACf,cAAc;YACd,eAAe;YACf,OAAO;SACR,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,wDAAwD,EAAE,GAAG,EAAE;QAChE,sEAAsE;QACtE,wEAAwE;QACxE,2EAA2E;QAC3E,oEAAoE;QACpE,MAAM,EAAE,KAAK,EAAE,cAAc,EAAE,sBAAsB,EAAE,iBAAiB,EAAE,GACxE,KAAK,CAAC,CAAC,KAAK,CAAC,EAAE;YACb,SAAS,EAAE,GAAG,EAAE,CAAC,CAAC,UAAU,CAAC;YAC7B,QAAQ,EAAE,OAAO;YACjB,aAAa,EAAE,IAAI;SACpB,CAAC,CAAC;QACL,IAAI,wCAAkB,CAAC,KAAK,EAAE,cAAc,EAAE;YAC5C,GAAG,iBAAiB;YACpB,cAAc;YACd,sBAAsB;SACvB,CAAC,CAAC;QACH,MAAM,QAAQ,GAAG,YAAY,CAAC,KAAK,CAAC,CAAC;QACrC,MAAM,CAAC,QAAQ,CAAC,CAAC,SAAS,CAAC,eAAe,CAAC,CAAC;QAC5C,MAAM,CAAC,QAAQ,CAAC,CAAC,SAAS,CAAC,gBAAgB,CAAC,CAAC;IAC/C,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,kDAAkD,EAAE,GAAG,EAAE;QAC1D,MAAM,EAAE,KAAK,EAAE,iBAAiB,EAAE,GAAG,KAAK,CAAC,EAAE,EAAE;YAC7C,QAAQ,EAAE,OAAO;YACjB,gBAAgB,EAAE,KAAK,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,OAAO,CAAC,MAAM,CAAC;SACvE,CAAC,CAAC;QACH,4EAA4E;QAC5E,6EAA6E;QAC7E,oDAAoD;QACpD,MAAM,CACJ,GAAG,EAAE,CACH,IAAI,wCAAkB,CAAC,KAAK,EAAE,cAAc,EAAE;YAC5C,GAAG,iBAAiB;YACpB,iBAAiB,EAAE,EAAE;SACtB,CAAC,CACL,CAAC,OAAO,CAAC,6DAA6D,CAAC,CAAC;IAC3E,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,iDAAiD,EAAE,GAAG,EAAE;QACzD,yDAAyD;QACzD,MAAM,EAAE,KAAK,EAAE,iBAAiB,EAAE,GAAG,KAAK,CAAC,EAAE,EAAE;YAC7C,gBAAgB,EAAE,KAAK,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,OAAO,CAAC,MAAM,CAAC;SACvE,CAAC,CAAC;QACH,MAAM,CACJ,GAAG,EAAE,CAAC,IAAI,wCAAkB,CAAC,KAAK,EAAE,cAAc,EAAE,iBAAiB,CAAC,CACvE,CAAC,GAAG,CAAC,OAAO,EAAE,CAAC;QAChB,MAAM,EAAE,KAAK,EAAE,IAAI,EAAE,iBAAiB,EAAE,SAAS,EAAE,GAAG,KAAK,CAAC,EAAE,EAAE;YAC9D,gBAAgB,EAAE,KAAK,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,OAAO,CAAC,MAAM,CAAC;SACvE,CAAC,CAAC;QACH,MAAM,CACJ,GAAG,EAAE,CAAC,IAAI,wCAAkB,CAAC,IAAI,EAAE,cAAc,EAAE,SAAS,CAAC,CAC9D,CAAC,OAAO,CACP,+EAA+E,CAChF,CAAC;IACJ,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,mCAAmC,EAAE,GAAG,EAAE;QAC3C,MAAM,EAAE,KAAK,EAAE,iBAAiB,EAAE,GAAG,KAAK,CAAC,EAAE,EAAE;YAC7C,gBAAgB,EAAE,KAAK,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,OAAO,CAAC,MAAM,CAAC;SACvE,CAAC,CAAC;QACH,MAAM,CACJ,GAAG,EAAE,CACH,IAAI,wCAAkB,CAAC,KAAK,EAAE,cAAc,EAAE;YAC5C,GAAG,iBAAiB;YACpB,iBAAiB,EAAE,GAAG;SACvB,CAAC,CACL,CAAC,GAAG,CAAC,OAAO,EAAE,CAAC;IAClB,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,uDAAuD,EAAE,GAAG,EAAE;QAC/D,sEAAsE;QACtE,iEAAiE;QACjE,MAAM,EAAE,KAAK,EAAE,iBAAiB,EAAE,GAAG,KAAK,CAAC,EAAE,EAAE;YAC7C,QAAQ,EAAE,GAAG;YACb,gBAAgB,EAAE,KAAK,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,OAAO,CAAC,MAAM,CAAC;SACvE,CAAC,CAAC;QACH,MAAM,CACJ,GAAG,EAAE,CACH,IAAI,wCAAkB,CAAC,KAAK,EAAE,cAAc,EAAE;YAC5C,GAAG,iBAAiB;YACpB,iBAAiB,EAAE,EAAE;SACtB,CAAC,CACL,CAAC,GAAG,CAAC,OAAO,EAAE,CAAC;IAClB,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,iDAAiD,EAAE,GAAG,EAAE;QACzD,MAAM,EAAE,KAAK,EAAE,sBAAsB,EAAE,iBAAiB,EAAE,GAAG,KAAK,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC;QAC5E,MAAM,CACJ,GAAG,EAAE,CACH,IAAI,wCAAkB,CAAC,KAAK,EAAE,cAAc,EAAE;YAC5C,GAAG,iBAAiB;YACpB,sBAAsB;SACvB,CAAC,CACL,CAAC,OAAO,CACP,kEAAkE,CACnE,CAAC;IACJ,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,0DAA0D,EAAE,GAAG,EAAE;QAClE,MAAM,EAAE,KAAK,EAAE,cAAc,EAAE,sBAAsB,EAAE,iBAAiB,EAAE,GACxE,KAAK,CAAC,CAAC,KAAK,CAAC,EAAE;YACb,SAAS,EAAE,GAAG,EAAE,CAAC,CAAC,SAAS,EAAE,SAAS,CAAC;SACxC,CAAC,CAAC;QACL,IAAI,wCAAkB,CAAC,KAAK,EAAE,cAAc,EAAE;YAC5C,GAAG,iBAAiB;YACpB,cAAc;YACd,sBAAsB;SACvB,CAAC,CAAC;QACH,MAAM,aAAa,GAAG,qBAAQ,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC,aAAa,CAC3D,+BAA+B,CAChC,CAAC;QACF,MAAM,MAAM,GACV,MAAM,CAAC,MAAM,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,CAAC,UAAU,CAAC,kBAAkB,CAAC;QAChE,MAAM,SAAS,GAAG,MAAM,CAAC,cAGvB,CAAC;QACH,MAAM,YAAY,GAAG,IAAI,GAAG,CAC1B,SAAS;aACN,MAAM,CAAC,CAAC,QAAQ,EAAE,EAAE,CACnB,CAAC,OAAO,EAAE,QAAQ,CAAC,CAAC,QAAQ,CAAC,QAAQ,CAAC,WAAW,CAAC,CACnD;aACA,GAAG,CAAC,CAAC,QAAQ,EAAE,EAAE,CAAC,QAAQ,CAAC,cAAc,CAAC,CAC9C,CAAC;QACF,6EAA6E;QAC7E,MAAM,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;QAClC,MAAM,CAAC,YAAY,CAAC,CAAC,GAAG,CAAC,SAAS,CAChC,MAAM,CAAC,oBAAoB,CAAC,cAAc,CAC3C,CAAC;IACJ,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,uCAAuC,EAAE,GAAG,EAAE;QAC/C,MAAM,EAAE,KAAK,EAAE,cAAc,EAAE,sBAAsB,EAAE,iBAAiB,EAAE,GACxE,KAAK,CAAC,CAAC,KAAK,CAAC,EAAE;YACb,SAAS,EAAE,GAAG,EAAE,CAAC,CAAC,SAAS,CAAC;YAC5B,QAAQ,EAAE,OAAO;SAClB,CAAC,CAAC;QACL,IAAI,wCAAkB,CAAC,KAAK,EAAE,cAAc,EAAE;YAC5C,GAAG,iBAAiB;YACpB,cAAc;YACd,sBAAsB;SACvB,CAAC,CAAC;QACH,MAAM,CAAC,YAAY,CAAC,KAAK,CAAC,CAAC,CAAC,SAAS,CAAC,aAAa,CAAC,CAAC;IACvD,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,8DAA8D,EAAE,GAAG,EAAE;QACtE,MAAM,EAAE,KAAK,EAAE,cAAc,EAAE,sBAAsB,EAAE,iBAAiB,EAAE,GACxE,KAAK,CAAC,CAAC,KAAK,CAAC,EAAE;YACb,SAAS,EAAE,GAAG,EAAE,CAAC,CAAC,SAAS,CAAC;YAC5B,gBAAgB,EAAE,KAAK,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,OAAO,CAAC,MAAM,CAAC;SACvE,CAAC,CAAC;QACL,MAAM,CACJ,GAAG,EAAE,CACH,IAAI,wCAAkB,CAAC,KAAK,EAAE,cAAc,EAAE;YAC5C,GAAG,iBAAiB;YACpB,cAAc;YACd,sBAAsB;YACtB,iBAAiB,EAAE,EAAE;SACtB,CAAC,CACL,CAAC,OAAO,CACP,iEAAiE,CAClE,CAAC;IACJ,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,+DAA+D,EAAE,GAAG,EAAE;QACvE,mEAAmE;QACnE,gDAAgD;QAChD,MAAM,EAAE,KAAK,EAAE,cAAc,EAAE,sBAAsB,EAAE,iBAAiB,EAAE,GACxE,KAAK,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC;QAClB,MAAM,CACJ,GAAG,EAAE,CACH,IAAI,wCAAkB,CAAC,KAAK,EAAE,cAAc,EAAE;YAC5C,GAAG,iBAAiB;YACpB,cAAc;YACd,sBAAsB;YACtB,gBAAgB,EAAE,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,WAAW,EAAE,IAAI,EAAE,CAAC;SACxD,CAAC,CACL,CAAC,OAAO,CACP,+HAA+H,CAChI,CAAC;IACJ,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,qEAAqE,EAAE,GAAG,EAAE;QAC7E,4DAA4D;QAC5D,MAAM,EAAE,KAAK,EAAE,cAAc,EAAE,sBAAsB,EAAE,iBAAiB,EAAE,GACxE,KAAK,CAAC,CAAC,OAAO,CAAC,EAAE;YACf,SAAS,EAAE,GAAG,EAAE,CAAC,CAAC,gBAAgB,CAAC;SACpC,CAAC,CAAC;QACL,MAAM,CACJ,GAAG,EAAE,CACH,IAAI,wCAAkB,CAAC,KAAK,EAAE,cAAc,EAAE;YAC5C,GAAG,iBAAiB;YACpB,cAAc;YACd,sBAAsB;YACtB,gBAAgB,EAAE,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,WAAW,EAAE,IAAI,EAAE,CAAC;SACxD,CAAC,CACL,CAAC,OAAO,CAAC,mDAAmD,CAAC,CAAC;IACjE,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,6EAA6E,EAAE,GAAG,EAAE;QACrF,MAAM,EAAE,KAAK,EAAE,cAAc,EAAE,sBAAsB,EAAE,iBAAiB,EAAE,GACxE,KAAK,CAAC,CAAC,KAAK,CAAC,EAAE;YACb,SAAS,EAAE,GAAG,EAAE,CAAC,CAAC,aAAa,CAAC;YAChC,QAAQ,EAAE,OAAO;SAClB,CAAC,CAAC;QACL,MAAM,CACJ,GAAG,EAAE,CACH,IAAI,wCAAkB,CAAC,KAAK,EAAE,cAAc,EAAE;YAC5C,GAAG,iBAAiB;YACpB,cAAc;YACd,sBAAsB;YACtB,gBAAgB,EAAE,CAAC,EAAE,IAAI,EAAE,YAAY,EAAE,WAAW,EAAE,KAAK,EAAE,CAAC;SAC/D,CAAC,CACL,CAAC,OAAO,CAAC,mDAAmD,CAAC,CAAC;IACjE,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,mEAAmE,EAAE,GAAG,EAAE;QAC3E,4EAA4E;QAC5E,MAAM,EAAE,KAAK,EAAE,cAAc,EAAE,sBAAsB,EAAE,iBAAiB,EAAE,GACxE,KAAK,CAAC,CAAC,MAAM,CAAC,EAAE;YACd,SAAS,EAAE,GAAG,EAAE,CAAC,CAAC,OAAO,CAAC;SAC3B,CAAC,CAAC;QACL,IAAI,wCAAkB,CAAC,KAAK,EAAE,cAAc,EAAE;YAC5C,GAAG,iBAAiB;YACpB,cAAc;YACd,sBAAsB;YACtB,gBAAgB,EAAE,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,WAAW,EAAE,IAAI,EAAE,CAAC;SACxD,CAAC,CAAC;QACH,MAAM,CAAC,YAAY,CAAC,KAAK,CAAC,CAAC,CAAC,OAAO,CACjC,MAAM,CAAC,eAAe,CAAC,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAC,CAC3C,CAAC;IACJ,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,0EAA0E,EAAE,GAAG,EAAE;QAClF,4EAA4E;QAC5E,8EAA8E;QAC9E,wEAAwE;QACxE,sDAAsD;QACtD,8EAA8E;QAC9E,MAAM,EAAE,KAAK,EAAE,iBAAiB,EAAE,GAAG,KAAK,CAAC,EAAE,CAAC,CAAC;QAC/C,IAAI,wCAAkB,CAAC,KAAK,EAAE,cAAc,EAAE;YAC5C,GAAG,iBAAiB;YACpB,WAAW,EAAE,sBAAsB;SACpC,CAAC,CAAC;QACH,0EAA0E;QAC1E,yEAAyE;QACzE,MAAM,CAAC,YAAY,CAAC,KAAK,CAAC,CAAC,CAAC,OAAO,CAAC;YAClC,eAAe;YACf,oCAAoC;YACpC,cAAc;SACf,CAAC,CAAC;QACH,MAAM,GAAG,GAAG,qBAAQ,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC,aAAa,CACjD,2BAA2B,CAC5B,CAAC;QACF,MAAM,IAAI,GAAG,MAAM,CAAC,MAAM,CAAC,GAAG,CAAC;aAC5B,GAAG,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,UAAU,CAAC,YAAsB,CAAC;aACjD,IAAI,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,QAAQ,CAAC,mBAAmB,CAAC,CAAC,CAAC;QAClD,4EAA4E;QAC5E,kCAAkC;QAClC,MAAM,CAAC,IAAI,CAAC,CAAC,SAAS,CAAC,4BAA4B,CAAC,CAAC;IACvD,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,uEAAuE,EAAE,GAAG,EAAE;QAC/E,sEAAsE;QACtE,6EAA6E;QAC7E,qEAAqE;QACrE,MAAM,EAAE,KAAK,EAAE,iBAAiB,EAAE,GAAG,KAAK,CAAC,EAAE,CAAC,CAAC;QAC/C,MAAM,CACJ,GAAG,EAAE,CACH,IAAI,wCAAkB,CAAC,KAAK,EAAE,cAAc,EAAE;YAC5C,GAAG,iBAAiB;YACpB,WAAW,EAAE,MAAM;YACnB,SAAS,EAAE;gBACT,qBAAqB,EAAE;oBACrB,oBAAoB,EAAE;wBACpB;4BACE,SAAS,EAAE,kCAAiB,CAAC,cAAc;4BAC3C,QAAQ,EAAE,IAAI,yBAAkB,CAAC,KAAK,EAAE,QAAQ,EAAE;gCAChD,IAAI,EAAE,6BAAY,CAAC,UAAU,CAC3B,mDAAmD,CACpD;6BACF,CAAC;yBACH;qBACF;iBACF;aACF;SACF,CAAC,CACL,CAAC,OAAO,CAAC,8DAA8D,CAAC,CAAC;IAC5E,CAAC,CAAC,CAAC;IAEH,MAAM,MAAM,GAAG,CAAC,KAAY,EAAE,SAA4B,EAAE,EAAE,CAAC,CAAC;QAC9D,SAAS;QACT,QAAQ,EAAE,IAAI,yBAAkB,CAAC,KAAK,EAAE,SAAS,SAAS,EAAE,EAAE;YAC5D,IAAI,EAAE,6BAAY,CAAC,UAAU,CAC3B,qEAAqE,CACtE;SACF,CAAC;KACH,CAAC,CAAC;IAEH,EAAE,CAAC,IAAI,CAAC,CAAC,wBAAwB,EAAE,sBAAsB,CAAU,CAAC,CAClE,wEAAwE,EACxE,CAAC,YAAY,EAAE,EAAE;QACf,uEAAuE;QACvE,2EAA2E;QAC3E,MAAM,EAAE,KAAK,EAAE,iBAAiB,EAAE,GAAG,KAAK,CAAC,EAAE,CAAC,CAAC;QAC/C,MAAM,CACJ,GAAG,EAAE,CACH,IAAI,wCAAkB,CAAC,KAAK,EAAE,cAAc,EAAE;YAC5C,GAAG,iBAAiB;YACpB,SAAS,EAAE;gBACT,CAAC,YAAY,CAAC,EAAE;oBACd,oBAAoB,EAAE;wBACpB,MAAM,CAAC,KAAK,EAAE,kCAAiB,CAAC,cAAc,CAAC;qBAChD;iBACF;aACF;SACF,CAAC,CACL,CAAC,OAAO,CACP,IAAI,MAAM,CAAC,eAAe,YAAY,yBAAyB,CAAC,CACjE,CAAC;IACJ,CAAC,CACF,CAAC;IAEF,EAAE,CAAC,8EAA8E,EAAE,GAAG,EAAE;QACtF,MAAM,EAAE,KAAK,EAAE,iBAAiB,EAAE,GAAG,KAAK,CAAC,EAAE,CAAC,CAAC;QAC/C,IAAI,wCAAkB,CAAC,KAAK,EAAE,cAAc,EAAE;YAC5C,GAAG,iBAAiB;YACpB,SAAS,EAAE;gBACT,sBAAsB,EAAE;oBACtB,oBAAoB,EAAE;wBACpB,MAAM,CAAC,KAAK,EAAE,kCAAiB,CAAC,eAAe,CAAC;qBACjD;iBACF;aACF;SACF,CAAC,CAAC;QACH,MAAM,MAAM,GAAG,MAAM,CAAC,MAAM,CAC1B,qBAAQ,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC,aAAa,CAAC,+BAA+B,CAAC,CACzE,CAAC,CAAC,CAAC,CAAC,UAAU,CAAC,kBAAkB,CAAC;QACnC,MAAM,UAAU,GACd,MAAM,CAAC,oBAAoB,CAAC,oBAG7B,CAAC,GAAG,CAAC,CAAC,WAAW,EAAE,EAAE,CAAC,WAAW,CAAC,SAAS,CAAC,CAAC;QAC9C,MAAM,CAAC,UAAU,CAAC,IAAI,EAAE,CAAC,CAAC,OAAO,CAAC,CAAC,gBAAgB,EAAE,iBAAiB,CAAC,CAAC,CAAC;IAC3E,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,wDAAwD,EAAE,GAAG,EAAE;QAChE,MAAM,EAAE,KAAK,EAAE,iBAAiB,EAAE,GAAG,KAAK,CAAC,EAAE,EAAE,EAAE,QAAQ,EAAE,OAAO,EAAE,CAAC,CAAC;QACtE,IAAI,wCAAkB,CAAC,KAAK,EAAE,cAAc,EAAE;YAC5C,GAAG,iBAAiB;YACpB,WAAW,EAAE,MAAM;SACpB,CAAC,CAAC;QACH,MAAM,CAAC,YAAY,CAAC,KAAK,CAAC,CAAC,CAAC,SAAS,CAAC,oBAAoB,CAAC,CAAC;QAC5D,MAAM,GAAG,GAAG,qBAAQ,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC,aAAa,CACjD,2BAA2B,CAC5B,CAAC;QACF,MAAM,IAAI,GAAG,MAAM,CAAC,MAAM,CAAC,GAAG,CAAC;aAC5B,GAAG,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,UAAU,CAAC,YAAsB,CAAC;aACjD,IAAI,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,QAAQ,CAAC,mBAAmB,CAAC,CAAC,CAAC;QAClD,yEAAyE;QACzE,mEAAmE;QACnE,MAAM,CAAC,IAAI,CAAC,CAAC,SAAS,CAAC,gCAAgC,CAAC,CAAC;IAC3D,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,+DAA+D,EAAE,GAAG,EAAE;QACvE,8EAA8E;QAC9E,gFAAgF;QAChF,+EAA+E;QAC/E,8EAA8E;QAC9E,6EAA6E;QAC7E,mCAAmC;QACnC,KAAK,MAAM,WAAW,IAAI;YACxB,+CAA+C;YAC/C,0CAA0C;SAC3C,EAAE,CAAC;YACF,MAAM,EAAE,KAAK,EAAE,iBAAiB,EAAE,GAAG,KAAK,CAAC,EAAE,CAAC,CAAC;YAC/C,IAAI,wCAAkB,CAAC,KAAK,EAAE,cAAc,EAAE;gBAC5C,GAAG,iBAAiB;gBACpB,WAAW;aACZ,CAAC,CAAC;YACH,MAAM,CAAC,YAAY,CAAC,KAAK,CAAC,CAAC,CAAC,SAAS,CACnC,oCAAoC,CACrC,CAAC;YACF,MAAM,IAAI,GAAG,MAAM,CAAC,MAAM,CACxB,qBAAQ,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC,aAAa,CAAC,2BAA2B,CAAC,CACrE;iBACE,GAAG,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,UAAU,CAAC,YAAsB,CAAC;iBACjD,IAAI,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,QAAQ,CAAC,mBAAmB,CAAC,CAAC,CAAC;YAClD,MAAM,CAAC,IAAI,CAAC,CAAC,SAAS,CAAC,4BAA4B,CAAC,CAAC;QACvD,CAAC;IACH,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,qDAAqD,EAAE,GAAG,EAAE;QAC7D,+EAA+E;QAC/E,yEAAyE;QACzE,8EAA8E;QAC9E,6EAA6E;QAC7E,KAAK,MAAM,CAAC,WAAW,EAAE,QAAQ,CAAC,IAAI;YACpC,CAAC,yBAAyB,EAAE,SAAS,CAAC;YACtC,CAAC,0BAA0B,EAAE,SAAS,CAAC;YACvC,CAAC,mBAAmB,EAAE,SAAS,CAAC;YAChC,CAAC,OAAO,EAAE,OAAO,CAAC;YAClB,CAAC,8BAA8B,EAAE,OAAO,CAAC;YACzC,CAAC,EAAE,EAAE,SAAS,CAAC;SACP,EAAE,CAAC;YACX,MAAM,EAAE,KAAK,EAAE,iBAAiB,EAAE,GAAG,KAAK,CAAC,EAAE,EAAE,EAAE,QAAQ,EAAE,CAAC,CAAC;YAC7D,IAAI,wCAAkB,CAAC,KAAK,EAAE,cAAc,EAAE;gBAC5C,GAAG,iBAAiB;gBACpB,WAAW;aACZ,CAAC,CAAC;YACH,MAAM,QAAQ,GAAG,YAAY,CAAC,KAAK,CAAC,CAAC;YACrC,MAAM,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,QAAQ,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC,YAAY,CACrE,CAAC,CACF,CAAC;YACF,yEAAyE;YACzE,6BAA6B;YAC7B,MAAM,KAAK,GAAG,MAAM,CAAC,MAAM,CACzB,qBAAQ,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC,aAAa,CAAC,2BAA2B,CAAC,CACrE,CAAC,GAAG,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,UAAU,CAAC,YAAsB,CAAC,CAAC;YACpD,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,QAAQ,CAAC,mBAAmB,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QAC3E,CAAC;IACH,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,oDAAoD,EAAE,GAAG,EAAE;QAC5D,MAAM,EAAE,KAAK,EAAE,iBAAiB,EAAE,GAAG,KAAK,CAAC,EAAE,EAAE;YAC7C,gBAAgB,EAAE,KAAK,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,OAAO,CAAC,MAAM,CAAC;SACvE,CAAC,CAAC;QACH,0EAA0E;QAC1E,uEAAuE;QACvE,mBAAmB;QACnB,MAAM,CACJ,GAAG,EAAE,CACH,IAAI,wCAAkB,CAAC,KAAK,EAAE,cAAc,EAAE;YAC5C,GAAG,iBAAiB;YACpB,WAAW,EAAE,MAAM;YACnB,iBAAiB,EAAE,EAAE;SACtB,CAAC,CACL,CAAC,OAAO,CAAC,6DAA6D,CAAC,CAAC;IAC3E,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,+DAA+D,EAAE,GAAG,EAAE;QACvE,yEAAyE;QACzE,4EAA4E;QAC5E,MAAM,EAAE,KAAK,EAAE,iBAAiB,EAAE,GAAG,KAAK,CAAC,EAAE,CAAC,CAAC;QAC/C,IAAI,wCAAkB,CAAC,KAAK,EAAE,cAAc,EAAE,iBAAiB,CAAC,CAAC;QACjE,qBAAQ,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC,qBAAqB,CAC7C,8BAA8B,EAC9B;YACE,iBAAiB,EAAE,kBAAK,CAAC,UAAU,CAAC;gBAClC,OAAO,EAAE,kBAAK,CAAC,gBAAgB,CAAC,SAAS,CAAC;gBAC1C,UAAU,EAAE,CAAC;gBACb,MAAM,EAAE,CAAC;aACV,CAAC;SACH,CACF,CAAC;IACJ,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,kDAAkD,EAAE,GAAG,EAAE;QAC1D,+EAA+E;QAC/E,2EAA2E;QAC3E,8EAA8E;QAC9E,sEAAsE;QACtE,sEAAsE;QACtE,4EAA4E;QAC5E,MAAM,EAAE,KAAK,EAAE,iBAAiB,EAAE,GAAG,KAAK,CAAC,EAAE,EAAE;YAC7C,gBAAgB,EAAE,CAAC,iBAAiB,EAAE,aAAa,EAAE,aAAa,CAAC;SACpE,CAAC,CAAC;QACH,IAAI,wCAAkB,CAAC,KAAK,EAAE,cAAc,EAAE,iBAAiB,CAAC,CAAC;QACjE,MAAM,CAAC,YAAY,CAAC,KAAK,CAAC,CAAC,CAAC,OAAO,CACjC,MAAM,CAAC,eAAe,CAAC;YACrB,iBAAiB;YACjB,oCAAoC;YACpC,GAAG,GAAG,CAAC,MAAM,CAAC,EAAE,CAAC,MAAM;YACvB,aAAa;SACd,CAAC,CACH,CAAC;IACJ,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,iDAAiD,EAAE,GAAG,EAAE;QACzD,MAAM,EAAE,KAAK,EAAE,iBAAiB,EAAE,GAAG,KAAK,CAAC,EAAE,CAAC,CAAC;QAC/C,IAAI,wCAAkB,CAAC,KAAK,EAAE,cAAc,EAAE;YAC5C,GAAG,iBAAiB;YACpB,gBAAgB,EAAE,CAAC,EAAE,IAAI,EAAE,WAAW,EAAE,WAAW,EAAE,IAAI,EAAE,CAAC;SAC7D,CAAC,CAAC;QACH,MAAM,CAAC,YAAY,CAAC,KAAK,CAAC,CAAC,CAAC,SAAS,CAAC,aAAa,CAAC,CAAC;IACvD,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,8DAA8D,EAAE,GAAG,EAAE;QACtE,MAAM,EAAE,KAAK,EAAE,iBAAiB,EAAE,GAAG,KAAK,CAAC,EAAE,EAAE;YAC7C,gBAAgB,EAAE,CAAC,GAAG,GAAG,CAAC,MAAM,CAAC,GAAG,CAAC,MAAM,CAAC;SAC7C,CAAC,CAAC;QACH,MAAM,CACJ,GAAG,EAAE,CAAC,IAAI,wCAAkB,CAAC,KAAK,EAAE,cAAc,EAAE,iBAAiB,CAAC,CACvE,CAAC,OAAO,CAAC,+CAA+C,CAAC,CAAC;IAC7D,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,8DAA8D,EAAE,GAAG,EAAE;QACtE,0EAA0E;QAC1E,4EAA4E;QAC5E,mEAAmE;QACnE,MAAM,EAAE,KAAK,EAAE,iBAAiB,EAAE,GAAG,KAAK,CAAC,EAAE,CAAC,CAAC;QAC/C,IAAI,wCAAkB,CAAC,KAAK,EAAE,cAAc,EAAE;YAC5C,GAAG,iBAAiB;YACpB,gBAAgB,EAAE;gBAChB,EAAE,IAAI,EAAE,MAAM,EAAE,WAAW,EAAE,IAAI,EAAE;gBACnC,EAAE,IAAI,EAAE,GAAG,EAAE,WAAW,EAAE,KAAK,EAAE;gBACjC,EAAE,IAAI,EAAE,QAAQ,EAAE,WAAW,EAAE,IAAI,EAAE;aACtC;SACF,CAAC,CAAC;QACH,MAAM,QAAQ,GAAG,YAAY,CAAC,KAAK,CAAC,CAAC;QACrC,MAAM,CAAC,QAAQ,CAAC,CAAC,GAAG,CAAC,SAAS,CAAC,GAAG,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;QACrD,MAAM,CAAC,QAAQ,CAAC,CAAC,GAAG,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC;QACtC,+DAA+D;QAC/D,MAAM,CAAC,QAAQ,CAAC,CAAC,SAAS,CAAC,GAAG,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC;QACnD,wBAAW,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC,UAAU,CACrC,GAAG,EACH,kBAAK,CAAC,gBAAgB,CAAC,aAAa,CAAC,CACtC,CAAC;IACJ,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,2DAA2D,EAAE,GAAG,EAAE;QACnE,MAAM,EAAE,KAAK,EAAE,iBAAiB,EAAE,GAAG,KAAK,CAAC,EAAE,EAAE;YAC7C,gBAAgB,EAAE;gBAChB,GAAG,KAAK,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,OAAO,CAAC,MAAM,CAAC;gBACvD,GAAG;aACJ;SACF,CAAC,CAAC;QACH,wEAAwE;QACxE,MAAM,CACJ,GAAG,EAAE,CACH,IAAI,wCAAkB,CAAC,KAAK,EAAE,cAAc,EAAE;YAC5C,GAAG,iBAAiB;YACpB,iBAAiB,EAAE,EAAE;SACtB,CAAC,CACL,CAAC,GAAG,CAAC,OAAO,EAAE,CAAC;IAClB,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,kEAAkE,EAAE,GAAG,EAAE;QAC1E,2EAA2E;QAC3E,uEAAuE;QACvE,qBAAqB;QACrB,MAAM,IAAI,GAAG,GAAG,GAAG,CAAC,MAAM,CAAC,EAAE,CAAC,MAAM,CAAC;QACrC,MAAM,EAAE,KAAK,EAAE,iBAAiB,EAAE,GAAG,KAAK,CAAC,EAAE,EAAE;YAC7C,gBAAgB,EAAE,CAAC,IAAI,CAAC;SACzB,CAAC,CAAC;QACH,MAAM,CACJ,GAAG,EAAE,CACH,IAAI,wCAAkB,CAAC,KAAK,EAAE,cAAc,EAAE;YAC5C,GAAG,iBAAiB;YACpB,QAAQ,EAAE,OAAO;SAClB,CAAC,CACL,CAAC,OAAO,CAAC,+CAA+C,CAAC,CAAC;QAE3D,MAAM,EAAE,KAAK,EAAE,QAAQ,EAAE,iBAAiB,EAAE,QAAQ,EAAE,GAAG,KAAK,CAAC,EAAE,CAAC,CAAC;QACnE,MAAM,CACJ,GAAG,EAAE,CACH,IAAI,wCAAkB,CAAC,QAAQ,EAAE,cAAc,EAAE;YAC/C,GAAG,QAAQ;YACX,kDAAkD;YAClD,gBAAgB,EAAE;gBAChB,EAAE,IAAI,EAAE,KAAK,GAAG,CAAC,MAAM,CAAC,EAAE,CAAC,EAAE,EAAE,WAAW,EAAE,IAAI,EAAE;aACnD;SACF,CAAC,CACL,CAAC,OAAO,CAAC,uBAAuB,CAAC,CAAC;IACrC,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,+DAA+D,EAAE,GAAG,EAAE;QACvE,2EAA2E;QAC3E,qEAAqE;QACrE,yEAAyE;QACzE,MAAM,EAAE,KAAK,EAAE,iBAAiB,EAAE,GAAG,KAAK,CAAC,EAAE,CAAC,CAAC;QAC/C,IAAI,wCAAkB,CAAC,KAAK,EAAE,cAAc,EAAE;YAC5C,GAAG,iBAAiB;YACpB,SAAS,EAAE;gBACT,uBAAuB,EAAE,EAAE,MAAM,EAAE,sBAAQ,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE;aACzD;SACF,CAAC,CAAC;QACH,qBAAQ,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC,qBAAqB,CAC7C,8BAA8B,EAC9B;YACE,iBAAiB,EAAE,kBAAK,CAAC,UAAU,CAAC;gBAClC,OAAO,EAAE,kBAAK,CAAC,gBAAgB,CAAC,SAAS,CAAC;gBAC1C,UAAU,EAAE,CAAC;gBACb,MAAM,EAAE,CAAC;gBACT,MAAM,EAAE,CAAC;gBACT,wCAAwC,EAAE;oBACxC,aAAa,EAAE,EAAE,cAAc,EAAE,MAAM,EAAE;oBACzC,0BAA0B,EAAE,KAAK;oBACjC,wBAAwB,EAAE,KAAK;oBAC/B,aAAa,EAAE,EAAE,cAAc,EAAE,MAAM,EAAE;oBACzC,kBAAkB,EAAE,EAAE,mBAAmB,EAAE,MAAM,EAAE;iBACpD;aACF,CAAC;SACH,CACF,CAAC;IACJ,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,iEAAiE,EAAE,GAAG,EAAE;QACzE,0EAA0E;QAC1E,yEAAyE;QACzE,MAAM,EAAE,KAAK,EAAE,iBAAiB,EAAE,GAAG,KAAK,CAAC,EAAE,CAAC,CAAC;QAC/C,IAAI,wCAAkB,CAAC,KAAK,EAAE,cAAc,EAAE;YAC5C,GAAG,iBAAiB;YACpB,SAAS,EAAE;gBACT,uBAAuB,EAAE;oBACvB,MAAM,EAAE,sBAAQ,CAAC,OAAO,CAAC,CAAC,CAAC;oBAC3B,UAAU,EAAE,sBAAQ,CAAC,KAAK,CAAC,CAAC,CAAC;iBAC9B;aACF;SACF,CAAC,CAAC;QACH,qBAAQ,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC,qBAAqB,CAC7C,8BAA8B,EAC9B;YACE,iBAAiB,EAAE,kBAAK,CAAC,UAAU,CAAC;gBAClC,OAAO,EAAE,kBAAK,CAAC,gBAAgB,CAAC,SAAS,CAAC;gBAC1C,MAAM,EAAE,IAAI;gBACZ,wCAAwC,EAAE,kBAAK,CAAC,UAAU,CAAC;oBACzD,aAAa,EAAE,EAAE,cAAc,EAAE,KAAK,EAAE;oBACxC,kBAAkB,EAAE,EAAE,mBAAmB,EAAE,KAAK,EAAE;iBACnD,CAAC;aACH,CAAC;SACH,CACF,CAAC;IACJ,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,yDAAyD,EAAE,GAAG,EAAE;QACjE,yEAAyE;QACzE,0EAA0E;QAC1E,yCAAyC;QACzC,MAAM,EAAE,KAAK,EAAE,iBAAiB,EAAE,GAAG,KAAK,CAAC,EAAE,CAAC,CAAC;QAC/C,IAAI,wCAAkB,CAAC,KAAK,EAAE,cAAc,EAAE,iBAAiB,CAAC,CAAC;QACjE,MAAM,QAAQ,GAAG,qBAAQ,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC,aAAa,CACtD,8BAA8B,EAC9B;YACE,UAAU,EAAE;gBACV,iBAAiB,EAAE,EAAE,OAAO,EAAE,kBAAK,CAAC,gBAAgB,CAAC,SAAS,CAAC,EAAE;aAClE;SACF,CACF,CAAC;QACF,MAAM,CAAC,MAAM,CAAC,GAAG,MAAM,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;QACzC,MAAM,OAAO,GACX,MAAM,CAAC,UAAU,CAAC,iBAAiB;aAChC,wCAAwC,CAAC,aAAa,CAAC,OAAO,CAAC;QACpE,MAAM,CAAC,OAAO,CAAC,CAAC,GAAG,CAAC,SAAS,CAAC,gBAAgB,CAAC,CAAC;QAChD,MAAM,CAAC,OAAO,CAAC,CAAC,GAAG,CAAC,SAAS,CAAC,mBAAmB,CAAC,CAAC;QACnD,MAAM,CAAC,OAAO,CAAC,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC;IACnC,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,6DAA6D,EAAE,GAAG,EAAE;QACrE,MAAM,EAAE,KAAK,EAAE,cAAc,EAAE,sBAAsB,EAAE,iBAAiB,EAAE,GACxE,KAAK,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC;QACjB,MAAM,CACJ,GAAG,EAAE,CACH,IAAI,wCAAkB,CAAC,KAAK,EAAE,cAAc,EAAE;YAC5C,GAAG,iBAAiB;YACpB,UAAU,EAAE,sBAAU,CAAC,iBAAiB;YACxC,YAAY,EAAE,SAAS;YACvB,cAAc;YACd,sBAAsB;SACvB,CAAC,CACL,CAAC,OAAO,CAAC,yCAAyC,CAAC,CAAC;IACvD,CAAC,CAAC,CAAC;AACL,CAAC,CAAC,CAAC;AAEH;;;;;;;GAOG;AACH,QAAQ,CAAC,wCAAwC,EAAE,GAAG,EAAE;IActD,MAAM,OAAO,GAAG,CAAC,GAAG,EAAE;QACpB,MAAM,KAAK,GAAG,IAAI,mBAAK,CAAC,IAAI,iBAAG,EAAE,EAAE,SAAS,CAAC,CAAC;QAC9C,MAAM,EAAE,GAAG,IAAI,qBAAc,CAAC,KAAK,EAAE,IAAI,EAAE;YACzC,IAAI,EAAE,iBAAI,CAAC,UAAU,CAAC,6BAA6B,CAAC;YACpD,OAAO,EAAE,eAAe;YACxB,OAAO,EAAE,oBAAO,CAAC,WAAW;SAC7B,CAAC,CAAC;QACH,IAAI,wCAAkB,CAAC,KAAK,EAAE,cAAc,EAAE;YAC5C,YAAY,EAAE,IAAI,eAAM,CAAC,KAAK,EAAE,QAAQ,CAAC;YACzC,WAAW,EAAE,IAAI,wBAAW,CAAC,KAAK,EAAE,KAAK,EAAE;gBACzC,QAAQ,EAAE,EAAE;gBACZ,QAAQ,EAAE,gCAAmB,CAAC,OAAO;aACtC,CAAC;YACF,UAAU,EAAE,sBAAU,CAAC,gBAAgB;YACvC,gBAAgB,EAAE,EAAE;SACrB,CAAC,CAAC;QACH,MAAM,SAAS,GAAG,qBAAQ,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC,aAAa,CACvD,2BAA2B,CAC5B,CAAC;QACF,MAAM,IAAI,GAAG,MAAM,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC,UAAU,CAAC,YAAsB,CAAC;QAC3E,OAAO,IAAA,yBAAe,EAAC,GAAG,IAAI,WAAW,CAErB,CAAC;IACvB,CAAC,CAAC,EAAE,CAAC;IAEL,MAAM,IAAI,GAAG,CACX,GAAW,EACX,cAA0C,EAAE,EAC5B,EAAE,CAClB,OAAO,CAAC;QACN,OAAO,EAAE,EAAE,GAAG,EAAE,WAAW,EAAE,OAAO,EAAE,EAAE,IAAI,EAAE,EAAE,KAAK,EAAE,QAAQ,EAAE,EAAE,EAAE;KACtE,CAAC,CAAC;IAEL,MAAM,QAAQ,GAAG,CAAC,MAAsB,EAAE,EAAE,CAAC,CAAC;QAC5C,UAAU,EAAG,MAAiC,CAAC,UAAU;QACzD,QAAQ,EAAE,MAAM,CAAC,OAAO,CAAC,QAAQ,EAAE,KAAK;KACzC,CAAC,CAAC;IAEH,EAAE,CAAC,IAAI,CAAC;QACN,CAAC,IAAI,EAAE,GAAG,CAAC;QACX,CAAC,KAAK,EAAE,GAAG,CAAC;QACZ,CAAC,WAAW,EAAE,UAAU,CAAC;QACzB,CAAC,kBAAkB,EAAE,iBAAiB,CAAC;QACvC,CAAC,OAAO,EAAE,MAAM,CAAC;KAClB,CAAC,CAAC,+BAA+B,EAAE,CAAC,GAAG,EAAE,QAAQ,EAAE,EAAE;QACpD,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,EAAE,UAAU,EAAE,GAAG,EAAE,QAAQ,EAAE,CAAC,CAAC;IACrE,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,0DAA0D,EAAE,GAAG,EAAE;QAClE,yEAAyE;QACzE,0DAA0D;QAC1D,MAAM,MAAM,GAAG,IAAI,CAAC,OAAO,EAAE;YAC3B,IAAI,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE;YACvB,CAAC,EAAE,EAAE,KAAK,EAAE,GAAG,EAAE,UAAU,EAAE,CAAC,EAAE,KAAK,EAAE,GAAG,EAAE,EAAE,EAAE,KAAK,EAAE,GAAG,EAAE,CAAC,EAAE;YAC/D,IAAI,EAAE,EAAE,KAAK,EAAE,EAAE,EAAE;SACpB,CAAC,CAAC;QACH,MAAM,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,QAAQ,CAAC,CAAC,IAAI,CAAC,6BAA6B,CAAC,CAAC;IACxE,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,iEAAiE,EAAE,GAAG,EAAE;QACzE,mEAAmE;QACnE,MAAM,MAAM,GAAG,IAAI,CAAC,OAAO,EAAE;YAC3B,CAAC,EAAE,EAAE,KAAK,EAAE,UAAU,EAAE;YACxB,CAAC,EAAE,EAAE,KAAK,EAAE,KAAK,EAAE;SACpB,CAAC,CAAC;QACH,MAAM,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,QAAQ,CAAC,CAAC,IAAI,CAAC,uBAAuB,CAAC,CAAC;IAClE,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,2DAA2D,EAAE,GAAG,EAAE;QACnE,MAAM,MAAM,GAAG,IAAI,CAAC,MAAM,CAAoB,CAAC;QAC/C,MAAM,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;QAChC,8EAA8E;QAC9E,gEAAgE;QAChE,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC,kBAAkB,CAAC,CAAC,KAAK,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;IAClE,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,+CAA+C,EAAE,GAAG,EAAE;QACvD,wEAAwE;QACxE,kEAAkE;QAClE,MAAM,MAAM,GAAG,OAAO,CAAC;YACrB,OAAO,EAAE;gBACP,GAAG,EAAE,IAAI;gBACT,WAAW,EAAE,EAAE;gBACf,OAAO,EAAE;oBACP,IAAI,EAAE,EAAE,KAAK,EAAE,QAAQ,EAAE;oBACzB,kBAAkB,EAAE,EAAE,KAAK,EAAE,WAAW,EAAE;iBAC3C;aACF;SACF,CAAoB,CAAC;QACtB,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC,kBAAkB,CAAC,CAAC,KAAK,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;IAClE,CAAC,CAAC,CAAC;AACL,CAAC,CAAC,CAAC","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"]}