sst 2.42.0 → 2.43.0

package/constructs/AstroSite.d.ts

@@ -18,38 +18,9 @@ export declare class AstroSite extends SsrSite {
     private static getBuildMeta;
     private static getCFRoutingFunction;
     protected plan(): {
-        cloudFrontFunctions?: Record<string, {
-            constructId: string;
-            injections: string[];
-        }> | undefined;
-        edgeFunctions?: Record<string, {
-            constructId: string;
-            function: import("./EdgeFunction.js").EdgeFunctionProps;
-        }> | undefined;
-        origins: Record<string, {
-            type: "function";
-            constructId: string;
-            function: import("./SsrFunction.js").SsrFunctionProps;
-            injections?: string[] | undefined;
-            streaming?: boolean | undefined;
-        } | {
-            type: "image-optimization-function";
-            function: import("aws-cdk-lib/aws-lambda").FunctionProps;
-        } | {
-            type: "s3";
-            originPath?: string | undefined;
-            copy: {
-                from: string;
-                to: string;
-                cached: boolean;
-                versionedSubDir?: string | undefined;
-            }[];
-        } | {
-            type: "group";
-            primaryOriginName: string;
-            fallbackOriginName: string;
-            fallbackStatusCodes?: number[] | undefined;
-        }>;
+        cloudFrontFunctions?: Record<string, import("./SsrSite.js").CloudFrontFunctionConfig> | undefined;
+        edgeFunctions?: Record<string, import("./SsrSite.js").EdgeFunctionConfig> | undefined;
+        origins: Record<string, import("./SsrSite.js").FunctionOriginConfig | import("./SsrSite.js").ImageOptimizationFunctionOriginConfig | import("./SsrSite.js").S3OriginConfig | import("./SsrSite.js").OriginGroupConfig>;
         edge: boolean;
         behaviors: {
             cacheType: "server" | "static";
@@ -64,6 +35,9 @@ export declare class AstroSite extends SsrSite {
             allowedHeaders?: string[] | undefined;
         } | undefined;
         buildId?: string | undefined;
+        warmer?: {
+            function: string;
+        } | undefined;
     };
     getConstructMetadata(): {
         data: {

package/constructs/NextjsSite.d.ts

@@ -1,9 +1,18 @@
 import { Construct } from "constructs";
-import { Runtime, FunctionProps, Architecture } from "aws-cdk-lib/aws-lambda";
-import { SsrSite, SsrSiteNormalizedProps, SsrSiteProps } from "./SsrSite.js";
+import { Runtime, FunctionProps as CdkFunctionProps, Architecture } from "aws-cdk-lib/aws-lambda";
+import { EdgeFunctionConfig, FunctionOriginConfig, SsrSite, SsrSiteNormalizedProps, SsrSiteProps } from "./SsrSite.js";
 import { Size } from "./util/size.js";
 import { Bucket } from "aws-cdk-lib/aws-s3";
-import { CachePolicyProps } from "aws-cdk-lib/aws-cloudfront";
+type OpenNextS3Origin = {
+    type: "s3";
+    originPath: string;
+    copy: {
+        from: string;
+        to: string;
+        cached: boolean;
+        versionedSubDir?: string;
+    }[];
+};
 export interface NextjsSiteProps extends Omit<SsrSiteProps, "nodejs"> {
     /**
      * OpenNext version for building the Next.js site.
@@ -14,17 +23,6 @@ export interface NextjsSiteProps extends Omit<SsrSiteProps, "nodejs"> {
      * ```
      */
     openNextVersion?: string;
-    /**
-     * How the logs are stored in CloudWatch
-     * - "combined" - Logs from all routes are stored in the same log group.
-     * - "per-route" - Logs from each route are stored in a separate log group.
-     * @default "per-route"
-     * @example
-     * ```js
-     * logging: "combined",
-     * ```
-     */
-    logging?: "combined" | "per-route";
     /**
      * The server function is deployed to Lambda in a single region. Alternatively, you can enable this option to deploy to Lambda@Edge.
      * @default false
@@ -42,59 +40,20 @@ export interface NextjsSiteProps extends Omit<SsrSiteProps, "nodejs"> {
          * ```
          */
         memorySize?: number | Size;
-    };
-    openNext?: {
-        /**
-         * Specify a custom build output path for cases when running OpenNext from
-         * a monorepo with decentralized build output. This is passed to the
-         * `--build-output-path` flag of OpenNext.
-         * @default Default build output path
-         * @example
-         * ```js
-         * buildOutputPath: "dist/apps/example-app"
-         * ```
-         */
-        buildOutputPath?: string;
-    };
-    experimental?: {
-        /**
-         * Enable streaming. Currently an experimental feature in OpenNext.
-         * @default false
-         * @example
-         * ```js
-         * experimental: {
-         *   streaming: true,
-         * }
-         * ```
-         */
-        streaming?: boolean;
         /**
-         * Disabling incremental cache will cause the entire page to be revalidated on each request. This can result in ISR and SSG pages to be in an inconsistent state. Specify this option if you are using SSR pages only.
-         *
-         * Note that it is possible to disable incremental cache while leaving on-demand revalidation enabled.
+         * If set to true, already computed image will return 304 Not Modified.
+         * This means that image needs to be immutable, the etag will be computed based on the image href, format and width and the next BUILD_ID.
          * @default false
          * @example
          * ```js
-         * experimental: {
-         *   disableIncrementalCache: true,
-         * }
-         * ```
-         */
-        disableIncrementalCache?: boolean;
-        /**
-         * Disabling DynamoDB cache will cause on-demand revalidation by path (`revalidatePath`) and by cache tag (`revalidateTag`) to fail silently.
-         * @default false
-         * @example
-         * ```js
-         * experimental: {
-         *   disableDynamoDBCache: true,
+         * imageOptimization: {
+         *  staticImageOptimization: true,
          * }
-         * ```
          */
-        disableDynamoDBCache?: boolean;
+        staticImageOptimization?: boolean;
     };
     cdk?: SsrSiteProps["cdk"] & {
-        revalidation?: Pick<FunctionProps, "vpc" | "vpcSubnets">;
+        revalidation?: Pick<CdkFunctionProps, "vpc" | "vpcSubnets">;
         /**
          * Override the CloudFront cache policy properties for responses from the
          * server rendering Lambda.
@@ -145,8 +104,11 @@ export declare class NextjsSite extends SsrSite {
     private appPathsManifest?;
     private pagesManifest?;
     private prerenderManifest?;
-    constructor(scope: Construct, id: string, rawProps?: NextjsSiteProps);
-    static buildDefaultServerCachePolicyProps(): CachePolicyProps;
+    private openNextOutput?;
+    constructor(scope: Construct, id: string, props?: NextjsSiteProps);
+    private createFunctionOrigin;
+    private createEcsOrigin;
+    private createEdgeOrigin;
     protected plan(bucket: Bucket): {
         cloudFrontFunctions?: {
             serverCfFunction: {
@@ -154,26 +116,11 @@ export declare class NextjsSite extends SsrSite {
                 injections: string[];
             };
         } | undefined;
-        edgeFunctions?: {
-            edgeServer: {
-                constructId: string;
-                function: {
-                    description: string;
-                    bundle: string;
-                    handler: string;
-                    environment: {
-                        CACHE_BUCKET_NAME: string;
-                        CACHE_BUCKET_KEY_PREFIX: string;
-                        CACHE_BUCKET_REGION: string;
-                    };
-                    layers: import("aws-cdk-lib/aws-lambda").ILayerVersion[] | undefined;
-                };
-            };
-        } | undefined;
+        edgeFunctions?: Record<string, EdgeFunctionConfig> | undefined;
         origins: {
+            s3: OpenNextS3Origin;
             imageOptimizer: {
                 type: "image-optimization-function";
-                constructId: string;
                 function: {
                     description: string;
                     handler: string;
@@ -181,73 +128,39 @@ export declare class NextjsSite extends SsrSite {
                     runtime: Runtime;
                     architecture: Architecture;
                     environment: {
+                        OPENNEXT_STATIC_ETAG?: string | undefined;
                         BUCKET_NAME: string;
                         BUCKET_KEY_PREFIX: string;
                     };
+                    permissions: string[];
                     memorySize: number;
                 };
             };
-            s3: {
-                type: "s3";
-                originPath: string;
-                copy: ({
-                    from: string;
-                    to: string;
-                    cached: true;
-                    versionedSubDir: string;
-                } | {
-                    from: string;
-                    to: string;
-                    cached: false;
-                    versionedSubDir?: undefined;
-                })[];
-            };
-            regionalServer?: {
-                type: "function";
-                constructId: string;
-                function: {
-                    description: string;
-                    bundle: string;
-                    handler: string;
-                    environment: {
-                        CACHE_BUCKET_NAME: string;
-                        CACHE_BUCKET_KEY_PREFIX: string;
-                        CACHE_BUCKET_REGION: string;
-                    };
-                    layers: import("aws-cdk-lib/aws-lambda").ILayerVersion[] | undefined;
-                };
-                streaming: boolean | undefined;
-                injections: string[];
-            } | undefined;
+            default: FunctionOriginConfig;
         };
         edge: boolean;
         behaviors: {
             cacheType: "server" | "static";
             pattern?: string | undefined;
-            origin: "s3" | "regionalServer" | "imageOptimizer";
+            origin: "default" | "s3" | "imageOptimizer";
             allowedMethods?: import("aws-cdk-lib/aws-cloudfront").AllowedMethods | undefined;
             cfFunction?: "serverCfFunction" | undefined;
-            edgeFunction?: "edgeServer" | undefined;
+            edgeFunction?: string | undefined;
         }[];
         errorResponses?: import("aws-cdk-lib/aws-cloudfront").ErrorResponse[] | undefined;
         serverCachePolicy?: {
             allowedHeaders?: string[] | undefined;
         } | undefined;
         buildId?: string | undefined;
+        warmer?: {
+            function: string;
+        } | undefined;
     };
-    private prefixPattern;
+    private setMiddlewareEnv;
     private createRevalidationQueue;
     private createRevalidationTable;
     getConstructMetadata(): {
-        type: "NextjsSite";
         data: {
-            routes: {
-                logGroupPrefix: string;
-                data: {
-                    route: string;
-                    logGroupPath: string;
-                }[];
-            } | undefined;
             mode: "placeholder" | "deployed";
             path: string;
             runtime: "nodejs16.x" | "nodejs18.x" | "nodejs20.x";
@@ -258,23 +171,20 @@ export declare class NextjsSite extends SsrSite {
             secrets: string[];
             prefetchSecrets: boolean | undefined;
         };
+        type: "NextjsSite";
     };
-    private removeSourcemaps;
     private useRoutes;
     private useRoutesManifest;
     private useAppPathRoutesManifest;
     private useAppPathsManifest;
     private usePagesManifest;
     private usePrerenderManifest;
-    private useServerFunctionPerRouteLoggingInjection;
-    private useCloudFrontFunctionPrerenderBypassHeaderInjection;
+    private useCloudFrontFunctionCacheHeaderKey;
+    private useCloudfrontGeoHeadersInjection;
     private getBuildId;
     private getSourcemapForAppRoute;
     private getSourcemapForPagesRoute;
-    private isPerRouteLoggingEnabled;
     private handleMissingSourcemap;
-    private disableDefaultLogging;
-    private uploadSourcemaps;
     private static buildCloudWatchRouteName;
     private static buildCloudWatchRouteHash;
     static _test: {

package/constructs/NextjsSite.js

@@ -1,35 +1,20 @@
 import fs from "fs";
 import path from "path";
-import zlib from "zlib";
 import crypto from "crypto";
-import { globSync } from "glob";
-import { Duration as CdkDuration, RemovalPolicy, CustomResource, } from "aws-cdk-lib/core";
-import { Code, Runtime, Function as CdkFunction, Architecture, LayerVersion, } from "aws-cdk-lib/aws-lambda";
+import { Duration as CdkDuration, RemovalPolicy, CustomResource, Fn, } from "aws-cdk-lib/core";
+import { Code, Runtime, Function as CdkFunction, Architecture, } from "aws-cdk-lib/aws-lambda";
 import { AttributeType, Billing, TableV2 as Table, } from "aws-cdk-lib/aws-dynamodb";
 import { Provider } from "aws-cdk-lib/custom-resources";
 import { Queue } from "aws-cdk-lib/aws-sqs";
 import { SqsEventSource } from "aws-cdk-lib/aws-lambda-event-sources";
 import { Stack } from "./Stack.js";
-import { SsrSite } from "./SsrSite.js";
+import { SsrSite, } from "./SsrSite.js";
 import { toCdkSize } from "./util/size.js";
-import { Effect, Policy, PolicyStatement } from "aws-cdk-lib/aws-iam";
+import { PolicyStatement } from "aws-cdk-lib/aws-iam";
 import { RetentionDays } from "aws-cdk-lib/aws-logs";
 import { VisibleError } from "../error.js";
-import { Asset } from "aws-cdk-lib/aws-s3-assets";
-import { useFunctions } from "./Function.js";
-import { useDeferredTasks } from "./deferred_task.js";
 import { Logger } from "../logger.js";
-const LAYER_VERSION = "2";
-const DEFAULT_OPEN_NEXT_VERSION = "2.3.8";
-const DEFAULT_CACHE_POLICY_ALLOWED_HEADERS = [
-    "accept",
-    "rsc",
-    "next-router-prefetch",
-    "next-router-state-tree",
-    "next-url",
-    "x-prerender-bypass",
-    "x-prerender-revalidate",
-];
+const DEFAULT_OPEN_NEXT_VERSION = "3.0.2";
 /**
  * The `NextjsSite` construct is a higher level CDK construct that makes it easy to create a Next.js app.
  * @example
@@ -48,118 +33,135 @@ export class NextjsSite extends SsrSite {
     appPathsManifest;
     pagesManifest;
     prerenderManifest;
-    constructor(scope, id, rawProps) {
-        const props = {
-            logging: rawProps?.logging ?? "per-route",
-            experimental: {
-                streaming: rawProps?.experimental?.streaming ?? false,
-                disableDynamoDBCache: rawProps?.experimental?.disableDynamoDBCache ?? false,
-                disableIncrementalCache: rawProps?.experimental?.disableIncrementalCache ?? false,
-                ...rawProps?.experimental,
-            },
-            ...rawProps,
-        };
+    openNextOutput;
+    constructor(scope, id, props = {}) {
         super(scope, id, {
             buildCommand: [
                 "npx",
                 "--yes",
                 `open-next@${props?.openNextVersion ?? DEFAULT_OPEN_NEXT_VERSION}`,
                 "build",
-                ...(props.openNext?.buildOutputPath
-                    ? ["--build-output-path", props.openNext.buildOutputPath]
-                    : []),
-                ...(props.experimental.streaming ? ["--streaming"] : []),
-                ...(props.experimental.disableDynamoDBCache
-                    ? ["--dangerously-disable-dynamodb-cache"]
-                    : []),
-                ...(props.experimental.disableIncrementalCache
-                    ? ["--dangerously-disable-incremental-cache"]
-                    : []),
             ].join(" "),
             ...props,
         });
+        const disableIncrementalCache = this.openNextOutput?.additionalProps?.disableIncrementalCache ?? false;
+        const disableTagCache = this.openNextOutput?.additionalProps?.disableTagCache ?? false;
         this.handleMissingSourcemap();
-        if (this.isPerRouteLoggingEnabled()) {
-            //this.disableDefaultLogging();
-            this.uploadSourcemaps();
+        if (this.openNextOutput?.edgeFunctions?.middleware) {
+            this.setMiddlewareEnv();
         }
-        if (!props.experimental.disableIncrementalCache) {
+        if (!disableIncrementalCache) {
             this.createRevalidationQueue();
-            if (!props.experimental.disableDynamoDBCache) {
+            if (!disableTagCache) {
                 this.createRevalidationTable();
             }
         }
     }
-    static buildDefaultServerCachePolicyProps() {
-        return super.buildDefaultServerCachePolicyProps(DEFAULT_CACHE_POLICY_ALLOWED_HEADERS);
+    createFunctionOrigin(fn, key, bucket) {
+        const { path: sitePath, environment, cdk } = this.props;
+        const baseServerConfig = {
+            description: "Next.js Server",
+            environment: {
+                CACHE_BUCKET_NAME: bucket.bucketName,
+                CACHE_BUCKET_KEY_PREFIX: "_cache",
+                CACHE_BUCKET_REGION: Stack.of(this).region,
+            },
+        };
+        return {
+            type: "function",
+            constructId: `${key}ServerFunction`,
+            function: {
+                ...baseServerConfig,
+                handler: fn.handler,
+                bundle: path.join(sitePath, fn.bundle),
+                runtime: "nodejs18.x",
+                architecture: Architecture.ARM_64,
+                memorySize: 1536,
+                environment: {
+                    ...environment,
+                    ...baseServerConfig.environment,
+                },
+            },
+            streaming: fn.streaming,
+            injections: [],
+        };
+    }
+    createEcsOrigin(ecs, key, bucket) {
+        throw new Error("Ecs origin are not supported yet");
     }
-    plan(bucket) {
-        const { path: sitePath, edge, experimental, imageOptimization, cdk, } = this.props;
-        const stack = Stack.of(this);
-        const serverConfig = {
-            description: "Next.js server",
-            bundle: path.join(sitePath, ".open-next", "server-function"),
-            handler: "index.handler",
+    createEdgeOrigin(fn, key, bucket) {
+        const { path: sitePath, cdk, environment } = this.props;
+        const baseServerConfig = {
             environment: {
                 CACHE_BUCKET_NAME: bucket.bucketName,
                 CACHE_BUCKET_KEY_PREFIX: "_cache",
                 CACHE_BUCKET_REGION: Stack.of(this).region,
             },
-            layers: this.isPerRouteLoggingEnabled()
-                ? [
-                    LayerVersion.fromLayerVersionArn(this, "SSTExtension", cdk?.server?.architecture?.name === Architecture.X86_64.name
-                        ? `arn:aws:lambda:${stack.region}:226609089145:layer:sst-extension-amd64:${LAYER_VERSION}`
-                        : `arn:aws:lambda:${stack.region}:226609089145:layer:sst-extension-arm64:${LAYER_VERSION}`),
-                ]
-                : undefined,
         };
-        this.removeSourcemaps();
+        return {
+            constructId: `${key}EdgeFunction`,
+            function: {
+                handler: fn.handler,
+                bundle: path.join(sitePath, fn.bundle),
+                runtime: "nodejs18.x",
+                memorySize: 1024,
+                environment: {
+                    ...environment,
+                    ...baseServerConfig.environment,
+                },
+            },
+        };
+    }
+    plan(bucket) {
+        const { path: sitePath } = this.props;
+        const imageOptimization = this.props.imageOptimization;
+        const openNextOutputPath = path.join(sitePath ?? ".", ".open-next", "open-next.output.json");
+        if (!fs.existsSync(openNextOutputPath)) {
+            throw new VisibleError(`Failed to load ".open-next/output.json" for the "${this.id}" site.`);
+        }
+        const openNextOutput = JSON.parse(fs.readFileSync(openNextOutputPath).toString());
+        this.openNextOutput = openNextOutput;
+        const imageOpt = openNextOutput.origins
+            .imageOptimizer;
+        const defaultOrigin = openNextOutput.origins.default;
+        const remainingOrigins = Object.entries(openNextOutput.origins).filter(([key, value]) => {
+            const result = key !== "imageOptimizer" && key !== "default" && key !== "s3";
+            return result;
+        });
+        const edgeFunctions = Object.entries(openNextOutput.edgeFunctions).reduce((acc, [key, value]) => {
+            return { ...acc, [key]: this.createEdgeOrigin(value, key, bucket) };
+        }, {});
         return this.validatePlan({
-            edge: edge ?? false,
+            edge: false,
             cloudFrontFunctions: {
                 serverCfFunction: {
                     constructId: "CloudFrontFunction",
                     injections: [
                         this.useCloudFrontFunctionHostHeaderInjection(),
-                        this.useCloudFrontFunctionPrerenderBypassHeaderInjection(),
+                        this.useCloudFrontFunctionCacheHeaderKey(),
+                        this.useCloudfrontGeoHeadersInjection(),
                     ],
                 },
             },
-            edgeFunctions: edge
-                ? {
-                    edgeServer: {
-                        constructId: "ServerFunction",
-                        function: serverConfig,
-                    },
-                }
-                : undefined,
+            edgeFunctions,
             origins: {
-                ...(edge
-                    ? {}
-                    : {
-                        regionalServer: {
-                            type: "function",
-                            constructId: "ServerFunction",
-                            function: serverConfig,
-                            streaming: experimental?.streaming,
-                            injections: this.isPerRouteLoggingEnabled()
-                                ? [this.useServerFunctionPerRouteLoggingInjection()]
-                                : [],
-                        },
-                    }),
+                s3: openNextOutput.origins.s3,
                 imageOptimizer: {
                     type: "image-optimization-function",
-                    constructId: "ImageFunction",
                     function: {
-                        description: "Next.js image optimizer",
-                        handler: "index.handler",
-                        code: Code.fromAsset(path.join(sitePath, ".open-next/image-optimization-function")),
+                        description: "Next.js Image Optimization Function",
+                        handler: imageOpt.handler,
+                        code: Code.fromAsset(path.join(sitePath, imageOpt.bundle)),
                         runtime: Runtime.NODEJS_18_X,
                         architecture: Architecture.ARM_64,
                         environment: {
                             BUCKET_NAME: bucket.bucketName,
                             BUCKET_KEY_PREFIX: "_assets",
+                            ...(this.props.imageOptimization?.staticImageOptimization
+                                ? { OPENNEXT_STATIC_ETAG: "true" }
+                                : {}),
                         },
+                        permissions: ["s3"],
                         memorySize: imageOptimization?.memorySize
                             ? typeof imageOptimization.memorySize === "string"
                                 ? toCdkSize(imageOptimization.memorySize).toMebibytes()
@@ -167,98 +169,55 @@ export class NextjsSite extends SsrSite {
                             : 1536,
                     },
                 },
-                s3: {
-                    type: "s3",
-                    originPath: "_assets",
-                    copy: [
-                        {
-                            from: ".open-next/assets",
-                            to: "_assets",
-                            cached: true,
-                            versionedSubDir: "_next",
-                        },
-                        { from: ".open-next/cache", to: "_cache", cached: false },
-                    ],
-                },
+                default: defaultOrigin.type === "ecs"
+                    ? this.createEcsOrigin(defaultOrigin, "default", bucket)
+                    : this.createFunctionOrigin(defaultOrigin, "default", bucket),
+                ...Object.fromEntries(remainingOrigins.map(([key, value]) => [
+                    key,
+                    value.type === "ecs"
+                        ? this.createEcsOrigin(value, key, bucket)
+                        : this.createFunctionOrigin(value, key, bucket),
+                ])),
             },
-            behaviors: [
-                ...(edge
-                    ? [
-                        {
-                            cacheType: "server",
-                            cfFunction: "serverCfFunction",
-                            edgeFunction: "edgeServer",
-                            origin: "s3",
-                        },
-                        {
-                            cacheType: "server",
-                            pattern: this.prefixPattern("api/*"),
-                            cfFunction: "serverCfFunction",
-                            edgeFunction: "edgeServer",
-                            origin: "s3",
-                        },
-                        {
-                            cacheType: "server",
-                            pattern: this.prefixPattern("_next/data/*"),
-                            cfFunction: "serverCfFunction",
-                            edgeFunction: "edgeServer",
-                            origin: "s3",
-                        },
-                    ]
-                    : [
-                        {
-                            cacheType: "server",
-                            cfFunction: "serverCfFunction",
-                            origin: "regionalServer",
-                        },
-                        {
-                            cacheType: "server",
-                            pattern: this.prefixPattern("api/*"),
-                            cfFunction: "serverCfFunction",
-                            origin: "regionalServer",
-                        },
-                        {
-                            cacheType: "server",
-                            pattern: this.prefixPattern("_next/data/*"),
-                            cfFunction: "serverCfFunction",
-                            origin: "regionalServer",
-                        },
-                    ]),
-                {
-                    cacheType: "server",
-                    pattern: this.prefixPattern("_next/image*"),
+            behaviors: openNextOutput.behaviors.map((behavior) => {
+                return {
+                    pattern: behavior.pattern === "*" ? undefined : behavior.pattern,
+                    origin: behavior.origin,
+                    cacheType: behavior.origin === "s3" ? "static" : "server",
                     cfFunction: "serverCfFunction",
-                    origin: "imageOptimizer",
-                },
-                // create 1 behaviour for each top level asset file/folder
-                ...fs.readdirSync(path.join(sitePath, ".open-next/assets")).map((item) => ({
-                    cacheType: "static",
-                    pattern: this.prefixPattern(fs
-                        .statSync(path.join(sitePath, ".open-next/assets", item))
-                        .isDirectory()
-                        ? `${item}/*`
-                        : item),
-                    origin: "s3",
-                })),
-            ],
+                    edgeFunction: behavior.edgeFunction ?? "",
+                };
+            }),
+            buildId: this.getBuildId(),
+            warmer: openNextOutput.additionalProps?.warmer
+                ? {
+                    function: path.join(sitePath, openNextOutput.additionalProps.warmer.bundle),
+                }
+                : undefined,
             serverCachePolicy: {
-                allowedHeaders: DEFAULT_CACHE_POLICY_ALLOWED_HEADERS,
+                allowedHeaders: ["x-open-next-cache-key"],
             },
-            buildId: this.getBuildId(),
         });
     }
-    prefixPattern(pattern) {
-        // Prefix CloudFront distribution behavior path patterns with `basePath` if configured
-        const { basePath } = this.useRoutesManifest();
-        return basePath && basePath.length > 0
-            ? `${basePath.slice(1)}/${pattern}`
-            : pattern;
+    setMiddlewareEnv() {
+        const origins = this.serverFunctions.reduce((acc, server) => {
+            return {
+                ...acc,
+                [server.function
+                    ? server.id.replace("ServerFunction", "")
+                    : server.id.replace("ServerContainer", "")]: {
+                    host: Fn.parseDomainName(server.url ?? ""),
+                    port: 443,
+                    protocol: "https",
+                },
+            };
+        }, {});
+        this.edgeFunctions?.middleware?.addEnvironment("OPEN_NEXT_ORIGIN", Fn.toJsonString(origins));
     }
     createRevalidationQueue() {
         if (!this.serverFunction)
             return;
         const { cdk } = this.props;
-        const server = this.serverFunction;
         const queue = new Queue(this, "RevalidationQueue", {
             fifo: true,
             receiveMessageWaitTime: CdkDuration.seconds(20),
@@ -272,16 +231,17 @@ export class NextjsSite extends SsrSite {
             ...cdk?.revalidation,
         });
         consumer.addEventSource(new SqsEventSource(queue, { batchSize: 5 }));
-        // Allow server to send messages to the queue
-        server.addEnvironment("REVALIDATION_QUEUE_URL", queue.queueUrl);
-        server.addEnvironment("REVALIDATION_QUEUE_REGION", Stack.of(this).region);
-        queue.grantSendMessages(server.role);
+        this.serverFunctions.forEach((server) => {
+            // Allow server to send messages to the queue
+            server.addEnvironment("REVALIDATION_QUEUE_URL", queue.queueUrl);
+            server.addEnvironment("REVALIDATION_QUEUE_REGION", Stack.of(this).region);
+            queue.grantSendMessages(server.role);
+        });
     }
     createRevalidationTable() {
         if (!this.serverFunction)
             return;
         const { path: sitePath } = this.props;
-        const server = this.serverFunction;
         const table = new Table(this, "RevalidationTable", {
             partitionKey: { name: "tag", type: AttributeType.STRING },
             sortKey: { name: "path", type: AttributeType.STRING },
@@ -296,8 +256,10 @@ export class NextjsSite extends SsrSite {
             ],
             removalPolicy: RemovalPolicy.DESTROY,
         });
-        server?.addEnvironment("CACHE_DYNAMO_TABLE", table.tableName);
-        table.grantReadWriteData(server.role);
+        this.serverFunctions.forEach((server) => {
+            server?.addEnvironment("CACHE_DYNAMO_TABLE", table.tableName);
+            table.grantReadWriteData(server.role);
+        });
         const dynamodbProviderPath = path.join(sitePath, ".open-next", "dynamodb-provider");
         if (fs.existsSync(dynamodbProviderPath)) {
             // Provision 128MB of memory for every 4,000 prerendered routes,
@@ -338,35 +300,11 @@ export class NextjsSite extends SsrSite {
         }
     }
     getConstructMetadata() {
-        const metadata = this.getConstructMetadataBase();
         return {
-            ...metadata,
             type: "NextjsSite",
-            data: {
-                ...metadata.data,
-                routes: this.isPerRouteLoggingEnabled()
-                    ? {
-                        logGroupPrefix: `/sst/lambda/${this.serverFunction.functionName}`,
-                        data: this.useRoutes().map(({ route, logGroupPath }) => ({
-                            route,
-                            logGroupPath,
-                        })),
-                    }
-                    : undefined,
-            },
+            ...this.getConstructMetadataBase(),
         };
     }
-    removeSourcemaps() {
-        const { path: sitePath } = this.props;
-        const files = globSync("**/*.js.map", {
-            cwd: path.join(sitePath, ".open-next", "server-function"),
-            nodir: true,
-            dot: true,
-        });
-        for (const file of files) {
-            fs.rmSync(path.join(sitePath, ".open-next", "server-function", file));
-        }
-    }
     useRoutes() {
         if (this._routes)
             return this._routes;
@@ -510,38 +448,57 @@ export class NextjsSite extends SsrSite {
             Logger.debug("Failed to load prerender-manifest.json", e);
         }
     }
-    useServerFunctionPerRouteLoggingInjection() {
+    // This function is used to improve cache hit ratio by setting the cache key based on the request headers and the path
+    // next/image only need the accept header, and this header is not useful for the rest of the query
+    useCloudFrontFunctionCacheHeaderKey() {
         return `
-if (event.rawPath) {
-  const routeData = ${JSON.stringify(
-        // @ts-expect-error
-        this.useRoutes().map(({ regexMatch, prefixMatch, logGroupPath }) => ({
-            regex: regexMatch,
-            prefix: prefixMatch,
-            logGroupPath,
-        })))}.find(({ regex, prefix }) => {
-    if (regex) return event.rawPath.match(new RegExp(regex));
-    if (prefix) return event.rawPath === prefix || (event.rawPath === prefix + "/");
-    return false;
-  });
-  if (routeData) {
-    console.log("::sst::" + JSON.stringify({
-      action:"log.split",
-      properties: {
-        logGroupName:"/sst/lambda/" + context.functionName + routeData.logGroupPath,
-      },
-    }));
+function getHeader(key) {
+  var header = request.headers[key];
+  if(header) {
+      if(header.multiValue){
+          return header.multiValue.map((header) => header.value).join(",");
+      }
+      if(header.value){
+          return header.value;
+      }
+  }
+  return ""
+  }
+  var cacheKey = "";
+  if(request.uri.startsWith("/_next/image")) {
+    cacheKey = getHeader("accept");
+  }else {
+    cacheKey = getHeader("rsc") + getHeader("next-router-prefetch") + getHeader("next-router-state-tree") + getHeader("next-url") + getHeader("x-prerender-revalidate");
+  }
+  if(request.cookies["__prerender_bypass"]) {
+    cacheKey += request.cookies["__prerender_bypass"] ? request.cookies["__prerender_bypass"].value : "";
   }
-}`;
+  var crypto = require('crypto');
+  
+  var hashedKey = crypto.createHash('md5').update(cacheKey).digest('hex');
+  request.headers["x-open-next-cache-key"] = {value: hashedKey};
+  `;
     }
-    useCloudFrontFunctionPrerenderBypassHeaderInjection() {
-        // In Next.js page router preview mode (depends on the cookie __prerender_bypass),
-        // to ensure we receive the cached page instead of the preview version, we set the
-        // header "x-prerender-bypass", and add it to cache policy's allowed headers.
+    // Inject the CloudFront viewer country, region, latitude, and longitude headers into the request headers
+    // for OpenNext to use them
+    useCloudfrontGeoHeadersInjection() {
         return `
-if (request.cookies["__prerender_bypass"]) { 
-  request.headers["x-prerender-bypass"] = { value: "true" }; 
-}`;
+if(request.headers["cloudfront-viewer-city"]) {
+  request.headers["x-open-next-city"] = request.headers["cloudfront-viewer-city"];
+}
+if(request.headers["cloudfront-viewer-country"]) {
+  request.headers["x-open-next-country"] = request.headers["cloudfront-viewer-country"];
+}
+if(request.headers["cloudfront-viewer-region"]) {
+  request.headers["x-open-next-region"] = request.headers["cloudfront-viewer-region"];
+}
+if(request.headers["cloudfront-viewer-latitude"]) {
+  request.headers["x-open-next-latitude"] = request.headers["cloudfront-viewer-latitude"];
+}
+if(request.headers["cloudfront-viewer-longitude"]) {
+  request.headers["x-open-next-longitude"] = request.headers["cloudfront-viewer-longitude"];
+}
+    `;
     }
     getBuildId() {
         const { path: sitePath } = this.props;
@@ -605,11 +562,6 @@ if (request.cookies["__prerender_bypass"]) {
             return;
         return sourcemapPath;
     }
-    isPerRouteLoggingEnabled() {
-        return (!this.doNotDeploy &&
-            !this.props.edge &&
-            this.props.logging === "per-route");
-    }
     handleMissingSourcemap() {
         if (this.doNotDeploy || this.props.edge)
             return;
@@ -618,48 +570,6 @@ if (request.cookies["__prerender_bypass"]) {
             return;
         this.serverFunction._overrideMissingSourcemap();
     }
-    disableDefaultLogging() {
-        const stack = Stack.of(this);
-        const server = this.serverFunction;
-        const policy = new Policy(this, "DisableLoggingPolicy", {
-            statements: [
-                new PolicyStatement({
-                    effect: Effect.DENY,
-                    actions: [
-                        "logs:CreateLogGroup",
-                        "logs:CreateLogStream",
-                        "logs:PutLogEvents",
-                    ],
-                    resources: [
-                        `arn:aws:logs:${stack.region}:${stack.account}:log-group:/aws/lambda/${server.functionName}`,
-                        `arn:aws:logs:${stack.region}:${stack.account}:log-group:/aws/lambda/${server.functionName}:*`,
-                    ],
-                }),
-            ],
-        });
-        server.role?.attachInlinePolicy(policy);
-    }
-    uploadSourcemaps() {
-        const stack = Stack.of(this);
-        const server = this.serverFunction;
-        this.useRoutes().forEach(({ sourcemapPath, sourcemapKey }) => {
-            if (!sourcemapPath || !sourcemapKey)
-                return;
-            useDeferredTasks().add(async () => {
-                // zip sourcemap
-                const zipPath = `${sourcemapPath}.gz.zip`;
-                const data = await fs.promises.readFile(sourcemapPath);
-                await fs.promises.writeFile(zipPath, zlib.gzipSync(data));
-                const asset = new Asset(this, `Sourcemap-${sourcemapKey}`, {
-                    path: zipPath,
-                });
-                useFunctions().sourcemaps.add(stack.stackName, {
-                    asset,
-                    tarKey: path.join(server.functionArn, sourcemapKey),
-                });
-            });
-        });
-    }
     static buildCloudWatchRouteName(route) {
         return route.replace(/[^a-zA-Z0-9_\-/.#]/g, "");
     }

package/constructs/RemixSite.d.ts

@@ -90,6 +90,9 @@ export declare class RemixSite extends SsrSite {
             allowedHeaders?: string[] | undefined;
         } | undefined;
         buildId?: string | undefined;
+        warmer?: {
+            function: string;
+        } | undefined;
     };
     private hasViteConfig;
     private getServerModuleFormat;

package/constructs/SolidStartSite.d.ts

@@ -72,6 +72,9 @@ export declare class SolidStartSite extends SsrSite {
             allowedHeaders?: string[] | undefined;
         } | undefined;
         buildId?: string | undefined;
+        warmer?: {
+            function: string;
+        } | undefined;
     };
     getConstructMetadata(): {
         data: {

package/constructs/SsrFunction.d.ts

@@ -1,7 +1,7 @@
 import { Construct } from "constructs";
 import { IGrantable } from "aws-cdk-lib/aws-iam";
 import { RetentionDays } from "aws-cdk-lib/aws-logs";
-import { FunctionOptions, Function as CdkFunction, FunctionUrlOptions } from "aws-cdk-lib/aws-lambda";
+import { FunctionOptions, Function as CdkFunction, FunctionUrlOptions, FunctionUrl } from "aws-cdk-lib/aws-lambda";
 import { NodeJSProps, FunctionCopyFilesProps } from "./Function.js";
 import { SSTConstruct } from "./Construct.js";
 import { BindingResource } from "./util/binding.js";
@@ -29,6 +29,7 @@ export declare class SsrFunction extends Construct implements SSTConstruct {
     /** @internal */
     readonly _doNotAllowOthersToBind = true;
     function: CdkFunction;
+    private functionUrl?;
     private assetReplacer;
     private assetReplacerPolicy;
     private missingSourcemap?;
@@ -37,8 +38,9 @@ export declare class SsrFunction extends Construct implements SSTConstruct {
     get role(): import("aws-cdk-lib/aws-iam").IRole | undefined;
     get functionArn(): string;
     get functionName(): string;
+    get url(): string | undefined;
     addEnvironment(key: string, value: string): CdkFunction;
-    addFunctionUrl(props?: FunctionUrlOptions): import("aws-cdk-lib/aws-lambda").FunctionUrl;
+    addFunctionUrl(props?: FunctionUrlOptions): FunctionUrl;
     grantInvoke(grantee: IGrantable): import("aws-cdk-lib/aws-iam").Grant;
     attachPermissions(permissions: Permissions): void;
     _overrideMissingSourcemap(): void;

package/constructs/SsrFunction.js

@@ -29,6 +29,7 @@ export class SsrFunction extends Construct {
     /** @internal */
     _doNotAllowOthersToBind = true;
     function;
+    functionUrl;
     assetReplacer;
     assetReplacerPolicy;
     missingSourcemap;
@@ -80,11 +81,15 @@ export class SsrFunction extends Construct {
     get functionName() {
         return this.function.functionName;
     }
+    get url() {
+        return this.functionUrl?.url;
+    }
     addEnvironment(key, value) {
         return this.function.addEnvironment(key, value);
     }
     addFunctionUrl(props) {
-        return this.function.addFunctionUrl(props);
+        this.functionUrl = this.function.addFunctionUrl(props);
+        return this.functionUrl;
     }
     grantInvoke(grantee) {
         return this.function.grantInvoke(grantee);

package/constructs/SsrSite.d.ts

@@ -1,7 +1,7 @@
 import { Construct } from "constructs";
 import { Bucket, BucketProps, IBucket } from "aws-cdk-lib/aws-s3";
 import { Function as CdkFunction, FunctionProps as CdkFunctionProps } from "aws-cdk-lib/aws-lambda";
-import { ICachePolicy, IResponseHeadersPolicy, ViewerProtocolPolicy, AllowedMethods, CachePolicyProps, ErrorResponse } from "aws-cdk-lib/aws-cloudfront";
+import { ICachePolicy, IResponseHeadersPolicy, ViewerProtocolPolicy, AllowedMethods, ErrorResponse } from "aws-cdk-lib/aws-cloudfront";
 import { S3OriginProps } from "aws-cdk-lib/aws-cloudfront-origins";
 import { DistributionDomainProps } from "./Distribution.js";
 import { SSTConstruct } from "./Construct.js";
@@ -13,26 +13,27 @@ import { Size } from "./util/size.js";
 import { Duration } from "./util/duration.js";
 import { Permissions } from "./util/permission.js";
 import { BindingResource, BindingProps } from "./util/binding.js";
-type CloudFrontFunctionConfig = {
+export type CloudFrontFunctionConfig = {
     constructId: string;
     injections: string[];
 };
-type EdgeFunctionConfig = {
+export type EdgeFunctionConfig = {
     constructId: string;
     function: EdgeFunctionProps;
 };
-type FunctionOriginConfig = {
+export type FunctionOriginConfig = {
     type: "function";
     constructId: string;
     function: SsrFunctionProps;
     injections?: string[];
     streaming?: boolean;
+    warm?: number;
 };
-type ImageOptimizationFunctionOriginConfig = {
+export type ImageOptimizationFunctionOriginConfig = {
     type: "image-optimization-function";
     function: CdkFunctionProps;
 };
-type S3OriginConfig = {
+export type S3OriginConfig = {
     type: "s3";
     originPath?: string;
     copy: {
@@ -42,7 +43,7 @@ type S3OriginConfig = {
         versionedSubDir?: string;
     }[];
 };
-type OriginGroupConfig = {
+export type OriginGroupConfig = {
     type: "group";
     primaryOriginName: string;
     fallbackOriginName: string;
@@ -424,11 +425,12 @@ export declare abstract class SsrSite extends Construct implements SSTConstruct
     protected doNotDeploy: boolean;
     protected bucket: Bucket;
     protected serverFunction?: EdgeFunction | SsrFunction;
+    protected serverFunctions: SsrFunction[];
+    protected edgeFunctions: Record<string, EdgeFunction>;
     private serverFunctionForDev?;
     private edge?;
     private distribution;
     constructor(scope: Construct, id: string, rawProps?: SsrSiteProps);
-    protected static buildDefaultServerCachePolicyProps(allowedHeaders: string[]): CachePolicyProps;
     /**
      * The CloudFront URL of the website.
      */
@@ -495,6 +497,9 @@ export declare abstract class SsrSite extends Construct implements SSTConstruct
             allowedHeaders?: string[];
         };
         buildId?: string;
+        warmer?: {
+            function: string;
+        };
     }): {
         cloudFrontFunctions?: CloudFrontFunctions | undefined;
         edgeFunctions?: EdgeFunctions | undefined;
@@ -513,6 +518,9 @@ export declare abstract class SsrSite extends Construct implements SSTConstruct
             allowedHeaders?: string[] | undefined;
         } | undefined;
         buildId?: string | undefined;
+        warmer?: {
+            function: string;
+        } | undefined;
     };
 }
 export declare const useSites: () => {

package/constructs/SsrSite.js

@@ -49,6 +49,8 @@ export class SsrSite extends Construct {
     doNotDeploy;
     bucket;
     serverFunction;
+    serverFunctions = [];
+    edgeFunctions = {};
     serverFunctionForDev;
     edge;
     distribution;
@@ -87,6 +89,7 @@ export class SsrSite extends Construct {
         }
         let s3DeployCRs = [];
         let ssrFunctions = [];
+        let warmConfig = [];
         let singletonUrlSigner;
         let singletonCachePolicy;
         let singletonOriginRequestPolicy;
@@ -107,6 +110,8 @@ export class SsrSite extends Construct {
         createWarmer();
         this.bucket = bucket;
         this.distribution = distribution;
+        this.serverFunctions = [...ssrFunctions];
+        this.edgeFunctions = { ...edgeFunctions };
         this.serverFunction = ssrFunctions[0] ?? Object.values(edgeFunctions)[0];
         this.edge = plan.edge;
         app.registerTypes(this);
@@ -213,27 +218,26 @@ export class SsrSite extends Construct {
             // note: Currently all sites have a single server function. When we add
             //       support for multiple server functions (ie. route splitting), we
             //       need to handle warming multiple functions.
-            if (!warm)
-                return;
-            if (warm && plan.edge) {
-                throw new VisibleError(`In the "${id}" Site, warming is currently supported only for the regional mode.`);
+            if (warm && ssrFunctions[0] instanceof SsrFunction) {
+                warmConfig.push({ concurrency: warm, function: ssrFunctions[0] });
             }
-            if (ssrFunctions.length === 0)
-                return;
+            const warmParams = warmConfig.map((config) => ({
+                concurrency: config.concurrency,
+                function: config.function.functionName,
+            }));
             // Create warmer function
             const warmer = new CdkFunction(self, "WarmerFunction", {
                 description: "SSR warmer",
-                code: Code.fromAsset(path.join(__dirname, "../support/ssr-warmer")),
+                code: Code.fromAsset(plan.warmer?.function ?? path.join(__dirname, "../support/ssr-warmer")),
                 runtime: Runtime.NODEJS_18_X,
                 handler: "index.handler",
                 timeout: CdkDuration.minutes(15),
                 memorySize: 128,
                 environment: {
-                    FUNCTION_NAME: ssrFunctions[0].functionName,
-                    CONCURRENCY: warm.toString(),
+                    WARM_PARAMS: JSON.stringify(warmParams),
                 },
             });
-            ssrFunctions[0].grantInvoke(warmer);
+            warmConfig.forEach((config) => config.function.grantInvoke(warmer));
             // Create cron job
             new Rule(self, "WarmerRule", {
                 schedule: Schedule.rate(CdkDuration.minutes(5)),
@@ -461,6 +465,9 @@ function handler(event) {
                 prefetchSecrets: regional?.prefetchSecrets,
             });
             ssrFunctions.push(fn);
+            if (props.warm) {
+                warmConfig.push({ concurrency: props.warm, function: fn });
+            }
             bucket.grantReadWrite(fn?.role);
             const fnUrl = fn.addFunctionUrl({
                 authType: regional?.enableServerUrlIamAuth
@@ -638,7 +645,19 @@ function handler(event) {
             const allowedHeaders = plan.serverCachePolicy?.allowedHeaders ?? [];
             singletonCachePolicy =
                 singletonCachePolicy ??
-                    new CachePolicy(self, "ServerCache", SsrSite.buildDefaultServerCachePolicyProps(allowedHeaders));
+                    new CachePolicy(self, "ServerCache", {
+                        queryStringBehavior: CacheQueryStringBehavior.all(),
+                        headerBehavior: allowedHeaders.length > 0
+                            ? CacheHeaderBehavior.allowList(...allowedHeaders)
+                            : CacheHeaderBehavior.none(),
+                        cookieBehavior: CacheCookieBehavior.none(),
+                        defaultTtl: CdkDuration.days(0),
+                        maxTtl: CdkDuration.days(365),
+                        minTtl: CdkDuration.days(0),
+                        enableAcceptEncodingBrotli: true,
+                        enableAcceptEncodingGzip: true,
+                        comment: "SST server response cache policy",
+                    });
             return singletonCachePolicy;
         }
         function useServerBehaviorOriginRequestPolicy() {
@@ -797,21 +816,6 @@ function handler(event) {
             });
         }
     }
-    static buildDefaultServerCachePolicyProps(allowedHeaders) {
-        return {
-            queryStringBehavior: CacheQueryStringBehavior.all(),
-            headerBehavior: allowedHeaders.length > 0
-                ? CacheHeaderBehavior.allowList(...allowedHeaders)
-                : CacheHeaderBehavior.none(),
-            cookieBehavior: CacheCookieBehavior.none(),
-            defaultTtl: CdkDuration.days(0),
-            maxTtl: CdkDuration.days(365),
-            minTtl: CdkDuration.days(0),
-            enableAcceptEncodingBrotli: true,
-            enableAcceptEncodingGzip: true,
-            comment: "SST server response cache policy",
-        };
-    }
     /**
      * The CloudFront URL of the website.
      */

package/constructs/SvelteKitSite.d.ts

@@ -103,6 +103,9 @@ export declare class SvelteKitSite extends SsrSite {
             allowedHeaders?: string[] | undefined;
         } | undefined;
         buildId?: string | undefined;
+        warmer?: {
+            function: string;
+        } | undefined;
     };
     getConstructMetadata(): {
         data: {

package/package.json

@@ -1,7 +1,7 @@
 {
   "sideEffects": false,
   "name": "sst",
-  "version": "2.42.0",
+  "version": "2.43.0",
   "bin": {
     "sst": "cli/sst.js"
   },
@@ -118,7 +118,7 @@
     "@types/ws": "^8.5.3",
     "@types/yargs": "^17.0.13",
     "archiver": "^5.3.1",
-    "astro-sst": "2.42.0",
+    "astro-sst": "2.43.0",
     "async": "^3.2.4",
     "tsx": "^3.12.1",
     "typescript": "^5.2.2",

package/support/ssr-warmer/index.mjs

@@ -30914,62 +30914,65 @@ var require_dist_cjs59 = __commonJS({
 // support/ssr-warmer/index.ts
 var import_client_lambda = __toESM(require_dist_cjs59(), 1);
 var lambda = new import_client_lambda.LambdaClient({});
-var FUNCTION_NAME = process.env.FUNCTION_NAME;
-var CONCURRENCY = parseInt(process.env.CONCURRENCY);
+var warmParams = JSON.parse(process.env.WARM_PARAMS);
 function generateUniqueId() {
   return Math.random().toString(36).slice(2, 8);
 }
 async function handler(_event, context) {
   const warmerId = `warmer-${generateUniqueId()}`;
-  console.log({
-    event: "warmer invoked",
-    functionName: FUNCTION_NAME,
-    concurrency: CONCURRENCY,
-    warmerId
-  });
-  const ret = await Promise.all(
-    Array.from({ length: CONCURRENCY }, (_v, i) => i).map((i) => {
-      try {
-        return lambda.send(
-          new import_client_lambda.InvokeCommand({
-            FunctionName: FUNCTION_NAME,
-            InvocationType: "RequestResponse",
-            Payload: JSON.stringify({
-              type: "warmer",
-              warmerId,
-              index: i,
-              concurrency: CONCURRENCY,
-              delay: 75
+  for (const warmParam of warmParams) {
+    const { concurrency: CONCURRENCY, function: FUNCTION_NAME } = warmParam;
+    console.log({
+      event: "warmer invoked",
+      functionName: FUNCTION_NAME,
+      concurrency: CONCURRENCY,
+      warmerId
+    });
+    const ret = await Promise.all(
+      Array.from({ length: CONCURRENCY }, (_v, i) => i).map((i) => {
+        try {
+          return lambda.send(
+            new import_client_lambda.InvokeCommand({
+              FunctionName: FUNCTION_NAME,
+              InvocationType: "RequestResponse",
+              Payload: JSON.stringify({
+                type: "warmer",
+                warmerId,
+                index: i,
+                concurrency: CONCURRENCY,
+                delay: 75
+              })
             })
-          })
+          );
+        } catch (e) {
+          console.error(`failed to warm up #${i}`, e);
+        }
+      })
+    );
+    const warmedServerIds = [];
+    ret.forEach((r, i) => {
+      if (r?.StatusCode !== 200 || !r?.Payload) {
+        console.error(`failed to warm up #${i}:`, r?.Payload?.toString());
+        return;
+      }
+      const payloadString = r.Payload.transformToString();
+      if (payloadString) {
+        const payload = JSON.parse(
+          r.Payload.transformToString()
         );
-      } catch (e) {
-        console.error(`failed to warm up #${i}`, e);
-      }
-    })
-  );
-  const warmedServerIds = [];
-  ret.forEach((r, i) => {
-    if (r?.StatusCode !== 200 || !r?.Payload) {
-      console.error(`failed to warm up #${i}:`, r?.Payload?.toString());
-      return;
-    }
-    const payloadString = r.Payload.transformToString();
-    if (payloadString) {
-      const payload = JSON.parse(
-        r.Payload.transformToString()
-      );
-      warmedServerIds.push(payload.serverId);
-    } else {
-      warmedServerIds.push("unknown");
-    }
-  });
-  console.log({
-    event: "warmer result",
-    sent: CONCURRENCY,
-    success: warmedServerIds.length,
-    uniqueServersWarmed: [...new Set(warmedServerIds)].length
-  });
+        warmedServerIds.push(payload.serverId);
+      } else {
+        warmedServerIds.push("unknown");
+      }
+    });
+    console.log({
+      event: "warmer result",
+      sent: CONCURRENCY,
+      name: FUNCTION_NAME,
+      success: warmedServerIds.length,
+      uniqueServersWarmed: [...new Set(warmedServerIds)].length
+    });
+  }
 }
 export {
   handler