cdk-nextjs 0.6.1 → 0.7.0

package/lib/nextjs-distribution.js

@@ -5,11 +5,13 @@ const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
 const aws_cdk_lib_1 = require("aws-cdk-lib");
 const aws_cloudfront_1 = require("aws-cdk-lib/aws-cloudfront");
 const aws_cloudfront_origins_1 = require("aws-cdk-lib/aws-cloudfront-origins");
+const aws_lambda_1 = require("aws-cdk-lib/aws-lambda");
 const constructs_1 = require("constructs");
+const function_groups_1 = require("./adapter/function-groups");
 const constants_1 = require("./constants");
 const base_path_1 = require("./utils/base-path");
 class NextjsDistribution extends constructs_1.Construct {
-    static [JSII_RTTI_SYMBOL_1] = { fqn: "cdk-nextjs.NextjsDistribution", version: "0.6.1" };
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "cdk-nextjs.NextjsDistribution", version: "0.7.0" };
     distribution;
     props;
     /**
@@ -19,6 +21,13 @@ class NextjsDistribution extends constructs_1.Construct {
      * relying on the caller having passed one.
      */
     basePath;
+    /**
+     * `props.assetPrefix` normalized to a leading-slash path, `""` when the app
+     * sets none or sets one that already equals the `basePath` prefix — in which
+     * case the ordinary `_next/static*` behavior already covers it and a second one
+     * would be a duplicate pattern CloudFront rejects.
+     */
+    assetPrefix;
     /**
      * Common security headers applied by default to all origins
      * @see https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/using-managed-response-headers-policies.html#managed-response-headers-policies-security
@@ -43,7 +52,6 @@ class NextjsDistribution extends constructs_1.Construct {
     };
     staticOrigin;
     dynamicOrigin;
-    imageOrigin;
     dynamicOriginResponsePolicy;
     dynamicCloudFrontFunctionAssociations;
     isFunctionCompute;
@@ -54,10 +62,11 @@ class NextjsDistribution extends constructs_1.Construct {
         super(scope, id);
         this.props = props;
         this.basePath = (0, base_path_1.normalizeBasePath)(props.basePath);
+        this.assetPrefix = this.resolveAssetPrefix();
         this.staticOrigin = this.createStaticOrigin();
         this.isFunctionCompute = props.nextjsType === constants_1.NextjsType.GLOBAL_FUNCTIONS;
+        this.validateFunctionGroupProps();
         this.dynamicOrigin = this.createDynamicOrigin();
-        this.imageOrigin = this.createImageOrigin();
         this.dynamicOriginResponsePolicy = this.createDynamicOriginRequestPolicy();
         this.dynamicCloudFrontFunctionAssociations =
             this.createDynamicCloudFrontFunctionAssociations();
@@ -65,6 +74,9 @@ class NextjsDistribution extends constructs_1.Construct {
         this.dynamicBehaviorOptions = this.createDynamicBehaviorOptions();
         this.imageBehaviorOptions = this.createImageBehaviorOptions();
         this.distribution = this.getDistribution();
+        if (this.isFunctionCompute) {
+            this.grantInvoke(function_groups_1.DEFAULT_FUNCTION_GROUP, props.functionUrl);
+        }
         this.addStaticBehaviors();
         this.addDynamicBehaviors();
     }
@@ -80,7 +92,11 @@ class NextjsDistribution extends constructs_1.Construct {
         return fullComment.length < 128 ? fullComment : baseComment;
     }
     createStaticOrigin() {
-        return aws_cloudfront_origins_1.S3BucketOrigin.withOriginAccessControl(this.props.assetsBucket, this.props.overrides?.s3BucketOriginProps);
+        return aws_cloudfront_origins_1.S3BucketOrigin.withOriginAccessControl(this.props.assetsBucket, {
+            // LIST lets S3 answer a missing key with 404 instead of 403
+            originAccessLevels: [aws_cloudfront_1.AccessLevel.READ, aws_cloudfront_1.AccessLevel.LIST],
+            ...this.props.overrides?.s3BucketOriginProps,
+        });
     }
     createDynamicOrigin() {
         if (this.isFunctionCompute) {
@@ -102,35 +118,22 @@ class NextjsDistribution extends constructs_1.Construct {
             });
         }
     }
-    /**
-     * A dedicated image optimization Lambda is only wired up when
-     * {@link NextjsDistributionProps.imageFunctionUrl} is supplied, which today
-     * only `NextjsType.GLOBAL_FUNCTIONS` does. Otherwise `_next/image*` keeps
-     * going to the dynamic origin, where the Next.js server optimizes images
-     * itself.
-     *
-     * The `_next/image*` behavior is kept either way: its cache policy
-     * (`queryStringBehavior: all()`, `accept` in the cache key) is the right one
-     * for image requests regardless of which origin answers them.
-     */
-    createImageOrigin() {
-        if (!this.isFunctionCompute || !this.props.imageFunctionUrl) {
-            return this.dynamicOrigin;
-        }
-        return aws_cloudfront_origins_1.FunctionUrlOrigin.withOriginAccessControl(this.props.imageFunctionUrl, {
-            ...this.props.overrides?.dynamicFunctionUrlOriginWithOACProps,
-            ...this.props.overrides?.imageFunctionUrlOriginWithOACProps,
-        });
-    }
     /**
      * Lambda Function URLs "expect the `Host` header to contain the origin domain
      * name, not the domain name of the CloudFront distribution."
+     *
+     * A container origin also gets CloudFront's own headers, for
+     * `CloudFront-Forwarded-Proto`: without a certificate CloudFront reaches the
+     * ALB over plain HTTP, so the ALB's `X-Forwarded-Proto` is `http`, and the
+     * runtime would build every absolute URL (`request.url`, the origin a server
+     * action is forwarded to) as `http://` behind a viewer on HTTPS.
      * @see https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/using-managed-origin-request-policies.html#managed-origin-request-policy-all-viewer-except-host-header
+     * @see https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/using-managed-origin-request-policies.html#managed-origin-request-policy-all-viewer-and-cloudfront
      */
     createDynamicOriginRequestPolicy() {
         return this.isFunctionCompute
             ? aws_cloudfront_1.OriginRequestPolicy.ALL_VIEWER_EXCEPT_HOST_HEADER
-            : aws_cloudfront_1.OriginRequestPolicy.ALL_VIEWER;
+            : aws_cloudfront_1.OriginRequestPolicy.ALL_VIEWER_AND_CLOUDFRONT_2022;
     }
     /**
      * Ensures Next.js `request.url` will be correct domain instead of URL of
@@ -141,9 +144,66 @@ class NextjsDistribution extends constructs_1.Construct {
         const associations = [];
         if (this.isFunctionCompute) {
             const cloudFrontFn = new aws_cloudfront_1.Function(this, "CloudFrontFn", {
+                // cloudfront-js-1.0, so ES5.1: `var`, no arrow functions, no template
+                // literals, no `Object.keys`.
                 code: aws_cloudfront_1.FunctionCode.fromInline(`
           function handler(event) {
             var request = event.request;
+            var uri = request.uri;
+
+            // Next.js answers any path containing a backslash or a repeated
+            // slash with a 308 to the collapsed path
+            // (\`normalizeRepeatedSlashes\`, called from \`base-server.ts\`), and so
+            // does this runtime. Behind a Lambda Function URL the origin never
+            // gets the chance: Origin Access Control signs the raw path while the
+            // Function URL canonicalizes it before verifying, so the origin
+            // answers 403 SignatureDoesNotMatch. Doing the redirect here is what
+            // makes \`/basepath//to-sv\` behave as it does under \`next start\`.
+            //
+            // A bare \`//\` reaches here too, and is answered the same way -
+            // measured, because \`//\` at the start of a request target is also the
+            // authority form and it was not obvious CloudFront would route it to a
+            // function at all. It does: \`GET //\` answers 308 to \`/\` with
+            // \`x-cache: FunctionGeneratedResponse\`, over both HTTP/1.1 and HTTP/2,
+            // which is what \`test/e2e/hydration\` asks for.
+            //
+            // Two things Next.js does that this cannot:
+            //
+            // - the body it sends with its own redirect (the destination, as
+            //   text), because a generated response can only carry one on
+            //   cloudfront-js-2.0. No known client reads it.
+            // - the original order of the query string. The event exposes
+            //   \`querystring\` as an object, never as the raw string, so
+            //   \`/x//y?a=1&b=2\` redirects to \`/x/y?b=2&a=1\`. The pairs all
+            //   survive; only their order is CloudFront's rather than the
+            //   client's, and a redirect target is not order-sensitive.
+            //
+            // A repeated key's \`multiValue\` already holds its first value, which
+            // \`value\` repeats, so it is one or the other, never both. Names and
+            // values arrive as the client sent them, still percent-encoded
+            // (measured: \`?a=%20b%26c&p=1+2\` reads back unchanged), so they are
+            // joined as-is; encoding them again would turn \`%20\` into \`%2520\`.
+            if (/\\\\|\\/\\//.test(uri)) {
+              var location = uri.replace(/\\\\/g, "/").replace(/\\/\\/+/g, "/");
+              var qs = [];
+              for (var name in request.querystring) {
+                var q = request.querystring[name];
+                var values = q.multiValue || [q];
+                for (var i = 0; i < values.length; i++) {
+                  var v = values[i].value;
+                  qs.push(v === "" ? name : name + "=" + v);
+                }
+              }
+              if (qs.length) {
+                location = location + "?" + qs.join("&");
+              }
+              return {
+                statusCode: 308,
+                statusDescription: "Permanent Redirect",
+                headers: { location: { value: location } },
+              };
+            }
+
             request.headers["x-forwarded-host"] = request.headers.host;
             return request;
           }
@@ -176,30 +236,21 @@ class NextjsDistribution extends constructs_1.Construct {
     }
     createDynamicBehaviorOptions() {
         const dynamicBehaviorOptions = this.props.overrides?.dynamicBehaviorOptions;
+        const cachePolicyProps = this.props.overrides?.dynamicCachePolicyProps;
         // create default cache policy if not provided
         const cachePolicy = dynamicBehaviorOptions?.cachePolicy ??
             new aws_cloudfront_1.CachePolicy(this, "DynamicCachePolicy", {
-                queryStringBehavior: aws_cloudfront_1.CacheQueryStringBehavior.all(),
-                headerBehavior: aws_cloudfront_1.CacheHeaderBehavior.allowList(
-                // NOTE: CloudFront Custom Cache Policies have soft max of 10 headers
-                // cdk-nextjs includes the most essential headers for Next.js functionality
-                // but it's recommended to request quota increase to include all headers (commented out ones below)
-                // more here: https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/cloudfront-limits.html#limits-policies
-                "accept", // content negotiation (HTML vs RSC payload)
-                "rsc", // React Server Components requests
-                "next-url", // Next.js routing
-                "next-router-state-tree", // App Router navigation state
-                "next-router-prefetch", // prefetch behavior
-                "next-router-segment-prefetch", // segment-level prefetching
-                "x-matched-path", // dynamic routes and rewrites
-                "x-prerender-revalidate", // on-demand ISR revalidation
-                "x-next-cache-tags", // tag-based cache revalidation
-                "x-prerender-bypass"),
-                cookieBehavior: aws_cloudfront_1.CacheCookieBehavior.all(),
-                enableAcceptEncodingBrotli: true,
-                enableAcceptEncodingGzip: true,
+                ...(isCachingDisabled(cachePolicyProps)
+                    ? DISABLED_CACHE_KEY
+                    : DYNAMIC_CACHE_KEY),
+                // A response with no `Cache-Control` is not cached, which is what Next.js
+                // and every app written for it assume: a dynamic route handler sets none.
+                // CDK's default is a day, which cached `/api/*` responses at the edge for
+                // 24 hours. Anything Next.js *means* to cache - ISR, SSG, a PPR shell -
+                // says so with `s-maxage`, which `maxTtl` still honors.
+                defaultTtl: aws_cdk_lib_1.Duration.seconds(0),
                 comment: this.getComment("NextJS Dynamic Cache Policy", aws_cdk_lib_1.Stack.of(this).stackName),
-                ...this.props.overrides?.dynamicCachePolicyProps,
+                ...cachePolicyProps,
             });
         const responseHeadersPolicy = dynamicBehaviorOptions?.responseHeadersPolicy ??
             new aws_cloudfront_1.ResponseHeadersPolicy(this, "DynamicResponseHeadersPolicy", {
@@ -210,14 +261,53 @@ class NextjsDistribution extends constructs_1.Construct {
         return {
             allowedMethods: aws_cloudfront_1.AllowedMethods.ALLOW_ALL,
             cachePolicy,
-            functionAssociations: this.dynamicCloudFrontFunctionAssociations,
             origin: this.dynamicOrigin,
             originRequestPolicy: this.dynamicOriginResponsePolicy,
             responseHeadersPolicy,
             viewerProtocolPolicy: aws_cloudfront_1.ViewerProtocolPolicy.REDIRECT_TO_HTTPS,
             ...dynamicBehaviorOptions,
+            functionAssociations: this.withDynamicFunctionAssociations("dynamicBehaviorOptions", dynamicBehaviorOptions?.functionAssociations),
         };
     }
+    /**
+     * The behavior's function associations: an override's, plus the viewer-request
+     * function Global Functions depends on.
+     *
+     * Spreading the override's `functionAssociations` over ours would silently
+     * drop that function, and with it the only thing standing between a viewer's
+     * own `X-Forwarded-Host` and the runtime, which trusts that header on Function
+     * URL events (`lambda-event.ts`): host injection into redirects and absolute
+     * URLs, cached for other viewers because the header is not in the cache key.
+     * So ours is kept, and an override claiming VIEWER_REQUEST — which CloudFront
+     * allows only one of per behavior — is an error rather than a replacement.
+     */
+    withDynamicFunctionAssociations(overrideName, overridden) {
+        if (!overridden) {
+            return this.dynamicCloudFrontFunctionAssociations;
+        }
+        if (!this.isFunctionCompute) {
+            return overridden;
+        }
+        const claimed = overridden.some((association) => association.eventType === aws_cloudfront_1.FunctionEventType.VIEWER_REQUEST);
+        if (claimed) {
+            throw new Error(`${constants_1.LOG_PREFIX} \`overrides.${overrideName}.functionAssociations\` ` +
+                `associates a CloudFront function with ` +
+                `${aws_cloudfront_1.FunctionEventType.VIEWER_REQUEST}, but NextjsGlobalFunctions needs ` +
+                `that event type for its own function, which overwrites ` +
+                `\`x-forwarded-host\` with the viewer's \`Host\` (the runtime trusts ` +
+                `that header behind CloudFront) and redirects repeated slashes. ` +
+                `CloudFront permits only one function per event type per behavior. ` +
+                `Move the logic to ${aws_cloudfront_1.FunctionEventType.VIEWER_RESPONSE}, or into ` +
+                `the app's middleware.`);
+        }
+        return [...overridden, ...this.dynamicCloudFrontFunctionAssociations];
+    }
+    /**
+     * `_next/image*` goes to the same origin as everything else — the Next.js
+     * server optimizes images in-process — but keeps its own behavior for the
+     * cache policy: `queryStringBehavior: all()` plus `accept` in the cache key is
+     * right for image requests and wrong for the rest.
+     */
     createImageBehaviorOptions() {
         const imageBehaviorOptions = this.props.overrides?.imageBehaviorOptions;
         // add default cache policy if not provided
@@ -245,13 +335,13 @@ class NextjsDistribution extends constructs_1.Construct {
         return {
             allowedMethods: aws_cloudfront_1.AllowedMethods.ALLOW_GET_HEAD_OPTIONS,
             cachedMethods: aws_cloudfront_1.CachedMethods.CACHE_GET_HEAD_OPTIONS,
-            functionAssociations: this.dynamicCloudFrontFunctionAssociations,
-            origin: this.imageOrigin,
+            origin: this.dynamicOrigin,
             originRequestPolicy: this.dynamicOriginResponsePolicy,
             cachePolicy,
             responseHeadersPolicy,
             viewerProtocolPolicy: aws_cloudfront_1.ViewerProtocolPolicy.REDIRECT_TO_HTTPS,
             ...imageBehaviorOptions,
+            functionAssociations: this.withDynamicFunctionAssociations("imageBehaviorOptions", imageBehaviorOptions?.functionAssociations),
         };
     }
     /**
@@ -278,6 +368,10 @@ class NextjsDistribution extends constructs_1.Construct {
     addDynamicBehaviors() {
         // Image Behavior
         this.distribution.addBehavior(this.getPathPattern("_next/image*"), this.imageBehaviorOptions.origin, this.imageBehaviorOptions);
+        // Function group behaviors, before the basePath catch-all below and after
+        // `_next/image*` (no group pattern can match an image request, and keeping
+        // the order of the unsplit case byte-identical is worth more than symmetry).
+        this.addFunctionGroupBehaviors();
         // Root Path Behaviors
         if (this.basePath) {
             // because we already have a basePath we don't use / instead we use /base-path
@@ -289,31 +383,410 @@ class NextjsDistribution extends constructs_1.Construct {
             // if no base path, then default behavior will handle all other paths
         }
     }
+    /**
+     * Before any behavior is computed: the budget and the `public/` checks both
+     * generate the group patterns, and would otherwise fail first with a less
+     * useful message.
+     */
+    validateFunctionGroupProps() {
+        if (!this.props.functionGroups?.length &&
+            !this.props.functionGroupBehaviors?.length) {
+            return;
+        }
+        if (!this.isFunctionCompute) {
+            throw new Error("`functionGroups` is only supported by NextjsGlobalFunctions.");
+        }
+    }
+    /**
+     * Every group behavior, final path pattern included, in the order
+     * {@link addFunctionGroupBehaviors} adds them.
+     */
+    functionGroupBehaviors() {
+        return (this.props.functionGroupBehaviors ?? []).map((behavior) => {
+            const group = this.props.functionGroups?.find((it) => it.name === behavior.group);
+            if (!group) {
+                throw new Error(`${constants_1.LOG_PREFIX} \`functionGroupBehaviors\` routes to function group ` +
+                    `"${behavior.group}", which is not in \`functionGroups\`.`);
+            }
+            return {
+                ...behavior,
+                group,
+                pathPattern: this.getPathPattern(behavior.pattern),
+            };
+        });
+    }
+    /**
+     * One behavior per group pattern, most specific first.
+     *
+     * The order is the whole mechanism. CloudFront evaluates behaviors in order
+     * and stops at the first whose path pattern matches, and `addBehavior`
+     * appends — so `api/*` added before `api/reports/*` would swallow every
+     * report request and send it to a function whose package has no report
+     * entrypoint. The adapter sorted the list when it checked it against how
+     * `assignRoutesToGroups` packaged the same routes, so it is added as it is.
+     */
+    addFunctionGroupBehaviors() {
+        const originPerGroup = new Map();
+        for (const { group, pathPattern } of this.functionGroupBehaviors()) {
+            let origin = originPerGroup.get(group.name);
+            if (!origin) {
+                origin = aws_cloudfront_origins_1.FunctionUrlOrigin.withOriginAccessControl(group.functionUrl, this.props.overrides?.dynamicFunctionUrlOriginWithOACProps);
+                originPerGroup.set(group.name, origin);
+                this.grantInvoke(group.name, group.functionUrl);
+            }
+            // Same behavior options as every other dynamic route — only the origin
+            // differs, and it is passed separately.
+            const { origin: _ignored, ...behaviorOptions } = this.dynamicBehaviorOptions;
+            this.distribution.addBehavior(pathPattern, origin, behaviorOptions);
+        }
+    }
+    /**
+     * `lambda:InvokeFunction` for CloudFront, which a Function URL behind OAC
+     * needs besides the `lambda:InvokeFunctionUrl` `FunctionUrlOrigin` grants,
+     * and scoped the same way: to this distribution, and to calls that come
+     * through the Function URL.
+     */
+    grantInvoke(group, functionUrl) {
+        new aws_lambda_1.CfnPermission(this, `InvokeFunction-${group}`, {
+            action: "lambda:InvokeFunction",
+            principal: "cloudfront.amazonaws.com",
+            functionName: functionUrl.functionArn,
+            sourceArn: this.distribution.distributionArn,
+            invokedViaFunctionUrl: true,
+        });
+    }
+    /**
+     * The `assetPrefix` path that needs a behavior of its own, or `""` for none.
+     *
+     * An absolute prefix contributes its *path*: "https://cdn.example.com" needs no
+     * behavior, but "https://cdn.example.com/cdn" does, because `next build`
+     * compiles a `/cdn/_next/:path+` rewrite of its own and `next start` serves
+     * every bundle under that path — so a CDN fronting this distribution there has
+     * to be answered. A prefix equal to the `basePath` prefix is dropped — that is
+     * the Next.js default when `basePath` is set, and `_next/static*` already
+     * resolves under it, so adding a second identical pattern would make CloudFront
+     * reject the distribution.
+     */
+    resolveAssetPrefix() {
+        const prefix = (0, base_path_1.assetPrefixPath)(this.props.assetPrefix ?? "");
+        return (0, base_path_1.normalizeBasePath)(prefix) === this.basePath ? "" : prefix;
+    }
+    /**
+     * Serves `<assetPrefix>/_next/static/*` from the same S3 objects as
+     * `_next/static/*`.
+     *
+     * Needed because Next.js puts `assetPrefix` in front of every bundle URL it
+     * emits while the objects keep their `<basePath>/_next/static/...` keys, and
+     * `assetPrefix` sits on top of `basePath` rather than under it, so
+     * `getPathPattern` is deliberately not used here. Without this behavior the
+     * request falls through to the default one, reaches the compute origin, and
+     * 404s: the deployment package carries no `.next/static` directory at all.
+     *
+     * A viewer-request function does the rewrite because an S3 origin keys on the
+     * request URI and `originPath` can only prepend. The prefix is a synth-time
+     * literal, so the function is a fixed-length string operation rather than a
+     * parse.
+     */
+    addAssetPrefixBehavior() {
+        // CloudFront allows one function per event type per behavior, so an override
+        // that already claims VIEWER_REQUEST on the static behavior cannot coexist
+        // with the rewrite below — the distribution would synth and then be rejected
+        // at deploy, naming neither. Thrown here instead, where both halves are
+        // known.
+        const claimed = (this.staticBehaviorOptions.functionAssociations ?? []).some((association) => association.eventType === aws_cloudfront_1.FunctionEventType.VIEWER_REQUEST);
+        if (claimed) {
+            throw new Error(`${constants_1.LOG_PREFIX} \`overrides.staticBehaviorOptions.functionAssociations\` ` +
+                `already associates a CloudFront function with ` +
+                `${aws_cloudfront_1.FunctionEventType.VIEWER_REQUEST}, but serving \`assetPrefix\` ` +
+                `("${this.assetPrefix}") needs that event type to rewrite the request ` +
+                `URI to the object's key, and CloudFront permits only one function per ` +
+                `event type per behavior. Either drop the override, or fold its logic ` +
+                `into a single function and set \`assetPrefix\` to "" so this ` +
+                `construct adds no behavior of its own.`);
+        }
+        const rewrite = new aws_cloudfront_1.Function(this, "AssetPrefixFn", {
+            comment: this.getComment("NextJS assetPrefix rewrite", aws_cdk_lib_1.Stack.of(this).stackName),
+            code: aws_cloudfront_1.FunctionCode.fromInline(`
+        function handler(event) {
+          var request = event.request;
+          request.uri = ${JSON.stringify(this.basePath ? `/${this.basePath}` : "")} + request.uri.slice(${this.assetPrefix.length});
+          return request;
+        }
+        `),
+        });
+        this.distribution.addBehavior(`${this.assetPrefix}/_next/static*`, this.staticOrigin, {
+            ...this.staticBehaviorOptions,
+            functionAssociations: [
+                ...(this.staticBehaviorOptions.functionAssociations ?? []),
+                { eventType: aws_cloudfront_1.FunctionEventType.VIEWER_REQUEST, function: rewrite },
+            ],
+        });
+    }
     addStaticBehaviors() {
         this.distribution.addBehavior(this.getPathPattern("_next/static*"), this.staticOrigin, this.staticBehaviorOptions);
-        // 22 = 25 (max) - 1 (_next/image) - 1 (_next/static) - 1 (*)
-        if (this.props.publicDirEntries.length >= 22) {
-            throw new Error(`Too many public/ files in Next.js build. CloudFront limits Distributions to 25 Cache Behaviors. See documented limit here: https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/cloudfront-limits.html#limits-web-distributions. Try including all public files into 1 top level directory (i.e. static/*).`);
+        if (this.assetPrefix) {
+            this.addAssetPrefixBehavior();
         }
+        const publicPathPatterns = this.publicPathPatterns();
+        this.assertBehaviorBudget(publicPathPatterns.length);
+        this.assertNoPublicCollisions(publicPathPatterns);
+        for (const pathPattern of publicPathPatterns) {
+            this.distribution.addBehavior(pathPattern, this.staticOrigin, this.staticBehaviorOptions);
+        }
+    }
+    /**
+     * The behavior path pattern for each top-level `public/` entry, final form:
+     * `/*` for a directory and the basePath prefix both applied.
+     *
+     * An entry whose name has no character CloudFront can spell is left out, with
+     * a warning, rather than given a pattern of nothing but wildcards. `фото/` is
+     * `????????/*` — any 8-byte first segment — and public/ behaviors are added
+     * ahead of every compute behavior, so it would send `/products/42` and
+     * `/settings/*` to S3, which answers 403. Leaving the entry out costs its own
+     * files instead: those requests reach the compute, which does not have them,
+     * and 404. One literal character is enough to keep a pattern narrow —
+     * `????????.jpg` only matches `.jpg` requests — so only the all-wildcard ones
+     * go.
+     *
+     * The length limit is checked here, on the final pattern, rather than in
+     * {@link toPathPattern}: the `/*` and the basePath count against it too, and a
+     * pattern that passed without them failed at deploy instead.
+     */
+    publicPathPatterns() {
+        const patterns = [];
+        const unmatchable = [];
         for (const publicFile of this.props.publicDirEntries) {
-            const pathPattern = publicFile.isDirectory
-                ? `${publicFile.name}/*`
-                : publicFile.name;
-            if (!/^[a-zA-Z0-9_\-.*$/~"'@:+?&]+$/.test(pathPattern)) {
-                throw new Error(`Invalid CloudFront Distribution Cache Behavior Path Pattern: ${pathPattern}. Please see documentation here: https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/distribution-web-values-specify.html#DownloadDistValuesPathPattern`);
+            const name = toPathPattern(publicFile.name);
+            if (!/[^?*/]/.test(name)) {
+                unmatchable.push(`"${publicFile.name}"`);
+                continue;
+            }
+            const pathPattern = this.getPathPattern(publicFile.isDirectory ? `${name}/*` : name);
+            if (pathPattern.length > MAX_PATH_PATTERN_LENGTH) {
+                throw new Error(`The public/ entry "${publicFile.name}" needs a ` +
+                    `${pathPattern.length}-character CloudFront path pattern, over ` +
+                    `the ${MAX_PATH_PATTERN_LENGTH}-character ` +
+                    "limit. Rename it, or move it into a subdirectory of public/ whose " +
+                    "own name is short enough. See " +
+                    "https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/DownloadDistValuesCacheBehavior.html#DownloadDistValuesPathPattern");
             }
-            const finalPathPattern = this.getPathPattern(pathPattern);
-            this.distribution.addBehavior(finalPathPattern, this.staticOrigin, this.staticBehaviorOptions);
+            patterns.push(pathPattern);
+        }
+        if (unmatchable.length > 0) {
+            aws_cdk_lib_1.Annotations.of(this).addWarning(`${constants_1.LOG_PREFIX} These top-level public/ entries have no character a ` +
+                "CloudFront path pattern can spell, so their pattern would be " +
+                "wildcards alone and would capture every app route of the same " +
+                `length. They get no behavior, so their requests reach the server, ` +
+                `which reads them from S3 instead: ${unmatchable.join(", ")}. To serve ` +
+                "them from S3 directly, rename them, or move them into a public/ " +
+                "subdirectory whose name has at least one ASCII letter or digit.");
         }
+        return patterns;
+    }
+    /**
+     * Refuse a group behavior that a `public/` behavior would make unreachable.
+     *
+     * `public/` behaviors are added first, and CloudFront stops at the first match,
+     * so two cases send a group's route to S3 instead of its function — which is
+     * why this is checked at synth, where both sides are known:
+     * - the same pattern twice: `public/docs/` and `/docs/**` both deploy as
+     *   `docs/*`. The synth succeeded and CloudFront rejected the deploy.
+     * - a group pattern under a public directory: `/docs/guide/**` behind
+     *   `docs/*` deploys and never matches.
+     */
+    assertNoPublicCollisions(publicPathPatterns) {
+        const publicRegexes = publicPathPatterns.map((pattern) => ({
+            pattern,
+            regex: (0, function_groups_1.cloudFrontPatternRegex)(`/${pattern.replace(/^\/+/, "")}`),
+        }));
+        for (const { group, route, pathPattern } of this.functionGroupBehaviors()) {
+            const duplicate = publicPathPatterns.includes(pathPattern);
+            // Matching the group pattern's own text is enough: its only wildcard is a
+            // trailing `*`, so a public pattern that matches the text up to and
+            // including it matches every URL the group pattern does.
+            const shadow = duplicate
+                ? undefined
+                : publicRegexes.find(({ regex }) => regex.test(`/${pathPattern.replace(/^\/+/, "")}`));
+            if (!duplicate && !shadow) {
+                continue;
+            }
+            throw new Error(`${constants_1.LOG_PREFIX} \`functionGroups\` pattern "${route}" (group ` +
+                `"${group.name}") ` +
+                (duplicate
+                    ? `deploys as the path pattern "${pathPattern}", which a top-level ` +
+                        `public/ entry already uses — CloudFront rejects a distribution ` +
+                        `with two behaviors on one path pattern. `
+                    : `deploys as "${pathPattern}", but the top-level public/ entry ` +
+                        `behind "${shadow.pattern}" is matched first and sends every ` +
+                        `such request to S3, so the group's function would never see ` +
+                        `them. `) +
+                `Move those public/ files under a directory no route uses, or ` +
+                `group a different path.`);
+        }
+    }
+    /**
+     * CloudFront has a per-distribution cache behavior quota, counting the default
+     * one — 75 unless raised, and `maxCacheBehaviors` says which — and there are
+     * three things competing for it: `public/` entries, function groups, and
+     * cdk-nextjs's own fixed set.
+     * Checked in one place so the error can say which to cut.
+     *
+     * @see https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/cloudfront-limits.html#limits-web-distributions
+     */
+    assertBehaviorBudget(publicPatterns) {
+        const limit = this.props.maxCacheBehaviors ?? DEFAULT_MAX_CACHE_BEHAVIORS;
+        if (aws_cdk_lib_1.Token.isUnresolved(limit)) {
+            return;
+        }
+        const groupPatterns = this.functionGroupBehaviors().length;
+        // The default behavior, `_next/image*`, `_next/static*`, plus — with a
+        // basePath — the two that stand in for the default behavior's coverage, and
+        // — with a path-style assetPrefix — the one that serves bundles under it.
+        // `this.basePath`, not the raw prop: `basePath: "/"` normalizes to `""` and
+        // adds no behaviors, so counting it added 2 to the total and could throw
+        // "over the limit" on an app that is under it.
+        const fixed = 3 + (this.basePath ? 2 : 0) + (this.assetPrefix ? 1 : 0);
+        const total = fixed + publicPatterns + groupPatterns;
+        if (total <= limit) {
+            return;
+        }
+        const parts = [
+            `${fixed} used by cdk-nextjs itself`,
+            `${publicPatterns} for top-level public/ entries`,
+        ];
+        if (groupPatterns) {
+            parts.push(`${groupPatterns} for \`functionGroups\` patterns`);
+        }
+        throw new Error(`This Next.js app needs ${total} CloudFront cache behaviors, over the ` +
+            `limit of ${limit} per distribution: ${parts.join(", ")}. ` +
+            `Move public/ files into a single top-level directory (one behavior ` +
+            `serves \`static/*\`)` +
+            (groupPatterns
+                ? `, and prefer one subtree pattern per function group over several ` +
+                    `exact paths`
+                : ``) +
+            `. If your account's quota is higher than ${limit}, set ` +
+            `\`maxCacheBehaviors\` to it. See https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/cloudfront-limits.html#limits-web-distributions`);
     }
     /**
      * Optionally prepends base path to given path pattern.
+     *
+     * A trailing slash on `pathPattern` is load-bearing and survives, which is why
+     * this concatenates rather than going through `joinPath`. The build's
+     * `functionGroupBehaviors` hold both "pricing" and "pricing/" for a
+     * `trailingSlash` app, and normalizing the second one collapsed it onto the
+     * first: `addBehavior` was
+     * then called twice with `/base/pricing`, which CloudFront rejects at deploy
+     * ("more than one cache behavior has the same path pattern"), and the
+     * canonical `/base/pricing/` was left to the `/base/*` catch-all — the misroute
+     * the second pattern exists to prevent.
      */
     getPathPattern(pathPattern) {
-        return this.basePath
-            ? `/${(0, base_path_1.joinPath)(this.basePath, pathPattern)}`
-            : pathPattern;
+        if (!this.basePath) {
+            return pathPattern;
+        }
+        return `/${this.basePath}/${pathPattern.replace(/^\/+/, "")}`;
     }
 }
 exports.NextjsDistribution = NextjsDistribution;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"nextjs-distribution.js","sourceRoot":"","sources":["../src/nextjs-distribution.ts"],"names":[],"mappings":"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","sourcesContent":["import { Duration, Stack } from \"aws-cdk-lib\";\nimport { ICertificate } from \"aws-cdk-lib/aws-certificatemanager\";\nimport {\n  AddBehaviorOptions,\n  AllowedMethods,\n  BehaviorOptions,\n  CacheCookieBehavior,\n  CacheHeaderBehavior,\n  CachePolicy,\n  CachePolicyProps,\n  CacheQueryStringBehavior,\n  CachedMethods,\n  Function as CloudFrontFunction,\n  Distribution,\n  FunctionAssociation,\n  FunctionCode,\n  FunctionEventType,\n  HeadersFrameOption,\n  HeadersReferrerPolicy,\n  HttpVersion,\n  IOrigin,\n  IOriginRequestPolicy,\n  OriginProtocolPolicy,\n  OriginRequestPolicy,\n  ResponseHeadersPolicy,\n  ResponseHeadersPolicyProps,\n  ResponseSecurityHeadersBehavior,\n  SecurityPolicyProtocol,\n  ViewerProtocolPolicy,\n} from \"aws-cdk-lib/aws-cloudfront\";\nimport {\n  FunctionUrlOrigin,\n  FunctionUrlOriginWithOACProps,\n  S3BucketOrigin,\n  VpcOrigin,\n  VpcOriginWithEndpointProps,\n} from \"aws-cdk-lib/aws-cloudfront-origins\";\nimport { IApplicationLoadBalancer } from \"aws-cdk-lib/aws-elasticloadbalancingv2\";\nimport { IFunctionUrl } from \"aws-cdk-lib/aws-lambda\";\nimport { IBucket } from \"aws-cdk-lib/aws-s3\";\nimport { Construct } from \"constructs\";\nimport { NextjsType } from \"./constants\";\nimport { OptionalDistributionProps } from \"./generated-structs/OptionalDistributionProps\";\nimport { OptionalS3OriginBucketWithOACProps } from \"./generated-structs/OptionalS3OriginBucketWithOACProps\";\nimport { PublicDirEntry } from \"./nextjs-build/nextjs-build\";\nimport { joinPath, normalizeBasePath } from \"./utils/base-path\";\n\nexport interface NextjsDistributionOverrides {\n  readonly distributionProps?: OptionalDistributionProps;\n  readonly imageBehaviorOptions?: AddBehaviorOptions;\n  readonly imageCachePolicyProps?: CachePolicyProps;\n  readonly imageResponseHeadersPolicyProps?: ResponseHeadersPolicyProps;\n  readonly dynamicBehaviorOptions?: AddBehaviorOptions;\n  readonly dynamicCachePolicyProps?: CachePolicyProps;\n  readonly dynamicResponseHeadersPolicyProps?: ResponseHeadersPolicyProps;\n  readonly dynamicFunctionUrlOriginWithOACProps?: FunctionUrlOriginWithOACProps;\n  readonly dynamicVpcOriginWithEndpointProps?: VpcOriginWithEndpointProps;\n  readonly imageFunctionUrlOriginWithOACProps?: FunctionUrlOriginWithOACProps;\n  readonly staticBehaviorOptions?: AddBehaviorOptions;\n  readonly staticResponseHeadersPolicyProps?: ResponseHeadersPolicyProps;\n  readonly s3BucketOriginProps?: OptionalS3OriginBucketWithOACProps;\n}\n\nexport interface NextjsDistributionProps {\n  /**\n   * Bucket containing static assets.\n   * Must be provided if you want to serve static files.\n   */\n  readonly assetsBucket: IBucket;\n  /**\n   * URI path prefix the app is served at. Surrounding slashes are normalized\n   * away, so \"/base\", \"base\" and \"/base/\" all produce the same cache behaviors.\n   */\n  readonly basePath?: string;\n  /**\n   * Optional but only applicable for `NextjsType.GLOBAL_CONTAINERS`\n   */\n  readonly certificate?: ICertificate;\n  readonly distribution?: Distribution;\n  /**\n   * Required if `NextjsType.GLOBAL_FUNCTIONS`\n   */\n  readonly functionUrl?: IFunctionUrl;\n  /**\n   * Function URL of the dedicated image optimization Lambda. Only applicable\n   * to `NextjsType.GLOBAL_FUNCTIONS`, and only when the dedicated image\n   * function is enabled. When omitted, the `_next/image*` behavior points at\n   * the dynamic origin, which serves image optimization from the Next.js\n   * server itself.\n   */\n  readonly imageFunctionUrl?: IFunctionUrl;\n  /**\n   * Required if `NextjsType.GLOBAL_CONTAINERS` or `NextjsType.REGIONAL_CONTAINERS`\n   */\n  readonly loadBalancer?: IApplicationLoadBalancer;\n  readonly nextjsType: NextjsType;\n  /**\n   * Override props for every construct.\n   */\n  readonly overrides?: NextjsDistributionOverrides;\n  /**\n   * Entries (files/directories) within Next.js app's public directory. Used to\n   * add static behaviors to distribution.\n   */\n  readonly publicDirEntries: PublicDirEntry[];\n}\n\nexport class NextjsDistribution extends Construct {\n  distribution: Distribution;\n\n  private props: NextjsDistributionProps;\n  /**\n   * `props.basePath` normalized to a bare path segment. This construct is the\n   * one place that needs it with a leading slash — CloudFront path patterns are\n   * written against the request path — so it prepends its own rather than\n   * relying on the caller having passed one.\n   */\n  private basePath: string;\n  /**\n   * Common security headers applied by default to all origins\n   * @see https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/using-managed-response-headers-policies.html#managed-response-headers-policies-security\n   */\n  private commonSecurityHeadersBehavior: ResponseSecurityHeadersBehavior = {\n    contentTypeOptions: { override: false },\n    frameOptions: {\n      frameOption: HeadersFrameOption.SAMEORIGIN,\n      override: false,\n    },\n    referrerPolicy: {\n      override: false,\n      referrerPolicy: HeadersReferrerPolicy.STRICT_ORIGIN_WHEN_CROSS_ORIGIN,\n    },\n\n    strictTransportSecurity: {\n      accessControlMaxAge: Duration.days(365),\n      includeSubdomains: true,\n      override: false,\n      preload: true,\n    },\n    xssProtection: { override: false, protection: true, modeBlock: true },\n  };\n  private staticOrigin: IOrigin;\n  private dynamicOrigin: IOrigin;\n  private imageOrigin: IOrigin;\n  private dynamicOriginResponsePolicy: IOriginRequestPolicy;\n  private dynamicCloudFrontFunctionAssociations: FunctionAssociation[];\n  private isFunctionCompute: boolean;\n  private staticBehaviorOptions: BehaviorOptions;\n  private dynamicBehaviorOptions: BehaviorOptions;\n  private imageBehaviorOptions: BehaviorOptions;\n\n  constructor(scope: Construct, id: string, props: NextjsDistributionProps) {\n    super(scope, id);\n    this.props = props;\n    this.basePath = normalizeBasePath(props.basePath);\n    this.staticOrigin = this.createStaticOrigin();\n    this.isFunctionCompute = props.nextjsType === NextjsType.GLOBAL_FUNCTIONS;\n    this.dynamicOrigin = this.createDynamicOrigin();\n    this.imageOrigin = this.createImageOrigin();\n    this.dynamicOriginResponsePolicy = this.createDynamicOriginRequestPolicy();\n    this.dynamicCloudFrontFunctionAssociations =\n      this.createDynamicCloudFrontFunctionAssociations();\n    this.staticBehaviorOptions = this.createStaticBehaviorOptions();\n    this.dynamicBehaviorOptions = this.createDynamicBehaviorOptions();\n    this.imageBehaviorOptions = this.createImageBehaviorOptions();\n    this.distribution = this.getDistribution();\n    this.addStaticBehaviors();\n    this.addDynamicBehaviors();\n  }\n\n  /**\n   * Creates a CloudFront comment that is safe for the 128 character limit.\n   * If the full comment with stack name exceeds 128 characters, returns the base comment only.\n   * @param baseComment The base comment text\n   * @param stackName The stack name to append\n   * @returns A comment string that is guaranteed to be < 128 characters\n   */\n  private getComment(baseComment: string, stackName: string): string {\n    const fullComment = `${baseComment} for ${stackName}`;\n    return fullComment.length < 128 ? fullComment : baseComment;\n  }\n\n  private createStaticOrigin(): IOrigin {\n    return S3BucketOrigin.withOriginAccessControl(\n      this.props.assetsBucket,\n      this.props.overrides?.s3BucketOriginProps,\n    );\n  }\n  private createDynamicOrigin(): IOrigin {\n    if (this.isFunctionCompute) {\n      if (!this.props.functionUrl) {\n        throw new Error(\"Missing NextjsDistributionProps.functionUrl\");\n      }\n      return FunctionUrlOrigin.withOriginAccessControl(\n        this.props.functionUrl,\n        this.props.overrides?.dynamicFunctionUrlOriginWithOACProps,\n      );\n    } else {\n      const loadBalancer = this.props.loadBalancer;\n      if (!loadBalancer) {\n        throw new Error(\"Missing NextjsDistributionProps.loadBalancer\");\n      }\n      return VpcOrigin.withApplicationLoadBalancer(loadBalancer, {\n        protocolPolicy: this.props.certificate\n          ? OriginProtocolPolicy.HTTPS_ONLY\n          : OriginProtocolPolicy.HTTP_ONLY,\n        ...this.props.overrides?.dynamicVpcOriginWithEndpointProps,\n      });\n    }\n  }\n  /**\n   * A dedicated image optimization Lambda is only wired up when\n   * {@link NextjsDistributionProps.imageFunctionUrl} is supplied, which today\n   * only `NextjsType.GLOBAL_FUNCTIONS` does. Otherwise `_next/image*` keeps\n   * going to the dynamic origin, where the Next.js server optimizes images\n   * itself.\n   *\n   * The `_next/image*` behavior is kept either way: its cache policy\n   * (`queryStringBehavior: all()`, `accept` in the cache key) is the right one\n   * for image requests regardless of which origin answers them.\n   */\n  private createImageOrigin(): IOrigin {\n    if (!this.isFunctionCompute || !this.props.imageFunctionUrl) {\n      return this.dynamicOrigin;\n    }\n    return FunctionUrlOrigin.withOriginAccessControl(\n      this.props.imageFunctionUrl,\n      {\n        ...this.props.overrides?.dynamicFunctionUrlOriginWithOACProps,\n        ...this.props.overrides?.imageFunctionUrlOriginWithOACProps,\n      },\n    );\n  }\n  /**\n   * Lambda Function URLs \"expect the `Host` header to contain the origin domain\n   * name, not the domain name of the CloudFront distribution.\"\n   * @see https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/using-managed-origin-request-policies.html#managed-origin-request-policy-all-viewer-except-host-header\n   */\n  private createDynamicOriginRequestPolicy(): IOriginRequestPolicy {\n    return this.isFunctionCompute\n      ? OriginRequestPolicy.ALL_VIEWER_EXCEPT_HOST_HEADER\n      : OriginRequestPolicy.ALL_VIEWER;\n  }\n  /**\n   * Ensures Next.js `request.url` will be correct domain instead of URL of\n   * compute (Lambda or Fargate)\n   * @see https://open-next.js.org/advanced/workaround#workaround-set-x-forwarded-host-header-aws-specific\n   */\n  private createDynamicCloudFrontFunctionAssociations(): FunctionAssociation[] {\n    const associations: FunctionAssociation[] = [];\n    if (this.isFunctionCompute) {\n      const cloudFrontFn = new CloudFrontFunction(this, \"CloudFrontFn\", {\n        code: FunctionCode.fromInline(`\n          function handler(event) {\n            var request = event.request;\n            request.headers[\"x-forwarded-host\"] = request.headers.host;\n            return request;\n          }\n          `),\n      });\n      associations.push({\n        eventType: FunctionEventType.VIEWER_REQUEST,\n        function: cloudFrontFn,\n      });\n    }\n    return associations;\n  }\n  private createStaticBehaviorOptions(): BehaviorOptions {\n    const staticBehaviorOptions = this.props.overrides?.staticBehaviorOptions;\n    const responseHeadersPolicy =\n      staticBehaviorOptions?.responseHeadersPolicy ??\n      new ResponseHeadersPolicy(this, \"StaticResponseHeadersPolicy\", {\n        securityHeadersBehavior: this.commonSecurityHeadersBehavior,\n        comment: this.getComment(\n          \"NextJS Static Response Headers Policy\",\n          Stack.of(this).stackName,\n        ),\n        ...this.props.overrides?.staticResponseHeadersPolicyProps,\n      });\n    return {\n      allowedMethods: AllowedMethods.ALLOW_GET_HEAD_OPTIONS,\n      cachedMethods: CachedMethods.CACHE_GET_HEAD_OPTIONS,\n      cachePolicy: CachePolicy.CACHING_OPTIMIZED,\n      origin: this.staticOrigin,\n      responseHeadersPolicy,\n      viewerProtocolPolicy: ViewerProtocolPolicy.REDIRECT_TO_HTTPS,\n      ...staticBehaviorOptions,\n    };\n  }\n  private createDynamicBehaviorOptions(): BehaviorOptions {\n    const dynamicBehaviorOptions = this.props.overrides?.dynamicBehaviorOptions;\n    // create default cache policy if not provided\n    const cachePolicy =\n      dynamicBehaviorOptions?.cachePolicy ??\n      new CachePolicy(this, \"DynamicCachePolicy\", {\n        queryStringBehavior: CacheQueryStringBehavior.all(),\n        headerBehavior: CacheHeaderBehavior.allowList(\n          // NOTE: CloudFront Custom Cache Policies have soft max of 10 headers\n          // cdk-nextjs includes the most essential headers for Next.js functionality\n          // but it's recommended to request quota increase to include all headers (commented out ones below)\n          // more here: https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/cloudfront-limits.html#limits-policies\n          \"accept\", // content negotiation (HTML vs RSC payload)\n          \"rsc\", // React Server Components requests\n          \"next-url\", // Next.js routing\n          \"next-router-state-tree\", // App Router navigation state\n          \"next-router-prefetch\", // prefetch behavior\n          \"next-router-segment-prefetch\", // segment-level prefetching\n          \"x-matched-path\", // dynamic routes and rewrites\n          \"x-prerender-revalidate\", // on-demand ISR revalidation\n          \"x-next-cache-tags\", // tag-based cache revalidation\n          \"x-prerender-bypass\", // draft mode\n          // \"x-nextjs-stale-time\", // stale-while-revalidate behavior\n          // \"x-next-cache-tag-token\", // auth token for cache tags (only needed with revalidateTag auth)\n          // \"x-nextjs-postponed\", // Partial Prerendering (experimental feature)\n          // \"x-prerender-revalidate-if-generated\", // conditional revalidation (niche use case)\n        ),\n        cookieBehavior: CacheCookieBehavior.all(),\n        enableAcceptEncodingBrotli: true,\n        enableAcceptEncodingGzip: true,\n        comment: this.getComment(\n          \"NextJS Dynamic Cache Policy\",\n          Stack.of(this).stackName,\n        ),\n        ...this.props.overrides?.dynamicCachePolicyProps,\n      });\n    const responseHeadersPolicy =\n      dynamicBehaviorOptions?.responseHeadersPolicy ??\n      new ResponseHeadersPolicy(this, \"DynamicResponseHeadersPolicy\", {\n        securityHeadersBehavior: this.commonSecurityHeadersBehavior,\n        comment: this.getComment(\n          \"NextJS Dynamic Response Headers Policy\",\n          Stack.of(this).stackName,\n        ),\n        ...this.props.overrides?.dynamicResponseHeadersPolicyProps,\n      });\n    return {\n      allowedMethods: AllowedMethods.ALLOW_ALL,\n      cachePolicy,\n      functionAssociations: this.dynamicCloudFrontFunctionAssociations,\n      origin: this.dynamicOrigin,\n      originRequestPolicy: this.dynamicOriginResponsePolicy,\n      responseHeadersPolicy,\n      viewerProtocolPolicy: ViewerProtocolPolicy.REDIRECT_TO_HTTPS,\n      ...dynamicBehaviorOptions,\n    };\n  }\n  private createImageBehaviorOptions(): BehaviorOptions {\n    const imageBehaviorOptions = this.props.overrides?.imageBehaviorOptions;\n    // add default cache policy if not provided\n    const cachePolicy =\n      imageBehaviorOptions?.cachePolicy ??\n      new CachePolicy(this, \"ImageCachePolicy\", {\n        // SECURITY NOTE: by default we don't include cookies in cache for\n        // images b/c it significantly improves image perf for most sites BUT\n        // if you have private images locked behind auth implemented with cookies\n        // you need to override this.\n        queryStringBehavior: CacheQueryStringBehavior.all(),\n        headerBehavior: CacheHeaderBehavior.allowList(\"accept\"),\n        cookieBehavior: CacheCookieBehavior.none(),\n        enableAcceptEncodingBrotli: true,\n        enableAcceptEncodingGzip: true,\n        comment: this.getComment(\n          \"NextJS Image Cache Policy\",\n          Stack.of(this).stackName,\n        ),\n        ...this.props.overrides?.imageCachePolicyProps,\n      });\n    // add default response headers policy if not provided\n    const responseHeadersPolicy =\n      imageBehaviorOptions?.responseHeadersPolicy ??\n      new ResponseHeadersPolicy(this, \"ImageResponseHeadersPolicy\", {\n        securityHeadersBehavior: this.commonSecurityHeadersBehavior,\n        comment: this.getComment(\n          \"NextJS Image Response Headers Policy\",\n          Stack.of(this).stackName,\n        ),\n        ...this.props.overrides?.imageResponseHeadersPolicyProps,\n      });\n    return {\n      allowedMethods: AllowedMethods.ALLOW_GET_HEAD_OPTIONS,\n      cachedMethods: CachedMethods.CACHE_GET_HEAD_OPTIONS,\n      functionAssociations: this.dynamicCloudFrontFunctionAssociations,\n      origin: this.imageOrigin,\n      originRequestPolicy: this.dynamicOriginResponsePolicy,\n      cachePolicy,\n      responseHeadersPolicy,\n      viewerProtocolPolicy: ViewerProtocolPolicy.REDIRECT_TO_HTTPS,\n      ...imageBehaviorOptions,\n    };\n  }\n  /**\n   * Creates or uses user specified CloudFront Distribution\n   */\n  private getDistribution(): Distribution {\n    let distribution: Distribution;\n    if (this.props.distribution) {\n      distribution = this.props.distribution;\n    } else {\n      distribution = new Distribution(this, \"Distribution\", {\n        minimumProtocolVersion: SecurityPolicyProtocol.TLS_V1_2_2021,\n        defaultBehavior: this.dynamicBehaviorOptions,\n        // best to use HTTP 2 and 3 for compatability (HTTP 2) and performance (HTTP3)\n        // CloudFront will choose best option for client\n        httpVersion: HttpVersion.HTTP2_AND_3,\n        comment: this.getComment(\n          \"NextJS Distribution\",\n          Stack.of(this).stackName,\n        ),\n        ...this.props.overrides?.distributionProps,\n      });\n    }\n    return distribution;\n  }\n  private addDynamicBehaviors() {\n    // Image Behavior\n    this.distribution.addBehavior(\n      this.getPathPattern(\"_next/image*\"),\n      this.imageBehaviorOptions.origin,\n      this.imageBehaviorOptions,\n    );\n    // Root Path Behaviors\n    if (this.basePath) {\n      // because we already have a basePath we don't use / instead we use /base-path\n      this.distribution.addBehavior(\n        `/${this.basePath}`,\n        this.dynamicBehaviorOptions.origin,\n        this.dynamicBehaviorOptions,\n      );\n      // when basePath is set, we emulate the \"default behavior\" (*) for the site as `/base-path/*`\n      this.distribution.addBehavior(\n        this.getPathPattern(\"*\"),\n        this.dynamicBehaviorOptions.origin,\n        this.dynamicBehaviorOptions,\n      );\n    } else {\n      // if no base path, then default behavior will handle all other paths\n    }\n  }\n  private addStaticBehaviors() {\n    this.distribution.addBehavior(\n      this.getPathPattern(\"_next/static*\"),\n      this.staticOrigin,\n      this.staticBehaviorOptions,\n    );\n    // 22 = 25 (max) - 1 (_next/image) - 1 (_next/static) - 1 (*)\n    if (this.props.publicDirEntries.length >= 22) {\n      throw new Error(\n        `Too many public/ files in Next.js build. CloudFront limits Distributions to 25 Cache Behaviors. See documented limit here: https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/cloudfront-limits.html#limits-web-distributions. Try including all public files into 1 top level directory (i.e. static/*).`,\n      );\n    }\n    for (const publicFile of this.props.publicDirEntries) {\n      const pathPattern = publicFile.isDirectory\n        ? `${publicFile.name}/*`\n        : publicFile.name;\n      if (!/^[a-zA-Z0-9_\\-.*$/~\"'@:+?&]+$/.test(pathPattern)) {\n        throw new Error(\n          `Invalid CloudFront Distribution Cache Behavior Path Pattern: ${pathPattern}. Please see documentation here: https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/distribution-web-values-specify.html#DownloadDistValuesPathPattern`,\n        );\n      }\n      const finalPathPattern = this.getPathPattern(pathPattern);\n      this.distribution.addBehavior(\n        finalPathPattern,\n        this.staticOrigin,\n        this.staticBehaviorOptions,\n      );\n    }\n  }\n  /**\n   * Optionally prepends base path to given path pattern.\n   */\n  private getPathPattern(pathPattern: string) {\n    return this.basePath\n      ? `/${joinPath(this.basePath, pathPattern)}`\n      : pathPattern;\n  }\n}\n"]}
+/**
+ * Whether `dynamicCachePolicyProps` turns the dynamic cache off, by capping every
+ * TTL at 0.
+ *
+ * CloudFront rejects a policy that caches nothing but still has a cache key
+ * ("HeaderBehavior is invalid for policy with caching disabled"), so such a
+ * policy has to drop the key. Until the default TTL became 0 this could not
+ * come up: CDK raises `maxTtl` to `defaultTtl` when it is lower, so an override
+ * of `maxTtl: 0` synthesized as a day and deployed. Now it is honored, and
+ * without this the upgrade deploy would fail.
+ *
+ * The TTLs are resolved the way CDK resolves them: `defaultTtl` raised to
+ * `minTtl`, then `maxTtl` raised to `defaultTtl`. Checking `maxTtl` alone called
+ * `{ maxTtl: 0, defaultTtl: 1h }` disabled, dropped the key, and CDK then
+ * synthesized a policy that caches for an hour keyed on nothing — one viewer's
+ * page served to every viewer.
+ */
+function isCachingDisabled(props) {
+    const ttls = [props?.maxTtl, props?.defaultTtl, props?.minTtl];
+    if (props?.maxTtl === undefined)
+        return false; // CDK's default is a year
+    return ttls.every((ttl) => ttl === undefined ||
+        (!aws_cdk_lib_1.Token.isUnresolved(ttl.toString()) && ttl.toSeconds() === 0));
+}
+/**
+ * What the dynamic cache policy keys on: every request input a Next.js response
+ * varies by.
+ */
+const DYNAMIC_CACHE_KEY = {
+    queryStringBehavior: aws_cloudfront_1.CacheQueryStringBehavior.all(),
+    headerBehavior: aws_cloudfront_1.CacheHeaderBehavior.allowList(
+    // NOTE: CloudFront Custom Cache Policies have soft max of 10 headers
+    // cdk-nextjs includes the most essential headers for Next.js functionality
+    // but it's recommended to request quota increase to include all headers (commented out ones below)
+    // more here: https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/cloudfront-limits.html#limits-policies
+    "accept", // content negotiation (HTML vs RSC payload)
+    "rsc", // React Server Components requests
+    "next-url", // Next.js routing
+    "next-router-state-tree", // App Router navigation state
+    "next-router-prefetch", // prefetch behavior
+    "next-router-segment-prefetch", // segment-level prefetching
+    "x-prerender-revalidate", // on-demand ISR revalidation
+    "x-prerender-bypass"),
+    cookieBehavior: aws_cloudfront_1.CacheCookieBehavior.all(),
+    enableAcceptEncodingBrotli: true,
+    enableAcceptEncodingGzip: true,
+};
+/**
+ * A cache key of nothing, for a policy that caches nothing. Forwarding is
+ * unaffected: the dynamic origin request policy sends every viewer header,
+ * cookie and query string regardless.
+ */
+const DISABLED_CACHE_KEY = {
+    queryStringBehavior: aws_cloudfront_1.CacheQueryStringBehavior.none(),
+    headerBehavior: aws_cloudfront_1.CacheHeaderBehavior.none(),
+    cookieBehavior: aws_cloudfront_1.CacheCookieBehavior.none(),
+    enableAcceptEncodingBrotli: false,
+    enableAcceptEncodingGzip: false,
+};
+/**
+ * CloudFront's default "Cache behaviors per distribution" quota, the default
+ * behavior included. Adjustable, hence `maxCacheBehaviors`.
+ *
+ * @see https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/cloudfront-limits.html#limits-web-distributions
+ */
+const DEFAULT_MAX_CACHE_BEHAVIORS = 75;
+/**
+ * Whether `char` is in CloudFront's path pattern alphabet: the literals, plus the
+ * `*` and `?` wildcards. No space, no `%`, nothing non-ASCII.
+ */
+function isPathPatternChar(char) {
+    return char === "*" || char === "?" || function_groups_1.PATH_PATTERN_LITERAL.test(char);
+}
+/** CloudFront's path pattern length limit. */
+const MAX_PATH_PATTERN_LENGTH = 255;
+/**
+ * A `public/` entry's name as a CloudFront path pattern.
+ *
+ * `public/hello world.jpg` is a valid Next.js asset — `next start` serves it, and
+ * `next/image` points at it — but a space cannot appear in a path pattern, so
+ * cdk-nextjs used to throw at synth and the app could not be deployed at all
+ * (`next-image-legacy/unicode`, whose `public/` also holds `äöüščří.png`).
+ *
+ * CloudFront URL-decodes the request path before matching it, so the pattern is
+ * matched against `hello world.jpg`, not the `/hello%20world.jpg` on the wire.
+ * Each character outside the alphabet is replaced by one `?` per byte of its
+ * UTF-8 encoding, because that is what `?` matches: `hello?world.jpg` for the
+ * space, and two `?` for each character of `äöüščří.png`. Measured against a
+ * deployed distribution; a `?` per *percent-encoded* character (`hello???world`)
+ * synthesizes fine and never matches. A `*` would be shorter and much wider:
+ * `äöüščří.png` would become `*.png`, which would pull every `.png` request in
+ * the app onto the static origin.
+ */
+function toPathPattern(name) {
+    return [...name]
+        .map((char) => isPathPatternChar(char)
+        ? char
+        : "?".repeat(Buffer.byteLength(char, "utf8")))
+        .join("");
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"nextjs-distribution.js","sourceRoot":"","sources":["../src/nextjs-distribution.ts"],"names":[],"mappings":"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","sourcesContent":["import { Annotations, Duration, Stack, Token } from \"aws-cdk-lib\";\nimport { ICertificate } from \"aws-cdk-lib/aws-certificatemanager\";\nimport {\n  AccessLevel,\n  AddBehaviorOptions,\n  AllowedMethods,\n  BehaviorOptions,\n  CacheCookieBehavior,\n  CacheHeaderBehavior,\n  CachePolicy,\n  CachePolicyProps,\n  CacheQueryStringBehavior,\n  CachedMethods,\n  Function as CloudFrontFunction,\n  Distribution,\n  FunctionAssociation,\n  FunctionCode,\n  FunctionEventType,\n  HeadersFrameOption,\n  HeadersReferrerPolicy,\n  HttpVersion,\n  IOrigin,\n  IOriginRequestPolicy,\n  OriginProtocolPolicy,\n  OriginRequestPolicy,\n  ResponseHeadersPolicy,\n  ResponseHeadersPolicyProps,\n  ResponseSecurityHeadersBehavior,\n  SecurityPolicyProtocol,\n  ViewerProtocolPolicy,\n} from \"aws-cdk-lib/aws-cloudfront\";\nimport {\n  FunctionUrlOrigin,\n  FunctionUrlOriginWithOACProps,\n  S3BucketOrigin,\n  VpcOrigin,\n  VpcOriginWithEndpointProps,\n} from \"aws-cdk-lib/aws-cloudfront-origins\";\nimport { IApplicationLoadBalancer } from \"aws-cdk-lib/aws-elasticloadbalancingv2\";\nimport { CfnPermission, IFunctionUrl } from \"aws-cdk-lib/aws-lambda\";\nimport { IBucket } from \"aws-cdk-lib/aws-s3\";\nimport { Construct } from \"constructs\";\nimport {\n  cloudFrontPatternRegex,\n  DEFAULT_FUNCTION_GROUP,\n  PATH_PATTERN_LITERAL,\n} from \"./adapter/function-groups\";\nimport { LOG_PREFIX, NextjsType } from \"./constants\";\nimport { OptionalDistributionProps } from \"./generated-structs/OptionalDistributionProps\";\nimport { OptionalS3OriginBucketWithOACProps } from \"./generated-structs/OptionalS3OriginBucketWithOACProps\";\nimport {\n  NextjsFunctionGroupBehavior,\n  PublicDirEntry,\n} from \"./nextjs-build/nextjs-build\";\nimport { assetPrefixPath, normalizeBasePath } from \"./utils/base-path\";\n\nexport interface NextjsDistributionOverrides {\n  readonly distributionProps?: OptionalDistributionProps;\n  readonly imageBehaviorOptions?: AddBehaviorOptions;\n  readonly imageCachePolicyProps?: CachePolicyProps;\n  readonly imageResponseHeadersPolicyProps?: ResponseHeadersPolicyProps;\n  readonly dynamicBehaviorOptions?: AddBehaviorOptions;\n  readonly dynamicCachePolicyProps?: CachePolicyProps;\n  readonly dynamicResponseHeadersPolicyProps?: ResponseHeadersPolicyProps;\n  readonly dynamicFunctionUrlOriginWithOACProps?: FunctionUrlOriginWithOACProps;\n  readonly dynamicVpcOriginWithEndpointProps?: VpcOriginWithEndpointProps;\n  readonly staticBehaviorOptions?: AddBehaviorOptions;\n  readonly staticResponseHeadersPolicyProps?: ResponseHeadersPolicyProps;\n  readonly s3BucketOriginProps?: OptionalS3OriginBucketWithOACProps;\n}\n\nexport interface NextjsDistributionProps {\n  /**\n   * Bucket containing static assets.\n   * Must be provided if you want to serve static files.\n   */\n  readonly assetsBucket: IBucket;\n  /**\n   * The app's own `assetPrefix`. Next.js emits `<assetPrefix>/_next/static/...`\n   * for every bundle while the objects stay at `<basePath>/_next/static/...` in\n   * S3, so the prefix's path gets a cache behavior of its own that rewrites it\n   * away.\n   *\n   * Either form is accepted: a path (\"/cdn\"), or an absolute URL, in which case\n   * only its path counts (\"https://cdn.example.com/cdn\" behaves as \"/cdn\", and\n   * \"https://cdn.example.com\" needs no behavior at all). An absolute prefix's path\n   * matters because `next build` compiles a `/cdn/_next/:path+` rewrite of its\n   * own, so `next start` serves every bundle under it — a CDN fronting this\n   * distribution there has to be answered too.\n   *\n   * Applied on top of `basePath`, not under it, because that is how Next.js\n   * builds the URL.\n   *\n   * @default - none; pass `NextjsBuild.nextConfigAssetPrefixPath`\n   */\n  readonly assetPrefix?: string;\n  /**\n   * URI path prefix the app is served at. Surrounding slashes are normalized\n   * away, so \"/base\", \"base\" and \"/base/\" all produce the same cache behaviors.\n   */\n  readonly basePath?: string;\n  /**\n   * Optional but only applicable for `NextjsType.GLOBAL_CONTAINERS`\n   */\n  readonly certificate?: ICertificate;\n  readonly distribution?: Distribution;\n  /**\n   * Required if `NextjsType.GLOBAL_FUNCTIONS`\n   */\n  readonly functionUrl?: IFunctionUrl;\n  /**\n   * Required if `NextjsType.GLOBAL_CONTAINERS` or `NextjsType.REGIONAL_CONTAINERS`\n   */\n  readonly loadBalancer?: IApplicationLoadBalancer;\n  readonly nextjsType: NextjsType;\n  /**\n   * Override props for every construct.\n   */\n  readonly overrides?: NextjsDistributionOverrides;\n  /**\n   * Entries (files/directories) within Next.js app's public directory. Used to\n   * add static behaviors to distribution.\n   */\n  readonly publicDirEntries: PublicDirEntry[];\n  /**\n   * The non-`default` function groups, the origins\n   * {@link functionGroupBehaviors} route to.\n   * @default - no splitting; the default behavior serves every dynamic route\n   */\n  readonly functionGroups?: NextjsDistributionFunctionGroup[];\n  /**\n   * `NextjsBuild.functionGroupBehaviors`: one cache behavior each, added in\n   * order, so the routes each group was packaged with reach it rather than the\n   * default function.\n   * @default - none\n   */\n  readonly functionGroupBehaviors?: NextjsFunctionGroupBehavior[];\n  /**\n   * The most cache behaviors the distribution may have, the default one\n   * included. cdk-nextjs counts what it adds against this at synth, so running\n   * out is a synth error naming what used them rather than a failed deploy.\n   *\n   * Raise it after raising the \"Cache behaviors per distribution\" quota for\n   * your account. Lower it by the behaviors a supplied {@link distribution}\n   * (or `overrides.distributionProps`) already has, which are not counted.\n   * @default 75 - CloudFront's default quota\n   * @see https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/cloudfront-limits.html#limits-web-distributions\n   */\n  readonly maxCacheBehaviors?: number;\n}\n\n/** A non-default function group and the origin its routes must reach. */\nexport interface NextjsDistributionFunctionGroup {\n  readonly name: string;\n  /** The group's Lambda Function URL. */\n  readonly functionUrl: IFunctionUrl;\n}\n\nexport class NextjsDistribution extends Construct {\n  distribution: Distribution;\n\n  private props: NextjsDistributionProps;\n  /**\n   * `props.basePath` normalized to a bare path segment. This construct is the\n   * one place that needs it with a leading slash — CloudFront path patterns are\n   * written against the request path — so it prepends its own rather than\n   * relying on the caller having passed one.\n   */\n  private basePath: string;\n  /**\n   * `props.assetPrefix` normalized to a leading-slash path, `\"\"` when the app\n   * sets none or sets one that already equals the `basePath` prefix — in which\n   * case the ordinary `_next/static*` behavior already covers it and a second one\n   * would be a duplicate pattern CloudFront rejects.\n   */\n  private assetPrefix: string;\n  /**\n   * Common security headers applied by default to all origins\n   * @see https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/using-managed-response-headers-policies.html#managed-response-headers-policies-security\n   */\n  private commonSecurityHeadersBehavior: ResponseSecurityHeadersBehavior = {\n    contentTypeOptions: { override: false },\n    frameOptions: {\n      frameOption: HeadersFrameOption.SAMEORIGIN,\n      override: false,\n    },\n    referrerPolicy: {\n      override: false,\n      referrerPolicy: HeadersReferrerPolicy.STRICT_ORIGIN_WHEN_CROSS_ORIGIN,\n    },\n\n    strictTransportSecurity: {\n      accessControlMaxAge: Duration.days(365),\n      includeSubdomains: true,\n      override: false,\n      preload: true,\n    },\n    xssProtection: { override: false, protection: true, modeBlock: true },\n  };\n  private staticOrigin: IOrigin;\n  private dynamicOrigin: IOrigin;\n  private dynamicOriginResponsePolicy: IOriginRequestPolicy;\n  private dynamicCloudFrontFunctionAssociations: FunctionAssociation[];\n  private isFunctionCompute: boolean;\n  private staticBehaviorOptions: BehaviorOptions;\n  private dynamicBehaviorOptions: BehaviorOptions;\n  private imageBehaviorOptions: BehaviorOptions;\n\n  constructor(scope: Construct, id: string, props: NextjsDistributionProps) {\n    super(scope, id);\n    this.props = props;\n    this.basePath = normalizeBasePath(props.basePath);\n    this.assetPrefix = this.resolveAssetPrefix();\n    this.staticOrigin = this.createStaticOrigin();\n    this.isFunctionCompute = props.nextjsType === NextjsType.GLOBAL_FUNCTIONS;\n    this.validateFunctionGroupProps();\n    this.dynamicOrigin = this.createDynamicOrigin();\n    this.dynamicOriginResponsePolicy = this.createDynamicOriginRequestPolicy();\n    this.dynamicCloudFrontFunctionAssociations =\n      this.createDynamicCloudFrontFunctionAssociations();\n    this.staticBehaviorOptions = this.createStaticBehaviorOptions();\n    this.dynamicBehaviorOptions = this.createDynamicBehaviorOptions();\n    this.imageBehaviorOptions = this.createImageBehaviorOptions();\n    this.distribution = this.getDistribution();\n    if (this.isFunctionCompute) {\n      this.grantInvoke(DEFAULT_FUNCTION_GROUP, props.functionUrl!);\n    }\n    this.addStaticBehaviors();\n    this.addDynamicBehaviors();\n  }\n\n  /**\n   * Creates a CloudFront comment that is safe for the 128 character limit.\n   * If the full comment with stack name exceeds 128 characters, returns the base comment only.\n   * @param baseComment The base comment text\n   * @param stackName The stack name to append\n   * @returns A comment string that is guaranteed to be < 128 characters\n   */\n  private getComment(baseComment: string, stackName: string): string {\n    const fullComment = `${baseComment} for ${stackName}`;\n    return fullComment.length < 128 ? fullComment : baseComment;\n  }\n\n  private createStaticOrigin(): IOrigin {\n    return S3BucketOrigin.withOriginAccessControl(this.props.assetsBucket, {\n      // LIST lets S3 answer a missing key with 404 instead of 403\n      originAccessLevels: [AccessLevel.READ, AccessLevel.LIST],\n      ...this.props.overrides?.s3BucketOriginProps,\n    });\n  }\n  private createDynamicOrigin(): IOrigin {\n    if (this.isFunctionCompute) {\n      if (!this.props.functionUrl) {\n        throw new Error(\"Missing NextjsDistributionProps.functionUrl\");\n      }\n      return FunctionUrlOrigin.withOriginAccessControl(\n        this.props.functionUrl,\n        this.props.overrides?.dynamicFunctionUrlOriginWithOACProps,\n      );\n    } else {\n      const loadBalancer = this.props.loadBalancer;\n      if (!loadBalancer) {\n        throw new Error(\"Missing NextjsDistributionProps.loadBalancer\");\n      }\n      return VpcOrigin.withApplicationLoadBalancer(loadBalancer, {\n        protocolPolicy: this.props.certificate\n          ? OriginProtocolPolicy.HTTPS_ONLY\n          : OriginProtocolPolicy.HTTP_ONLY,\n        ...this.props.overrides?.dynamicVpcOriginWithEndpointProps,\n      });\n    }\n  }\n  /**\n   * Lambda Function URLs \"expect the `Host` header to contain the origin domain\n   * name, not the domain name of the CloudFront distribution.\"\n   *\n   * A container origin also gets CloudFront's own headers, for\n   * `CloudFront-Forwarded-Proto`: without a certificate CloudFront reaches the\n   * ALB over plain HTTP, so the ALB's `X-Forwarded-Proto` is `http`, and the\n   * runtime would build every absolute URL (`request.url`, the origin a server\n   * action is forwarded to) as `http://` behind a viewer on HTTPS.\n   * @see https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/using-managed-origin-request-policies.html#managed-origin-request-policy-all-viewer-except-host-header\n   * @see https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/using-managed-origin-request-policies.html#managed-origin-request-policy-all-viewer-and-cloudfront\n   */\n  private createDynamicOriginRequestPolicy(): IOriginRequestPolicy {\n    return this.isFunctionCompute\n      ? OriginRequestPolicy.ALL_VIEWER_EXCEPT_HOST_HEADER\n      : OriginRequestPolicy.ALL_VIEWER_AND_CLOUDFRONT_2022;\n  }\n  /**\n   * Ensures Next.js `request.url` will be correct domain instead of URL of\n   * compute (Lambda or Fargate)\n   * @see https://open-next.js.org/advanced/workaround#workaround-set-x-forwarded-host-header-aws-specific\n   */\n  private createDynamicCloudFrontFunctionAssociations(): FunctionAssociation[] {\n    const associations: FunctionAssociation[] = [];\n    if (this.isFunctionCompute) {\n      const cloudFrontFn = new CloudFrontFunction(this, \"CloudFrontFn\", {\n        // cloudfront-js-1.0, so ES5.1: `var`, no arrow functions, no template\n        // literals, no `Object.keys`.\n        code: FunctionCode.fromInline(`\n          function handler(event) {\n            var request = event.request;\n            var uri = request.uri;\n\n            // Next.js answers any path containing a backslash or a repeated\n            // slash with a 308 to the collapsed path\n            // (\\`normalizeRepeatedSlashes\\`, called from \\`base-server.ts\\`), and so\n            // does this runtime. Behind a Lambda Function URL the origin never\n            // gets the chance: Origin Access Control signs the raw path while the\n            // Function URL canonicalizes it before verifying, so the origin\n            // answers 403 SignatureDoesNotMatch. Doing the redirect here is what\n            // makes \\`/basepath//to-sv\\` behave as it does under \\`next start\\`.\n            //\n            // A bare \\`//\\` reaches here too, and is answered the same way -\n            // measured, because \\`//\\` at the start of a request target is also the\n            // authority form and it was not obvious CloudFront would route it to a\n            // function at all. It does: \\`GET //\\` answers 308 to \\`/\\` with\n            // \\`x-cache: FunctionGeneratedResponse\\`, over both HTTP/1.1 and HTTP/2,\n            // which is what \\`test/e2e/hydration\\` asks for.\n            //\n            // Two things Next.js does that this cannot:\n            //\n            // - the body it sends with its own redirect (the destination, as\n            //   text), because a generated response can only carry one on\n            //   cloudfront-js-2.0. No known client reads it.\n            // - the original order of the query string. The event exposes\n            //   \\`querystring\\` as an object, never as the raw string, so\n            //   \\`/x//y?a=1&b=2\\` redirects to \\`/x/y?b=2&a=1\\`. The pairs all\n            //   survive; only their order is CloudFront's rather than the\n            //   client's, and a redirect target is not order-sensitive.\n            //\n            // A repeated key's \\`multiValue\\` already holds its first value, which\n            // \\`value\\` repeats, so it is one or the other, never both. Names and\n            // values arrive as the client sent them, still percent-encoded\n            // (measured: \\`?a=%20b%26c&p=1+2\\` reads back unchanged), so they are\n            // joined as-is; encoding them again would turn \\`%20\\` into \\`%2520\\`.\n            if (/\\\\\\\\|\\\\/\\\\//.test(uri)) {\n              var location = uri.replace(/\\\\\\\\/g, \"/\").replace(/\\\\/\\\\/+/g, \"/\");\n              var qs = [];\n              for (var name in request.querystring) {\n                var q = request.querystring[name];\n                var values = q.multiValue || [q];\n                for (var i = 0; i < values.length; i++) {\n                  var v = values[i].value;\n                  qs.push(v === \"\" ? name : name + \"=\" + v);\n                }\n              }\n              if (qs.length) {\n                location = location + \"?\" + qs.join(\"&\");\n              }\n              return {\n                statusCode: 308,\n                statusDescription: \"Permanent Redirect\",\n                headers: { location: { value: location } },\n              };\n            }\n\n            request.headers[\"x-forwarded-host\"] = request.headers.host;\n            return request;\n          }\n          `),\n      });\n      associations.push({\n        eventType: FunctionEventType.VIEWER_REQUEST,\n        function: cloudFrontFn,\n      });\n    }\n    return associations;\n  }\n  private createStaticBehaviorOptions(): BehaviorOptions {\n    const staticBehaviorOptions = this.props.overrides?.staticBehaviorOptions;\n    const responseHeadersPolicy =\n      staticBehaviorOptions?.responseHeadersPolicy ??\n      new ResponseHeadersPolicy(this, \"StaticResponseHeadersPolicy\", {\n        securityHeadersBehavior: this.commonSecurityHeadersBehavior,\n        comment: this.getComment(\n          \"NextJS Static Response Headers Policy\",\n          Stack.of(this).stackName,\n        ),\n        ...this.props.overrides?.staticResponseHeadersPolicyProps,\n      });\n    return {\n      allowedMethods: AllowedMethods.ALLOW_GET_HEAD_OPTIONS,\n      cachedMethods: CachedMethods.CACHE_GET_HEAD_OPTIONS,\n      cachePolicy: CachePolicy.CACHING_OPTIMIZED,\n      origin: this.staticOrigin,\n      responseHeadersPolicy,\n      viewerProtocolPolicy: ViewerProtocolPolicy.REDIRECT_TO_HTTPS,\n      ...staticBehaviorOptions,\n    };\n  }\n  private createDynamicBehaviorOptions(): BehaviorOptions {\n    const dynamicBehaviorOptions = this.props.overrides?.dynamicBehaviorOptions;\n    const cachePolicyProps = this.props.overrides?.dynamicCachePolicyProps;\n    // create default cache policy if not provided\n    const cachePolicy =\n      dynamicBehaviorOptions?.cachePolicy ??\n      new CachePolicy(this, \"DynamicCachePolicy\", {\n        ...(isCachingDisabled(cachePolicyProps)\n          ? DISABLED_CACHE_KEY\n          : DYNAMIC_CACHE_KEY),\n        // A response with no `Cache-Control` is not cached, which is what Next.js\n        // and every app written for it assume: a dynamic route handler sets none.\n        // CDK's default is a day, which cached `/api/*` responses at the edge for\n        // 24 hours. Anything Next.js *means* to cache - ISR, SSG, a PPR shell -\n        // says so with `s-maxage`, which `maxTtl` still honors.\n        defaultTtl: Duration.seconds(0),\n        comment: this.getComment(\n          \"NextJS Dynamic Cache Policy\",\n          Stack.of(this).stackName,\n        ),\n        ...cachePolicyProps,\n      });\n    const responseHeadersPolicy =\n      dynamicBehaviorOptions?.responseHeadersPolicy ??\n      new ResponseHeadersPolicy(this, \"DynamicResponseHeadersPolicy\", {\n        securityHeadersBehavior: this.commonSecurityHeadersBehavior,\n        comment: this.getComment(\n          \"NextJS Dynamic Response Headers Policy\",\n          Stack.of(this).stackName,\n        ),\n        ...this.props.overrides?.dynamicResponseHeadersPolicyProps,\n      });\n    return {\n      allowedMethods: AllowedMethods.ALLOW_ALL,\n      cachePolicy,\n      origin: this.dynamicOrigin,\n      originRequestPolicy: this.dynamicOriginResponsePolicy,\n      responseHeadersPolicy,\n      viewerProtocolPolicy: ViewerProtocolPolicy.REDIRECT_TO_HTTPS,\n      ...dynamicBehaviorOptions,\n      functionAssociations: this.withDynamicFunctionAssociations(\n        \"dynamicBehaviorOptions\",\n        dynamicBehaviorOptions?.functionAssociations,\n      ),\n    };\n  }\n  /**\n   * The behavior's function associations: an override's, plus the viewer-request\n   * function Global Functions depends on.\n   *\n   * Spreading the override's `functionAssociations` over ours would silently\n   * drop that function, and with it the only thing standing between a viewer's\n   * own `X-Forwarded-Host` and the runtime, which trusts that header on Function\n   * URL events (`lambda-event.ts`): host injection into redirects and absolute\n   * URLs, cached for other viewers because the header is not in the cache key.\n   * So ours is kept, and an override claiming VIEWER_REQUEST — which CloudFront\n   * allows only one of per behavior — is an error rather than a replacement.\n   */\n  private withDynamicFunctionAssociations(\n    overrideName: string,\n    overridden: FunctionAssociation[] | undefined,\n  ): FunctionAssociation[] {\n    if (!overridden) {\n      return this.dynamicCloudFrontFunctionAssociations;\n    }\n    if (!this.isFunctionCompute) {\n      return overridden;\n    }\n    const claimed = overridden.some(\n      (association) =>\n        association.eventType === FunctionEventType.VIEWER_REQUEST,\n    );\n    if (claimed) {\n      throw new Error(\n        `${LOG_PREFIX} \\`overrides.${overrideName}.functionAssociations\\` ` +\n          `associates a CloudFront function with ` +\n          `${FunctionEventType.VIEWER_REQUEST}, but NextjsGlobalFunctions needs ` +\n          `that event type for its own function, which overwrites ` +\n          `\\`x-forwarded-host\\` with the viewer's \\`Host\\` (the runtime trusts ` +\n          `that header behind CloudFront) and redirects repeated slashes. ` +\n          `CloudFront permits only one function per event type per behavior. ` +\n          `Move the logic to ${FunctionEventType.VIEWER_RESPONSE}, or into ` +\n          `the app's middleware.`,\n      );\n    }\n    return [...overridden, ...this.dynamicCloudFrontFunctionAssociations];\n  }\n  /**\n   * `_next/image*` goes to the same origin as everything else — the Next.js\n   * server optimizes images in-process — but keeps its own behavior for the\n   * cache policy: `queryStringBehavior: all()` plus `accept` in the cache key is\n   * right for image requests and wrong for the rest.\n   */\n  private createImageBehaviorOptions(): BehaviorOptions {\n    const imageBehaviorOptions = this.props.overrides?.imageBehaviorOptions;\n    // add default cache policy if not provided\n    const cachePolicy =\n      imageBehaviorOptions?.cachePolicy ??\n      new CachePolicy(this, \"ImageCachePolicy\", {\n        // SECURITY NOTE: by default we don't include cookies in cache for\n        // images b/c it significantly improves image perf for most sites BUT\n        // if you have private images locked behind auth implemented with cookies\n        // you need to override this.\n        queryStringBehavior: CacheQueryStringBehavior.all(),\n        headerBehavior: CacheHeaderBehavior.allowList(\"accept\"),\n        cookieBehavior: CacheCookieBehavior.none(),\n        enableAcceptEncodingBrotli: true,\n        enableAcceptEncodingGzip: true,\n        comment: this.getComment(\n          \"NextJS Image Cache Policy\",\n          Stack.of(this).stackName,\n        ),\n        ...this.props.overrides?.imageCachePolicyProps,\n      });\n    // add default response headers policy if not provided\n    const responseHeadersPolicy =\n      imageBehaviorOptions?.responseHeadersPolicy ??\n      new ResponseHeadersPolicy(this, \"ImageResponseHeadersPolicy\", {\n        securityHeadersBehavior: this.commonSecurityHeadersBehavior,\n        comment: this.getComment(\n          \"NextJS Image Response Headers Policy\",\n          Stack.of(this).stackName,\n        ),\n        ...this.props.overrides?.imageResponseHeadersPolicyProps,\n      });\n    return {\n      allowedMethods: AllowedMethods.ALLOW_GET_HEAD_OPTIONS,\n      cachedMethods: CachedMethods.CACHE_GET_HEAD_OPTIONS,\n      origin: this.dynamicOrigin,\n      originRequestPolicy: this.dynamicOriginResponsePolicy,\n      cachePolicy,\n      responseHeadersPolicy,\n      viewerProtocolPolicy: ViewerProtocolPolicy.REDIRECT_TO_HTTPS,\n      ...imageBehaviorOptions,\n      functionAssociations: this.withDynamicFunctionAssociations(\n        \"imageBehaviorOptions\",\n        imageBehaviorOptions?.functionAssociations,\n      ),\n    };\n  }\n  /**\n   * Creates or uses user specified CloudFront Distribution\n   */\n  private getDistribution(): Distribution {\n    let distribution: Distribution;\n    if (this.props.distribution) {\n      distribution = this.props.distribution;\n    } else {\n      distribution = new Distribution(this, \"Distribution\", {\n        minimumProtocolVersion: SecurityPolicyProtocol.TLS_V1_2_2021,\n        defaultBehavior: this.dynamicBehaviorOptions,\n        // best to use HTTP 2 and 3 for compatability (HTTP 2) and performance (HTTP3)\n        // CloudFront will choose best option for client\n        httpVersion: HttpVersion.HTTP2_AND_3,\n        comment: this.getComment(\n          \"NextJS Distribution\",\n          Stack.of(this).stackName,\n        ),\n        ...this.props.overrides?.distributionProps,\n      });\n    }\n    return distribution;\n  }\n  private addDynamicBehaviors() {\n    // Image Behavior\n    this.distribution.addBehavior(\n      this.getPathPattern(\"_next/image*\"),\n      this.imageBehaviorOptions.origin,\n      this.imageBehaviorOptions,\n    );\n    // Function group behaviors, before the basePath catch-all below and after\n    // `_next/image*` (no group pattern can match an image request, and keeping\n    // the order of the unsplit case byte-identical is worth more than symmetry).\n    this.addFunctionGroupBehaviors();\n    // Root Path Behaviors\n    if (this.basePath) {\n      // because we already have a basePath we don't use / instead we use /base-path\n      this.distribution.addBehavior(\n        `/${this.basePath}`,\n        this.dynamicBehaviorOptions.origin,\n        this.dynamicBehaviorOptions,\n      );\n      // when basePath is set, we emulate the \"default behavior\" (*) for the site as `/base-path/*`\n      this.distribution.addBehavior(\n        this.getPathPattern(\"*\"),\n        this.dynamicBehaviorOptions.origin,\n        this.dynamicBehaviorOptions,\n      );\n    } else {\n      // if no base path, then default behavior will handle all other paths\n    }\n  }\n  /**\n   * Before any behavior is computed: the budget and the `public/` checks both\n   * generate the group patterns, and would otherwise fail first with a less\n   * useful message.\n   */\n  private validateFunctionGroupProps() {\n    if (\n      !this.props.functionGroups?.length &&\n      !this.props.functionGroupBehaviors?.length\n    ) {\n      return;\n    }\n    if (!this.isFunctionCompute) {\n      throw new Error(\n        \"`functionGroups` is only supported by NextjsGlobalFunctions.\",\n      );\n    }\n  }\n  /**\n   * Every group behavior, final path pattern included, in the order\n   * {@link addFunctionGroupBehaviors} adds them.\n   */\n  private functionGroupBehaviors() {\n    return (this.props.functionGroupBehaviors ?? []).map((behavior) => {\n      const group = this.props.functionGroups?.find(\n        (it) => it.name === behavior.group,\n      );\n      if (!group) {\n        throw new Error(\n          `${LOG_PREFIX} \\`functionGroupBehaviors\\` routes to function group ` +\n            `\"${behavior.group}\", which is not in \\`functionGroups\\`.`,\n        );\n      }\n      return {\n        ...behavior,\n        group,\n        pathPattern: this.getPathPattern(behavior.pattern),\n      };\n    });\n  }\n  /**\n   * One behavior per group pattern, most specific first.\n   *\n   * The order is the whole mechanism. CloudFront evaluates behaviors in order\n   * and stops at the first whose path pattern matches, and `addBehavior`\n   * appends — so `api/*` added before `api/reports/*` would swallow every\n   * report request and send it to a function whose package has no report\n   * entrypoint. The adapter sorted the list when it checked it against how\n   * `assignRoutesToGroups` packaged the same routes, so it is added as it is.\n   */\n  private addFunctionGroupBehaviors() {\n    const originPerGroup = new Map<string, IOrigin>();\n    for (const { group, pathPattern } of this.functionGroupBehaviors()) {\n      let origin = originPerGroup.get(group.name);\n      if (!origin) {\n        origin = FunctionUrlOrigin.withOriginAccessControl(\n          group.functionUrl,\n          this.props.overrides?.dynamicFunctionUrlOriginWithOACProps,\n        );\n        originPerGroup.set(group.name, origin);\n        this.grantInvoke(group.name, group.functionUrl);\n      }\n      // Same behavior options as every other dynamic route — only the origin\n      // differs, and it is passed separately.\n      const { origin: _ignored, ...behaviorOptions } =\n        this.dynamicBehaviorOptions;\n      this.distribution.addBehavior(pathPattern, origin, behaviorOptions);\n    }\n  }\n  /**\n   * `lambda:InvokeFunction` for CloudFront, which a Function URL behind OAC\n   * needs besides the `lambda:InvokeFunctionUrl` `FunctionUrlOrigin` grants,\n   * and scoped the same way: to this distribution, and to calls that come\n   * through the Function URL.\n   */\n  private grantInvoke(group: string, functionUrl: IFunctionUrl) {\n    new CfnPermission(this, `InvokeFunction-${group}`, {\n      action: \"lambda:InvokeFunction\",\n      principal: \"cloudfront.amazonaws.com\",\n      functionName: functionUrl.functionArn,\n      sourceArn: this.distribution.distributionArn,\n      invokedViaFunctionUrl: true,\n    });\n  }\n  /**\n   * The `assetPrefix` path that needs a behavior of its own, or `\"\"` for none.\n   *\n   * An absolute prefix contributes its *path*: \"https://cdn.example.com\" needs no\n   * behavior, but \"https://cdn.example.com/cdn\" does, because `next build`\n   * compiles a `/cdn/_next/:path+` rewrite of its own and `next start` serves\n   * every bundle under that path — so a CDN fronting this distribution there has\n   * to be answered. A prefix equal to the `basePath` prefix is dropped — that is\n   * the Next.js default when `basePath` is set, and `_next/static*` already\n   * resolves under it, so adding a second identical pattern would make CloudFront\n   * reject the distribution.\n   */\n  private resolveAssetPrefix(): string {\n    const prefix = assetPrefixPath(this.props.assetPrefix ?? \"\");\n    return normalizeBasePath(prefix) === this.basePath ? \"\" : prefix;\n  }\n  /**\n   * Serves `<assetPrefix>/_next/static/*` from the same S3 objects as\n   * `_next/static/*`.\n   *\n   * Needed because Next.js puts `assetPrefix` in front of every bundle URL it\n   * emits while the objects keep their `<basePath>/_next/static/...` keys, and\n   * `assetPrefix` sits on top of `basePath` rather than under it, so\n   * `getPathPattern` is deliberately not used here. Without this behavior the\n   * request falls through to the default one, reaches the compute origin, and\n   * 404s: the deployment package carries no `.next/static` directory at all.\n   *\n   * A viewer-request function does the rewrite because an S3 origin keys on the\n   * request URI and `originPath` can only prepend. The prefix is a synth-time\n   * literal, so the function is a fixed-length string operation rather than a\n   * parse.\n   */\n  private addAssetPrefixBehavior() {\n    // CloudFront allows one function per event type per behavior, so an override\n    // that already claims VIEWER_REQUEST on the static behavior cannot coexist\n    // with the rewrite below — the distribution would synth and then be rejected\n    // at deploy, naming neither. Thrown here instead, where both halves are\n    // known.\n    const claimed = (\n      this.staticBehaviorOptions.functionAssociations ?? []\n    ).some(\n      (association) =>\n        association.eventType === FunctionEventType.VIEWER_REQUEST,\n    );\n    if (claimed) {\n      throw new Error(\n        `${LOG_PREFIX} \\`overrides.staticBehaviorOptions.functionAssociations\\` ` +\n          `already associates a CloudFront function with ` +\n          `${FunctionEventType.VIEWER_REQUEST}, but serving \\`assetPrefix\\` ` +\n          `(\"${this.assetPrefix}\") needs that event type to rewrite the request ` +\n          `URI to the object's key, and CloudFront permits only one function per ` +\n          `event type per behavior. Either drop the override, or fold its logic ` +\n          `into a single function and set \\`assetPrefix\\` to \"\" so this ` +\n          `construct adds no behavior of its own.`,\n      );\n    }\n    const rewrite = new CloudFrontFunction(this, \"AssetPrefixFn\", {\n      comment: this.getComment(\n        \"NextJS assetPrefix rewrite\",\n        Stack.of(this).stackName,\n      ),\n      code: FunctionCode.fromInline(`\n        function handler(event) {\n          var request = event.request;\n          request.uri = ${JSON.stringify(\n            this.basePath ? `/${this.basePath}` : \"\",\n          )} + request.uri.slice(${this.assetPrefix.length});\n          return request;\n        }\n        `),\n    });\n    this.distribution.addBehavior(\n      `${this.assetPrefix}/_next/static*`,\n      this.staticOrigin,\n      {\n        ...this.staticBehaviorOptions,\n        functionAssociations: [\n          ...(this.staticBehaviorOptions.functionAssociations ?? []),\n          { eventType: FunctionEventType.VIEWER_REQUEST, function: rewrite },\n        ],\n      },\n    );\n  }\n  private addStaticBehaviors() {\n    this.distribution.addBehavior(\n      this.getPathPattern(\"_next/static*\"),\n      this.staticOrigin,\n      this.staticBehaviorOptions,\n    );\n    if (this.assetPrefix) {\n      this.addAssetPrefixBehavior();\n    }\n    const publicPathPatterns = this.publicPathPatterns();\n    this.assertBehaviorBudget(publicPathPatterns.length);\n    this.assertNoPublicCollisions(publicPathPatterns);\n    for (const pathPattern of publicPathPatterns) {\n      this.distribution.addBehavior(\n        pathPattern,\n        this.staticOrigin,\n        this.staticBehaviorOptions,\n      );\n    }\n  }\n  /**\n   * The behavior path pattern for each top-level `public/` entry, final form:\n   * `/*` for a directory and the basePath prefix both applied.\n   *\n   * An entry whose name has no character CloudFront can spell is left out, with\n   * a warning, rather than given a pattern of nothing but wildcards. `фото/` is\n   * `????????/*` — any 8-byte first segment — and public/ behaviors are added\n   * ahead of every compute behavior, so it would send `/products/42` and\n   * `/settings/*` to S3, which answers 403. Leaving the entry out costs its own\n   * files instead: those requests reach the compute, which does not have them,\n   * and 404. One literal character is enough to keep a pattern narrow —\n   * `????????.jpg` only matches `.jpg` requests — so only the all-wildcard ones\n   * go.\n   *\n   * The length limit is checked here, on the final pattern, rather than in\n   * {@link toPathPattern}: the `/*` and the basePath count against it too, and a\n   * pattern that passed without them failed at deploy instead.\n   */\n  private publicPathPatterns(): string[] {\n    const patterns: string[] = [];\n    const unmatchable: string[] = [];\n    for (const publicFile of this.props.publicDirEntries) {\n      const name = toPathPattern(publicFile.name);\n      if (!/[^?*/]/.test(name)) {\n        unmatchable.push(`\"${publicFile.name}\"`);\n        continue;\n      }\n      const pathPattern = this.getPathPattern(\n        publicFile.isDirectory ? `${name}/*` : name,\n      );\n      if (pathPattern.length > MAX_PATH_PATTERN_LENGTH) {\n        throw new Error(\n          `The public/ entry \"${publicFile.name}\" needs a ` +\n            `${pathPattern.length}-character CloudFront path pattern, over ` +\n            `the ${MAX_PATH_PATTERN_LENGTH}-character ` +\n            \"limit. Rename it, or move it into a subdirectory of public/ whose \" +\n            \"own name is short enough. See \" +\n            \"https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/DownloadDistValuesCacheBehavior.html#DownloadDistValuesPathPattern\",\n        );\n      }\n      patterns.push(pathPattern);\n    }\n    if (unmatchable.length > 0) {\n      Annotations.of(this).addWarning(\n        `${LOG_PREFIX} These top-level public/ entries have no character a ` +\n          \"CloudFront path pattern can spell, so their pattern would be \" +\n          \"wildcards alone and would capture every app route of the same \" +\n          `length. They get no behavior, so their requests reach the server, ` +\n          `which reads them from S3 instead: ${unmatchable.join(\", \")}. To serve ` +\n          \"them from S3 directly, rename them, or move them into a public/ \" +\n          \"subdirectory whose name has at least one ASCII letter or digit.\",\n      );\n    }\n    return patterns;\n  }\n  /**\n   * Refuse a group behavior that a `public/` behavior would make unreachable.\n   *\n   * `public/` behaviors are added first, and CloudFront stops at the first match,\n   * so two cases send a group's route to S3 instead of its function — which is\n   * why this is checked at synth, where both sides are known:\n   * - the same pattern twice: `public/docs/` and `/docs/**` both deploy as\n   *   `docs/*`. The synth succeeded and CloudFront rejected the deploy.\n   * - a group pattern under a public directory: `/docs/guide/**` behind\n   *   `docs/*` deploys and never matches.\n   */\n  private assertNoPublicCollisions(publicPathPatterns: string[]) {\n    const publicRegexes = publicPathPatterns.map((pattern) => ({\n      pattern,\n      regex: cloudFrontPatternRegex(`/${pattern.replace(/^\\/+/, \"\")}`),\n    }));\n    for (const { group, route, pathPattern } of this.functionGroupBehaviors()) {\n      const duplicate = publicPathPatterns.includes(pathPattern);\n      // Matching the group pattern's own text is enough: its only wildcard is a\n      // trailing `*`, so a public pattern that matches the text up to and\n      // including it matches every URL the group pattern does.\n      const shadow = duplicate\n        ? undefined\n        : publicRegexes.find(({ regex }) =>\n            regex.test(`/${pathPattern.replace(/^\\/+/, \"\")}`),\n          );\n      if (!duplicate && !shadow) {\n        continue;\n      }\n      throw new Error(\n        `${LOG_PREFIX} \\`functionGroups\\` pattern \"${route}\" (group ` +\n          `\"${group.name}\") ` +\n          (duplicate\n            ? `deploys as the path pattern \"${pathPattern}\", which a top-level ` +\n              `public/ entry already uses — CloudFront rejects a distribution ` +\n              `with two behaviors on one path pattern. `\n            : `deploys as \"${pathPattern}\", but the top-level public/ entry ` +\n              `behind \"${shadow!.pattern}\" is matched first and sends every ` +\n              `such request to S3, so the group's function would never see ` +\n              `them. `) +\n          `Move those public/ files under a directory no route uses, or ` +\n          `group a different path.`,\n      );\n    }\n  }\n  /**\n   * CloudFront has a per-distribution cache behavior quota, counting the default\n   * one — 75 unless raised, and `maxCacheBehaviors` says which — and there are\n   * three things competing for it: `public/` entries, function groups, and\n   * cdk-nextjs's own fixed set.\n   * Checked in one place so the error can say which to cut.\n   *\n   * @see https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/cloudfront-limits.html#limits-web-distributions\n   */\n  private assertBehaviorBudget(publicPatterns: number) {\n    const limit = this.props.maxCacheBehaviors ?? DEFAULT_MAX_CACHE_BEHAVIORS;\n    if (Token.isUnresolved(limit)) {\n      return;\n    }\n    const groupPatterns = this.functionGroupBehaviors().length;\n    // The default behavior, `_next/image*`, `_next/static*`, plus — with a\n    // basePath — the two that stand in for the default behavior's coverage, and\n    // — with a path-style assetPrefix — the one that serves bundles under it.\n    // `this.basePath`, not the raw prop: `basePath: \"/\"` normalizes to `\"\"` and\n    // adds no behaviors, so counting it added 2 to the total and could throw\n    // \"over the limit\" on an app that is under it.\n    const fixed = 3 + (this.basePath ? 2 : 0) + (this.assetPrefix ? 1 : 0);\n    const total = fixed + publicPatterns + groupPatterns;\n    if (total <= limit) {\n      return;\n    }\n    const parts = [\n      `${fixed} used by cdk-nextjs itself`,\n      `${publicPatterns} for top-level public/ entries`,\n    ];\n    if (groupPatterns) {\n      parts.push(`${groupPatterns} for \\`functionGroups\\` patterns`);\n    }\n    throw new Error(\n      `This Next.js app needs ${total} CloudFront cache behaviors, over the ` +\n        `limit of ${limit} per distribution: ${parts.join(\", \")}. ` +\n        `Move public/ files into a single top-level directory (one behavior ` +\n        `serves \\`static/*\\`)` +\n        (groupPatterns\n          ? `, and prefer one subtree pattern per function group over several ` +\n            `exact paths`\n          : ``) +\n        `. If your account's quota is higher than ${limit}, set ` +\n        `\\`maxCacheBehaviors\\` to it. See https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/cloudfront-limits.html#limits-web-distributions`,\n    );\n  }\n  /**\n   * Optionally prepends base path to given path pattern.\n   *\n   * A trailing slash on `pathPattern` is load-bearing and survives, which is why\n   * this concatenates rather than going through `joinPath`. The build's\n   * `functionGroupBehaviors` hold both \"pricing\" and \"pricing/\" for a\n   * `trailingSlash` app, and normalizing the second one collapsed it onto the\n   * first: `addBehavior` was\n   * then called twice with `/base/pricing`, which CloudFront rejects at deploy\n   * (\"more than one cache behavior has the same path pattern\"), and the\n   * canonical `/base/pricing/` was left to the `/base/*` catch-all — the misroute\n   * the second pattern exists to prevent.\n   */\n  private getPathPattern(pathPattern: string) {\n    if (!this.basePath) {\n      return pathPattern;\n    }\n    return `/${this.basePath}/${pathPattern.replace(/^\\/+/, \"\")}`;\n  }\n}\n\n/**\n * Whether `dynamicCachePolicyProps` turns the dynamic cache off, by capping every\n * TTL at 0.\n *\n * CloudFront rejects a policy that caches nothing but still has a cache key\n * (\"HeaderBehavior is invalid for policy with caching disabled\"), so such a\n * policy has to drop the key. Until the default TTL became 0 this could not\n * come up: CDK raises `maxTtl` to `defaultTtl` when it is lower, so an override\n * of `maxTtl: 0` synthesized as a day and deployed. Now it is honored, and\n * without this the upgrade deploy would fail.\n *\n * The TTLs are resolved the way CDK resolves them: `defaultTtl` raised to\n * `minTtl`, then `maxTtl` raised to `defaultTtl`. Checking `maxTtl` alone called\n * `{ maxTtl: 0, defaultTtl: 1h }` disabled, dropped the key, and CDK then\n * synthesized a policy that caches for an hour keyed on nothing — one viewer's\n * page served to every viewer.\n */\nfunction isCachingDisabled(props: CachePolicyProps | undefined): boolean {\n  const ttls = [props?.maxTtl, props?.defaultTtl, props?.minTtl];\n  if (props?.maxTtl === undefined) return false; // CDK's default is a year\n  return ttls.every(\n    (ttl) =>\n      ttl === undefined ||\n      (!Token.isUnresolved(ttl.toString()) && ttl.toSeconds() === 0),\n  );\n}\n\n/** The cache-key half of {@link CachePolicyProps}. */\ninterface CacheKeyProps {\n  readonly queryStringBehavior: CacheQueryStringBehavior;\n  readonly headerBehavior: CacheHeaderBehavior;\n  readonly cookieBehavior: CacheCookieBehavior;\n  readonly enableAcceptEncodingBrotli: boolean;\n  readonly enableAcceptEncodingGzip: boolean;\n}\n\n/**\n * What the dynamic cache policy keys on: every request input a Next.js response\n * varies by.\n */\nconst DYNAMIC_CACHE_KEY: CacheKeyProps = {\n  queryStringBehavior: CacheQueryStringBehavior.all(),\n  headerBehavior: CacheHeaderBehavior.allowList(\n    // NOTE: CloudFront Custom Cache Policies have soft max of 10 headers\n    // cdk-nextjs includes the most essential headers for Next.js functionality\n    // but it's recommended to request quota increase to include all headers (commented out ones below)\n    // more here: https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/cloudfront-limits.html#limits-policies\n    \"accept\", // content negotiation (HTML vs RSC payload)\n    \"rsc\", // React Server Components requests\n    \"next-url\", // Next.js routing\n    \"next-router-state-tree\", // App Router navigation state\n    \"next-router-prefetch\", // prefetch behavior\n    \"next-router-segment-prefetch\", // segment-level prefetching\n    \"x-prerender-revalidate\", // on-demand ISR revalidation\n    \"x-prerender-bypass\", // draft mode\n    // \"x-nextjs-stale-time\", // stale-while-revalidate behavior\n    // \"x-next-cache-tag-token\", // auth token for cache tags (only needed with revalidateTag auth)\n    // \"x-nextjs-postponed\", // Partial Prerendering (experimental feature)\n    // \"x-prerender-revalidate-if-generated\", // conditional revalidation (niche use case)\n  ),\n  cookieBehavior: CacheCookieBehavior.all(),\n  enableAcceptEncodingBrotli: true,\n  enableAcceptEncodingGzip: true,\n};\n\n/**\n * A cache key of nothing, for a policy that caches nothing. Forwarding is\n * unaffected: the dynamic origin request policy sends every viewer header,\n * cookie and query string regardless.\n */\nconst DISABLED_CACHE_KEY: CacheKeyProps = {\n  queryStringBehavior: CacheQueryStringBehavior.none(),\n  headerBehavior: CacheHeaderBehavior.none(),\n  cookieBehavior: CacheCookieBehavior.none(),\n  enableAcceptEncodingBrotli: false,\n  enableAcceptEncodingGzip: false,\n};\n\n/**\n * CloudFront's default \"Cache behaviors per distribution\" quota, the default\n * behavior included. Adjustable, hence `maxCacheBehaviors`.\n *\n * @see https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/cloudfront-limits.html#limits-web-distributions\n */\nconst DEFAULT_MAX_CACHE_BEHAVIORS = 75;\n\n/**\n * Whether `char` is in CloudFront's path pattern alphabet: the literals, plus the\n * `*` and `?` wildcards. No space, no `%`, nothing non-ASCII.\n */\nfunction isPathPatternChar(char: string): boolean {\n  return char === \"*\" || char === \"?\" || PATH_PATTERN_LITERAL.test(char);\n}\n/** CloudFront's path pattern length limit. */\nconst MAX_PATH_PATTERN_LENGTH = 255;\n\n/**\n * A `public/` entry's name as a CloudFront path pattern.\n *\n * `public/hello world.jpg` is a valid Next.js asset — `next start` serves it, and\n * `next/image` points at it — but a space cannot appear in a path pattern, so\n * cdk-nextjs used to throw at synth and the app could not be deployed at all\n * (`next-image-legacy/unicode`, whose `public/` also holds `äöüščří.png`).\n *\n * CloudFront URL-decodes the request path before matching it, so the pattern is\n * matched against `hello world.jpg`, not the `/hello%20world.jpg` on the wire.\n * Each character outside the alphabet is replaced by one `?` per byte of its\n * UTF-8 encoding, because that is what `?` matches: `hello?world.jpg` for the\n * space, and two `?` for each character of `äöüščří.png`. Measured against a\n * deployed distribution; a `?` per *percent-encoded* character (`hello???world`)\n * synthesizes fine and never matches. A `*` would be shorter and much wider:\n * `äöüščří.png` would become `*.png`, which would pull every `.png` request in\n * the app onto the static origin.\n */\nfunction toPathPattern(name: string): string {\n  return [...name]\n    .map((char) =>\n      isPathPatternChar(char)\n        ? char\n        : \"?\".repeat(Buffer.byteLength(char, \"utf8\")),\n    )\n    .join(\"\");\n}\n"]}