cdk-nextjs 0.6.2 → 0.7.1

package/lib/nextjs-cache.js

@@ -1,19 +1,92 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.NextjsCache = void 0;
 const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
 const fs_1 = require("fs");
+const os_1 = require("os");
+const path_1 = require("path");
 const aws_cdk_lib_1 = require("aws-cdk-lib");
 const aws_dynamodb_1 = require("aws-cdk-lib/aws-dynamodb");
 const aws_s3_1 = require("aws-cdk-lib/aws-s3");
 const aws_s3_deployment_1 = require("aws-cdk-lib/aws-s3-deployment");
+const cxapi = __importStar(require("aws-cdk-lib/cx-api"));
 const constructs_1 = require("constructs");
 const constants_1 = require("./constants");
+/** What a `BucketDeployment` Lambda gets without asking. */
+const DEFAULT_EPHEMERAL_STORAGE_MIB = 512;
+/** The most Lambda will give any function. */
+const MAX_EPHEMERAL_STORAGE_MIB = 10240;
+/**
+ * The smallest power-of-two MiB step at or above `mib`, capped at `max`.
+ *
+ * `BucketDeployment` folds `ephemeralStorageSize` into both its singleton
+ * handler's UUID and its custom resource's logical ID, so every distinct size is
+ * a new handler Lambda, a new `ServiceToken`, and a replaced custom resource.
+ * Sized to the MiB, that was every deploy whose init cache grew by one: a full
+ * CloudFormation deployment where a hotswap would have done. Doubling steps
+ * change only when the cache does by a large fraction.
+ */
+function storageStep(mib, max) {
+    let step = DEFAULT_EPHEMERAL_STORAGE_MIB;
+    while (step < mib) {
+        step *= 2;
+    }
+    return Math.min(step, max);
+}
+/** Bytes on disk under `dir`, following the tree but not symlinks. */
+function sizeOfDirectory(dir) {
+    let total = 0;
+    for (const entry of (0, fs_1.readdirSync)(dir, {
+        withFileTypes: true,
+        recursive: true,
+    })) {
+        if (entry.isFile()) {
+            // `parentPath` only exists from Node 20.12; `path` is its deprecated
+            // predecessor, and the only one on 20.9-20.11.
+            const parent = entry.parentPath ?? entry.path;
+            total += (0, fs_1.statSync)((0, path_1.join)(parent, entry.name)).size;
+        }
+    }
+    return total;
+}
 /**
  * Next.js Cache construct providing unified S3 and DynamoDB cache management.
  */
 class NextjsCache extends constructs_1.Construct {
-    static [JSII_RTTI_SYMBOL_1] = { fqn: "cdk-nextjs.NextjsCache", version: "0.6.2" };
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "cdk-nextjs.NextjsCache", version: "0.7.1" };
     cacheBucket;
     revalidationTable;
     buildId;
@@ -45,6 +118,9 @@ class NextjsCache extends constructs_1.Construct {
     /**
      * Creates DynamoDB table for revalidation metadata
      * Schema: pk (buildId or "METADATA"), sk (tag#cacheKey or "CURRENT_BUILD"), createdAt, revalidatedAt
+     *
+     * Also the `'use cache'` revalidation log (pk "<buildId>#log",
+     * sk "<epoch-ms>#<tag>"), whose rows expire through the `ttl` attribute.
      */
     createRevalidationTable() {
         const table = new aws_dynamodb_1.TableV2(this, "RevalidationTable", {
@@ -58,6 +134,7 @@ class NextjsCache extends constructs_1.Construct {
             },
             billing: aws_dynamodb_1.Billing.onDemand(),
             removalPolicy: aws_cdk_lib_1.RemovalPolicy.DESTROY,
+            timeToLiveAttribute: "ttl",
             ...this.props.overrides?.revalidationTableProps,
         });
         return table;
@@ -72,16 +149,115 @@ class NextjsCache extends constructs_1.Construct {
             return undefined;
         }
         console.log(`${constants_1.LOG_PREFIX} Deploying init cache from ${this.props.initCacheDir}`);
-        // Use standard BucketDeployment for regular S3 buckets
-        const bucketDeployment = new aws_s3_deployment_1.BucketDeployment(this, "InitCacheDeployment", {
-            sources: [aws_s3_deployment_1.Source.asset(this.props.initCacheDir)],
-            destinationBucket: this.cacheBucket,
-            destinationKeyPrefix: this.props.buildId, // Add buildId prefix to all uploaded files
-            prune: false, // Don't delete existing objects to prevent 404s during deployment, pruning will be handled by post-deploy
-            ...this.props.overrides?.bucketDeploymentProps,
+        const stagingDir = this.createStagingDirectory();
+        try {
+            // Use standard BucketDeployment for regular S3 buckets
+            const bucketDeployment = new aws_s3_deployment_1.BucketDeployment(this, "InitCacheDeployment", {
+                sources: [aws_s3_deployment_1.Source.asset(stagingDir)],
+                destinationBucket: this.cacheBucket,
+                prune: false, // Don't delete existing objects to prevent 404s during deployment, pruning will be handled by post-deploy
+                ...this.sizeDeploymentLambda(),
+                ...this.props.overrides?.bucketDeploymentProps,
+            });
+            return bucketDeployment;
+        }
+        finally {
+            // `Source.asset` stages during `BucketDeployment`'s construction - CDK's
+            // `AssetStaging` zips into `cdk.out` from its own constructor - so the
+            // temporary copy is dead the moment that returns. Leaving it was a slow
+            // leak with a large unit: the init cache has been measured at 664 MiB, and
+            // every `cdk synth` left another full copy in the system temp directory,
+            // so a CI loop of ~22 deploys could put ~15 GB on the runner's disk.
+            //
+            // Unless staging is disabled (`cdk synth --no-staging`, and SAM, which
+            // sets the same context): then nothing is copied into `cdk.out`, the
+            // asset manifest points at this directory itself, and removing it fails
+            // the publish that follows the synth with ENOENT.
+            if (!this.node.tryGetContext(cxapi.DISABLE_ASSET_STAGING_CONTEXT)) {
+                (0, fs_1.rmSync)(stagingDir, { recursive: true, force: true });
+            }
+        }
+    }
+    /**
+     * `/tmp` and memory for `BucketDeployment`'s unzip Lambda, scaled to the init
+     * cache it has to unpack.
+     *
+     * That Lambda downloads the asset zip into `/tmp` and then extracts it
+     * alongside, so it needs room for both at once. CDK defaults it to 512 MiB of
+     * ephemeral storage and 128 MB of memory — fine for a small app, and a hard
+     * failure for one whose prerendered payloads are large. A fixture with 60
+     * statically generated pages carrying ~1 MB of RSC each produced a 664 MiB
+     * seed directory and the handler died on
+     * `OSError: [Errno 28] No space left on device` inside `zip.extractall`.
+     * Worse, `cdk deploy --hotswap` invokes the custom resource directly with a
+     * placeholder response URL, so the `Status: FAILED` it sends goes nowhere: the
+     * CLI prints "Contents of AWS::S3::Bucket … hotswapped!", exits 0, and the app
+     * comes up serving a *partially* seeded cache. Every route whose entry did not
+     * make it is then a miss that re-renders — which, for a
+     * `cacheComponents: true` app, means a postponed shell where the prerender
+     * should have been.
+     *
+     * The zip's compressed size is not known at synth time (CDK archives the asset
+     * later), so the worst case — an incompressible payload — is what gets
+     * budgeted: twice the directory, plus headroom, rounded up to a
+     * {@link storageStep}. Memory is only raised past
+     * CDK's default for caches big enough that 128 MB's slice of a vCPU would make
+     * the unzip and upload race the custom resource's 15-minute timeout; small
+     * apps keep the cheaper default and their existing template.
+     *
+     * Above the 10 GiB ephemeral-storage ceiling there is nothing left to ask for,
+     * so this warns and lets the deployment fail loudly rather than pretend.
+     * `overrides.bucketDeploymentProps` wins over everything here, including
+     * `useEfs: true`, which is the supported way out.
+     */
+    sizeDeploymentLambda() {
+        const mib = Math.ceil(sizeOfDirectory(this.props.initCacheDir) / 1024 ** 2);
+        const wanted = mib * 2 + 128;
+        if (wanted > MAX_EPHEMERAL_STORAGE_MIB) {
+            console.warn(`${constants_1.LOG_PREFIX} The init cache at ${this.props.initCacheDir} is ${mib} MiB, which does not fit in the ${MAX_EPHEMERAL_STORAGE_MIB} MiB of ephemeral storage a BucketDeployment Lambda can be given. Pass overrides.bucketDeploymentProps with useEfs: true to seed a cache this large.`);
+        }
+        const ephemeral = storageStep(wanted, MAX_EPHEMERAL_STORAGE_MIB);
+        return {
+            ephemeralStorageSize: aws_cdk_lib_1.Size.mebibytes(ephemeral),
+            ...(mib > 256 ? { memoryLimit: 1024 } : {}),
+        };
+    }
+    /**
+     * Stage the init cache under a `buildId` directory, so that the objects land
+     * at `<buildId>/<key>` without a `destinationKeyPrefix`.
+     *
+     * The keys have to carry the build ID — that is how the runtime cache handler
+     * and the post-deploy pruner namespace one deployment's entries from the next
+     * (`src/adapter/s3-cache-handler.ts`). Asking `BucketDeployment` for it, as
+     * this used to, is what costs: it unconditionally tags the *destination
+     * bucket* with `aws-cdk:cr-owned:<destinationKeyPrefix>:<hash>`, so a prefix
+     * that changes per build makes the bucket's `Tags` change per build.
+     * `AWS::S3::Bucket` `Tags` are not hotswappable, so `cdk deploy
+     * --hotswap-fallback` rejected the diff and fell back to a full CloudFormation
+     * deployment every single time — measured at 19 of 22 deploys in one harness
+     * run, ~110s each against a ~52s hotswap.
+     *
+     * Putting the build ID in the asset's own paths instead leaves the S3 keys
+     * byte-identical and the tag key constant (`aws-cdk:cr-owned:<hash>`, derived
+     * from the construct path). Nothing else read the prefix: `prune` is already
+     * `false`, and the two handler branches that do scope work to it — emptying
+     * the prefix on delete, and deleting the old prefix when the destination
+     * changes — are both gated on `retainOnDelete`, which `BucketDeployment`
+     * defaults to `true`.
+     *
+     * A copy rather than the directory itself because the build ID is only known
+     * *after* `next build`, so the adapter cannot write into a nested directory in
+     * the first place, and because `.next/cdk-nextjs-init-cache` has to stay where
+     * it is for the local cache handler to read it (`CDK_NEXTJS_INIT_CACHE_DIR`).
+     * CDK is about to read every byte of this to zip it regardless.
+     */
+    createStagingDirectory() {
+        const stagingDir = (0, fs_1.mkdtempSync)((0, path_1.join)((0, os_1.tmpdir)(), "nextjs-init-cache-"));
+        (0, fs_1.cpSync)(this.props.initCacheDir, (0, path_1.join)(stagingDir, this.props.buildId), {
+            recursive: true,
         });
-        return bucketDeployment;
+        return stagingDir;
     }
 }
 exports.NextjsCache = NextjsCache;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"nextjs-cache.js","sourceRoot":"","sources":["../src/nextjs-cache.ts"],"names":[],"mappings":"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","sourcesContent":["import { existsSync } from \"fs\";\nimport { RemovalPolicy } from \"aws-cdk-lib\";\nimport {\n  AttributeType,\n  Billing,\n  TableV2,\n  TablePropsV2,\n  ITableV2,\n} from \"aws-cdk-lib/aws-dynamodb\";\nimport {\n  Bucket,\n  BucketEncryption,\n  BucketProps,\n  BlockPublicAccess,\n  IBucket,\n} from \"aws-cdk-lib/aws-s3\";\nimport {\n  BucketDeployment,\n  BucketDeploymentProps,\n  Source,\n} from \"aws-cdk-lib/aws-s3-deployment\";\nimport { Construct } from \"constructs\";\nimport { LOG_PREFIX } from \"./constants\";\n\nexport interface NextjsCacheOverrides {\n  readonly cacheBucketProps?: BucketProps;\n  readonly revalidationTableProps?: TablePropsV2;\n  readonly bucketDeploymentProps?: BucketDeploymentProps;\n}\n\nexport interface NextjsCacheProps {\n  readonly buildId: string;\n  /**\n   * Bring your own S3 bucket for cache storage. When provided, cdk-nextjs\n   * will skip creating a new bucket. Cache objects are prefixed with `buildId`\n   * so multiple deployments can safely share one bucket.\n   */\n  readonly cacheBucket?: IBucket;\n  /**\n   * Absolute path to the init cache directory\n   * @example \"/Users/john/myapp/.next/cdk-nextjs-init-cache\"\n   */\n  readonly initCacheDir: string;\n  readonly overrides?: NextjsCacheOverrides;\n  /**\n   * Bring your own DynamoDB table for revalidation metadata. When provided,\n   * cdk-nextjs will skip creating a new table. The table must have `pk` (String)\n   * as partition key and `sk` (String) as sort key. Entries are partitioned by\n   * `buildId` so multiple deployments can safely share one table.\n   */\n  readonly revalidationTable?: ITableV2;\n}\n\n/**\n * Next.js Cache construct providing unified S3 and DynamoDB cache management.\n */\nexport class NextjsCache extends Construct {\n  readonly cacheBucket: IBucket;\n  readonly revalidationTable: ITableV2;\n  readonly buildId: string;\n  readonly bucketDeployment?: BucketDeployment;\n  private props: NextjsCacheProps;\n\n  constructor(scope: Construct, id: string, props: NextjsCacheProps) {\n    super(scope, id);\n    this.props = props;\n    this.buildId = props.buildId;\n    this.cacheBucket = props.cacheBucket ?? this.createCacheBucket();\n    this.revalidationTable =\n      props.revalidationTable ?? this.createRevalidationTable();\n    this.bucketDeployment = this.createDeployment();\n  }\n\n  /**\n   * Creates S3 bucket for cache storage with BUILD_ID prefixing.\n   */\n  private createCacheBucket(): IBucket {\n    const bucket = new Bucket(this, \"Bucket\", {\n      encryption: BucketEncryption.S3_MANAGED,\n      blockPublicAccess: BlockPublicAccess.BLOCK_ALL,\n      removalPolicy: RemovalPolicy.DESTROY,\n      autoDeleteObjects: true,\n      enforceSSL: true,\n      ...this.props.overrides?.cacheBucketProps,\n    });\n\n    return bucket;\n  }\n\n  /**\n   * Creates DynamoDB table for revalidation metadata\n   * Schema: pk (buildId or \"METADATA\"), sk (tag#cacheKey or \"CURRENT_BUILD\"), createdAt, revalidatedAt\n   */\n  private createRevalidationTable(): TableV2 {\n    const table = new TableV2(this, \"RevalidationTable\", {\n      partitionKey: {\n        name: \"pk\",\n        type: AttributeType.STRING,\n      },\n      sortKey: {\n        name: \"sk\",\n        type: AttributeType.STRING,\n      },\n      billing: Billing.onDemand(),\n      removalPolicy: RemovalPolicy.DESTROY,\n      ...this.props.overrides?.revalidationTableProps,\n    });\n\n    return table;\n  }\n\n  /**\n   * Deploy pre-built cache files from .next/cdk-nextjs-init-cache to S3\n   */\n  private createDeployment(): BucketDeployment | undefined {\n    // Check if cache directory exists\n    if (!existsSync(this.props.initCacheDir)) {\n      console.log(\n        `${LOG_PREFIX} No pre-built cache found at ${this.props.initCacheDir}, skipping init cache deployment`,\n      );\n      return undefined;\n    }\n\n    console.log(\n      `${LOG_PREFIX} Deploying init cache from ${this.props.initCacheDir}`,\n    );\n\n    // Use standard BucketDeployment for regular S3 buckets\n    const bucketDeployment = new BucketDeployment(this, \"InitCacheDeployment\", {\n      sources: [Source.asset(this.props.initCacheDir)],\n      destinationBucket: this.cacheBucket,\n      destinationKeyPrefix: this.props.buildId, // Add buildId prefix to all uploaded files\n      prune: false, // Don't delete existing objects to prevent 404s during deployment, pruning will be handled by post-deploy\n      ...this.props.overrides?.bucketDeploymentProps,\n    });\n    return bucketDeployment;\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"nextjs-cache.js","sourceRoot":"","sources":["../src/nextjs-cache.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  cpSync,\n  existsSync,\n  mkdtempSync,\n  readdirSync,\n  rmSync,\n  statSync,\n} from \"fs\";\nimport { tmpdir } from \"os\";\nimport { join } from \"path\";\nimport { RemovalPolicy, Size } from \"aws-cdk-lib\";\nimport {\n  AttributeType,\n  Billing,\n  TableV2,\n  TablePropsV2,\n  ITableV2,\n} from \"aws-cdk-lib/aws-dynamodb\";\nimport {\n  Bucket,\n  BucketEncryption,\n  BucketProps,\n  BlockPublicAccess,\n  IBucket,\n} from \"aws-cdk-lib/aws-s3\";\nimport {\n  BucketDeployment,\n  BucketDeploymentProps,\n  Source,\n} from \"aws-cdk-lib/aws-s3-deployment\";\nimport * as cxapi from \"aws-cdk-lib/cx-api\";\nimport { Construct } from \"constructs\";\nimport { LOG_PREFIX } from \"./constants\";\n\n/** What a `BucketDeployment` Lambda gets without asking. */\nconst DEFAULT_EPHEMERAL_STORAGE_MIB = 512;\n/** The most Lambda will give any function. */\nconst MAX_EPHEMERAL_STORAGE_MIB = 10240;\n\n/**\n * The smallest power-of-two MiB step at or above `mib`, capped at `max`.\n *\n * `BucketDeployment` folds `ephemeralStorageSize` into both its singleton\n * handler's UUID and its custom resource's logical ID, so every distinct size is\n * a new handler Lambda, a new `ServiceToken`, and a replaced custom resource.\n * Sized to the MiB, that was every deploy whose init cache grew by one: a full\n * CloudFormation deployment where a hotswap would have done. Doubling steps\n * change only when the cache does by a large fraction.\n */\nfunction storageStep(mib: number, max: number): number {\n  let step = DEFAULT_EPHEMERAL_STORAGE_MIB;\n  while (step < mib) {\n    step *= 2;\n  }\n  return Math.min(step, max);\n}\n\n/** Bytes on disk under `dir`, following the tree but not symlinks. */\nfunction sizeOfDirectory(dir: string): number {\n  let total = 0;\n  for (const entry of readdirSync(dir, {\n    withFileTypes: true,\n    recursive: true,\n  })) {\n    if (entry.isFile()) {\n      // `parentPath` only exists from Node 20.12; `path` is its deprecated\n      // predecessor, and the only one on 20.9-20.11.\n      const parent =\n        entry.parentPath ?? (entry as unknown as { path: string }).path;\n      total += statSync(join(parent, entry.name)).size;\n    }\n  }\n  return total;\n}\n\nexport interface NextjsCacheOverrides {\n  readonly cacheBucketProps?: BucketProps;\n  readonly revalidationTableProps?: TablePropsV2;\n  readonly bucketDeploymentProps?: BucketDeploymentProps;\n}\n\nexport interface NextjsCacheProps {\n  readonly buildId: string;\n  /**\n   * Bring your own S3 bucket for cache storage. When provided, cdk-nextjs\n   * will skip creating a new bucket.\n   *\n   * The bucket must be dedicated to this one deployment. Don't share it with\n   * another deployment (another branch, stage, or app): every deploy's\n   * post-deploy step deletes every object under a top-level prefix other than\n   * the current `buildId/`, which includes every other deployment's cache.\n   */\n  readonly cacheBucket?: IBucket;\n  /**\n   * Absolute path to the init cache directory\n   * @example \"/Users/john/myapp/.next/cdk-nextjs-init-cache\"\n   */\n  readonly initCacheDir: string;\n  readonly overrides?: NextjsCacheOverrides;\n  /**\n   * Bring your own DynamoDB table for revalidation metadata. When provided,\n   * cdk-nextjs will skip creating a new table. The table must have `pk` (String)\n   * as partition key and `sk` (String) as sort key.\n   * Enabling TTL on its `ttl` attribute is recommended: each tag revalidation\n   * writes a revalidation log row that expires through it after 15 minutes.\n   * Without TTL those rows are kept until a deploy replaces their build, whose\n   * post-deploy step deletes them.\n   *\n   * The table must be dedicated to this one deployment. Don't share it with\n   * another deployment (another branch, stage, or app): every deploy's\n   * post-deploy step deletes the entries of the build it last recorded in the\n   * table, which with a shared table is another deployment's live build.\n   */\n  readonly revalidationTable?: ITableV2;\n}\n\n/**\n * Next.js Cache construct providing unified S3 and DynamoDB cache management.\n */\nexport class NextjsCache extends Construct {\n  readonly cacheBucket: IBucket;\n  readonly revalidationTable: ITableV2;\n  readonly buildId: string;\n  readonly bucketDeployment?: BucketDeployment;\n  private props: NextjsCacheProps;\n\n  constructor(scope: Construct, id: string, props: NextjsCacheProps) {\n    super(scope, id);\n    this.props = props;\n    this.buildId = props.buildId;\n    this.cacheBucket = props.cacheBucket ?? this.createCacheBucket();\n    this.revalidationTable =\n      props.revalidationTable ?? this.createRevalidationTable();\n    this.bucketDeployment = this.createDeployment();\n  }\n\n  /**\n   * Creates S3 bucket for cache storage with BUILD_ID prefixing.\n   */\n  private createCacheBucket(): IBucket {\n    const bucket = new Bucket(this, \"Bucket\", {\n      encryption: BucketEncryption.S3_MANAGED,\n      blockPublicAccess: BlockPublicAccess.BLOCK_ALL,\n      removalPolicy: RemovalPolicy.DESTROY,\n      autoDeleteObjects: true,\n      enforceSSL: true,\n      ...this.props.overrides?.cacheBucketProps,\n    });\n\n    return bucket;\n  }\n\n  /**\n   * Creates DynamoDB table for revalidation metadata\n   * Schema: pk (buildId or \"METADATA\"), sk (tag#cacheKey or \"CURRENT_BUILD\"), createdAt, revalidatedAt\n   *\n   * Also the `'use cache'` revalidation log (pk \"<buildId>#log\",\n   * sk \"<epoch-ms>#<tag>\"), whose rows expire through the `ttl` attribute.\n   */\n  private createRevalidationTable(): TableV2 {\n    const table = new TableV2(this, \"RevalidationTable\", {\n      partitionKey: {\n        name: \"pk\",\n        type: AttributeType.STRING,\n      },\n      sortKey: {\n        name: \"sk\",\n        type: AttributeType.STRING,\n      },\n      billing: Billing.onDemand(),\n      removalPolicy: RemovalPolicy.DESTROY,\n      timeToLiveAttribute: \"ttl\",\n      ...this.props.overrides?.revalidationTableProps,\n    });\n\n    return table;\n  }\n\n  /**\n   * Deploy pre-built cache files from .next/cdk-nextjs-init-cache to S3\n   */\n  private createDeployment(): BucketDeployment | undefined {\n    // Check if cache directory exists\n    if (!existsSync(this.props.initCacheDir)) {\n      console.log(\n        `${LOG_PREFIX} No pre-built cache found at ${this.props.initCacheDir}, skipping init cache deployment`,\n      );\n      return undefined;\n    }\n\n    console.log(\n      `${LOG_PREFIX} Deploying init cache from ${this.props.initCacheDir}`,\n    );\n\n    const stagingDir = this.createStagingDirectory();\n\n    try {\n      // Use standard BucketDeployment for regular S3 buckets\n      const bucketDeployment = new BucketDeployment(\n        this,\n        \"InitCacheDeployment\",\n        {\n          sources: [Source.asset(stagingDir)],\n          destinationBucket: this.cacheBucket,\n          prune: false, // Don't delete existing objects to prevent 404s during deployment, pruning will be handled by post-deploy\n          ...this.sizeDeploymentLambda(),\n          ...this.props.overrides?.bucketDeploymentProps,\n        },\n      );\n      return bucketDeployment;\n    } finally {\n      // `Source.asset` stages during `BucketDeployment`'s construction - CDK's\n      // `AssetStaging` zips into `cdk.out` from its own constructor - so the\n      // temporary copy is dead the moment that returns. Leaving it was a slow\n      // leak with a large unit: the init cache has been measured at 664 MiB, and\n      // every `cdk synth` left another full copy in the system temp directory,\n      // so a CI loop of ~22 deploys could put ~15 GB on the runner's disk.\n      //\n      // Unless staging is disabled (`cdk synth --no-staging`, and SAM, which\n      // sets the same context): then nothing is copied into `cdk.out`, the\n      // asset manifest points at this directory itself, and removing it fails\n      // the publish that follows the synth with ENOENT.\n      if (!this.node.tryGetContext(cxapi.DISABLE_ASSET_STAGING_CONTEXT)) {\n        rmSync(stagingDir, { recursive: true, force: true });\n      }\n    }\n  }\n\n  /**\n   * `/tmp` and memory for `BucketDeployment`'s unzip Lambda, scaled to the init\n   * cache it has to unpack.\n   *\n   * That Lambda downloads the asset zip into `/tmp` and then extracts it\n   * alongside, so it needs room for both at once. CDK defaults it to 512 MiB of\n   * ephemeral storage and 128 MB of memory — fine for a small app, and a hard\n   * failure for one whose prerendered payloads are large. A fixture with 60\n   * statically generated pages carrying ~1 MB of RSC each produced a 664 MiB\n   * seed directory and the handler died on\n   * `OSError: [Errno 28] No space left on device` inside `zip.extractall`.\n   * Worse, `cdk deploy --hotswap` invokes the custom resource directly with a\n   * placeholder response URL, so the `Status: FAILED` it sends goes nowhere: the\n   * CLI prints \"Contents of AWS::S3::Bucket … hotswapped!\", exits 0, and the app\n   * comes up serving a *partially* seeded cache. Every route whose entry did not\n   * make it is then a miss that re-renders — which, for a\n   * `cacheComponents: true` app, means a postponed shell where the prerender\n   * should have been.\n   *\n   * The zip's compressed size is not known at synth time (CDK archives the asset\n   * later), so the worst case — an incompressible payload — is what gets\n   * budgeted: twice the directory, plus headroom, rounded up to a\n   * {@link storageStep}. Memory is only raised past\n   * CDK's default for caches big enough that 128 MB's slice of a vCPU would make\n   * the unzip and upload race the custom resource's 15-minute timeout; small\n   * apps keep the cheaper default and their existing template.\n   *\n   * Above the 10 GiB ephemeral-storage ceiling there is nothing left to ask for,\n   * so this warns and lets the deployment fail loudly rather than pretend.\n   * `overrides.bucketDeploymentProps` wins over everything here, including\n   * `useEfs: true`, which is the supported way out.\n   */\n  private sizeDeploymentLambda() {\n    const mib = Math.ceil(sizeOfDirectory(this.props.initCacheDir) / 1024 ** 2);\n    const wanted = mib * 2 + 128;\n    if (wanted > MAX_EPHEMERAL_STORAGE_MIB) {\n      console.warn(\n        `${LOG_PREFIX} The init cache at ${this.props.initCacheDir} is ${mib} MiB, which does not fit in the ${MAX_EPHEMERAL_STORAGE_MIB} MiB of ephemeral storage a BucketDeployment Lambda can be given. Pass overrides.bucketDeploymentProps with useEfs: true to seed a cache this large.`,\n      );\n    }\n    const ephemeral = storageStep(wanted, MAX_EPHEMERAL_STORAGE_MIB);\n\n    return {\n      ephemeralStorageSize: Size.mebibytes(ephemeral),\n      ...(mib > 256 ? { memoryLimit: 1024 } : {}),\n    };\n  }\n\n  /**\n   * Stage the init cache under a `buildId` directory, so that the objects land\n   * at `<buildId>/<key>` without a `destinationKeyPrefix`.\n   *\n   * The keys have to carry the build ID — that is how the runtime cache handler\n   * and the post-deploy pruner namespace one deployment's entries from the next\n   * (`src/adapter/s3-cache-handler.ts`). Asking `BucketDeployment` for it, as\n   * this used to, is what costs: it unconditionally tags the *destination\n   * bucket* with `aws-cdk:cr-owned:<destinationKeyPrefix>:<hash>`, so a prefix\n   * that changes per build makes the bucket's `Tags` change per build.\n   * `AWS::S3::Bucket` `Tags` are not hotswappable, so `cdk deploy\n   * --hotswap-fallback` rejected the diff and fell back to a full CloudFormation\n   * deployment every single time — measured at 19 of 22 deploys in one harness\n   * run, ~110s each against a ~52s hotswap.\n   *\n   * Putting the build ID in the asset's own paths instead leaves the S3 keys\n   * byte-identical and the tag key constant (`aws-cdk:cr-owned:<hash>`, derived\n   * from the construct path). Nothing else read the prefix: `prune` is already\n   * `false`, and the two handler branches that do scope work to it — emptying\n   * the prefix on delete, and deleting the old prefix when the destination\n   * changes — are both gated on `retainOnDelete`, which `BucketDeployment`\n   * defaults to `true`.\n   *\n   * A copy rather than the directory itself because the build ID is only known\n   * *after* `next build`, so the adapter cannot write into a nested directory in\n   * the first place, and because `.next/cdk-nextjs-init-cache` has to stay where\n   * it is for the local cache handler to read it (`CDK_NEXTJS_INIT_CACHE_DIR`).\n   * CDK is about to read every byte of this to zip it regardless.\n   */\n  private createStagingDirectory(): string {\n    const stagingDir = mkdtempSync(join(tmpdir(), \"nextjs-init-cache-\"));\n    cpSync(this.props.initCacheDir, join(stagingDir, this.props.buildId), {\n      recursive: true,\n    });\n    return stagingDir;\n  }\n}\n"]}

package/lib/nextjs-cache.test.js

@@ -1,9 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 /* eslint-disable import/no-extraneous-dependencies */
+const fs_1 = require("fs");
+const os_1 = require("os");
+const path_1 = require("path");
 const aws_cdk_lib_1 = require("aws-cdk-lib");
 const assertions_1 = require("aws-cdk-lib/assertions");
 const aws_dynamodb_1 = require("aws-cdk-lib/aws-dynamodb");
+const aws_s3_1 = require("aws-cdk-lib/aws-s3");
+const aws_s3_deployment_1 = require("aws-cdk-lib/aws-s3-deployment");
 const nextjs_cache_1 = require("./nextjs-cache");
 describe("NextjsCache", () => {
     let app;
@@ -65,6 +70,16 @@ describe("NextjsCache", () => {
                 BillingMode: "PAY_PER_REQUEST",
             });
         });
+        // The 'use cache' revalidation log's rows expire through `ttl`.
+        it("expires revalidation log rows through a TTL attribute", () => {
+            new nextjs_cache_1.NextjsCache(stack, "TestCache", {
+                buildId: "test-build-123",
+                initCacheDir: "/tmp/test-cache",
+            });
+            assertions_1.Template.fromStack(stack).hasResourceProperties("AWS::DynamoDB::GlobalTable", {
+                TimeToLiveSpecification: { AttributeName: "ttl", Enabled: true },
+            });
+        });
         it("should apply custom overrides", () => {
             new nextjs_cache_1.NextjsCache(stack, "TestCache", {
                 buildId: "test-build-123",
@@ -83,6 +98,7 @@ describe("NextjsCache", () => {
                             name: "cacheKey",
                             type: aws_dynamodb_1.AttributeType.STRING,
                         },
+                        timeToLiveAttribute: "expiresAt",
                     },
                 },
             });
@@ -92,8 +108,167 @@ describe("NextjsCache", () => {
             });
             template.hasResourceProperties("AWS::DynamoDB::GlobalTable", {
                 TableName: "custom-revalidation-table",
+                TimeToLiveSpecification: { AttributeName: "expiresAt", Enabled: true },
+            });
+        });
+    });
+    describe("Init cache deployment", () => {
+        let initCacheDir;
+        let outdir;
+        beforeEach(() => {
+            initCacheDir = (0, fs_1.mkdtempSync)((0, path_1.join)((0, os_1.tmpdir)(), "init-cache-src-"));
+            (0, fs_1.mkdirSync)((0, path_1.join)(initCacheDir, "server", "app"), { recursive: true });
+            (0, fs_1.writeFileSync)((0, path_1.join)(initCacheDir, "server", "app", "index.html"), "<p/>");
+            outdir = (0, fs_1.mkdtempSync)((0, path_1.join)((0, os_1.tmpdir)(), "init-cache-out-"));
+        });
+        afterEach(() => {
+            (0, fs_1.rmSync)(initCacheDir, { recursive: true, force: true });
+            (0, fs_1.rmSync)(outdir, { recursive: true, force: true });
+        });
+        /**
+         * The tag `BucketDeployment` stamps on its destination bucket, and the only
+         * one that can vary between two builds. `Tags` on an `AWS::S3::Bucket` are
+         * not hotswappable, so a tag key that carries the build ID costs a full
+         * CloudFormation deployment on every deploy.
+         */
+        function ownerTags(template) {
+            const buckets = template.findResources("AWS::S3::Bucket");
+            return Object.values(buckets)
+                .flatMap((bucket) => bucket.Properties?.Tags ?? [])
+                .map((tag) => tag.Key)
+                .filter((key) => key.startsWith("aws-cdk:cr-owned"));
+        }
+        function synth(buildId) {
+            const ownApp = new aws_cdk_lib_1.App({ outdir: (0, fs_1.mkdtempSync)((0, path_1.join)(outdir, "app-")) });
+            const ownStack = new aws_cdk_lib_1.Stack(ownApp, "TestStack");
+            new nextjs_cache_1.NextjsCache(ownStack, "TestCache", { buildId, initCacheDir });
+            return { app: ownApp, template: assertions_1.Template.fromStack(ownStack) };
+        }
+        it("keys the objects under the build ID without a destinationKeyPrefix", () => {
+            const { app: ownApp, template } = synth("build-abc123");
+            // Not `DestinationBucketKeyPrefix: Match.absent()` on its own: that would
+            // also pass if the staged tree had lost the build ID, which is what keeps
+            // the S3 keys the same as before this moved.
+            const deployments = template.findResources("Custom::CDKBucketDeployment");
+            expect(Object.keys(deployments)).toHaveLength(1);
+            expect(Object.values(deployments)[0].Properties).not.toHaveProperty("DestinationBucketKeyPrefix");
+            const assembly = ownApp.synth();
+            const stagedUnderBuildId = (0, fs_1.readdirSync)(assembly.directory, {
+                withFileTypes: true,
+            }).some((entry) => entry.isDirectory() &&
+                entry.name.startsWith("asset.") &&
+                (0, fs_1.readdirSync)((0, path_1.join)(assembly.directory, entry.name)).includes("build-abc123"));
+            expect(stagedUnderBuildId).toBe(true);
+        });
+        it("removes its temporary staging copy once the asset is staged", () => {
+            // `Source.asset` stages during `BucketDeployment`'s construction, so the
+            // copy is dead as soon as that returns - and it is a whole init cache,
+            // measured at 664 MiB. Leaving one per synth put ~15 GB in the system temp
+            // directory over a CI loop of ~22 deploys.
+            const existing = new Set((0, fs_1.readdirSync)((0, os_1.tmpdir)()).filter((name) => name.startsWith("nextjs-init-cache-")));
+            synth("build-abc123").app.synth();
+            const leaked = (0, fs_1.readdirSync)((0, os_1.tmpdir)()).filter((name) => name.startsWith("nextjs-init-cache-") && !existing.has(name));
+            expect(leaked).toEqual([]);
+        });
+        it("tags the cache bucket the same way whatever the build ID", () => {
+            const first = ownerTags(synth("build-abc123").template);
+            const second = ownerTags(synth("build-def456").template);
+            expect(first).toHaveLength(1);
+            expect(first[0]).toMatch(/^aws-cdk:cr-owned:[0-9a-f]{8}$/);
+            expect(second).toEqual(first);
+        });
+        /**
+         * The unzip Lambda holds the asset zip and its extracted contents in `/tmp`
+         * at once, so a seed directory bigger than the 512 MiB CDK asks for by
+         * default kills it with `[Errno 28] No space left on device` — and under
+         * `cdk deploy --hotswap` that failure is invisible, because the CLI hands the
+         * custom resource a placeholder response URL and never reads its status.
+         */
+        function deploymentLambda(template) {
+            const functions = template.findResources("AWS::Lambda::Function", {
+                Properties: {
+                    Handler: "index.handler",
+                    Runtime: assertions_1.Match.stringLikeRegexp("^python"),
+                },
+            });
+            expect(Object.keys(functions)).toHaveLength(1);
+            return Object.values(functions)[0].Properties;
+        }
+        it("leaves a small init cache on the default Lambda sizing", () => {
+            const properties = deploymentLambda(synth("build-abc123").template);
+            // The floor, not a computed value: a handful of bytes still wants 512 MiB
+            // because that is the least Lambda will give.
+            expect(properties.EphemeralStorage).toEqual({ Size: 512 });
+            // Absent, not 128: leaving `memoryLimit` alone keeps the property out of
+            // the template, which is Lambda's own 128 MB default.
+            expect(properties.MemorySize).toBeUndefined();
+        });
+        it("scales /tmp and memory to a large init cache", () => {
+            // A sparse file: `statSync` reports 300 MiB, the filesystem stores almost
+            // nothing, and the zip of a 300 MiB hole costs no real work.
+            const big = (0, path_1.join)(initCacheDir, "server", "app", "big.rsc");
+            (0, fs_1.writeFileSync)(big, "");
+            (0, fs_1.truncateSync)(big, 300 * 1024 * 1024);
+            const properties = deploymentLambda(synth("build-abc123").template);
+            // 301 MiB of cache — the 300 MiB hole plus the fixture's own file, rounded
+            // up — doubled for the zip that sits beside it, plus headroom: 730 MiB,
+            // rounded up to the next step.
+            expect(properties.EphemeralStorage).toEqual({ Size: 1024 });
+            expect(properties.MemorySize).toBe(1024);
+        });
+        it("keeps the deployment's identity while the cache grows by a little", () => {
+            // `ephemeralStorageSize` is part of the singleton handler's UUID and the
+            // custom resource's logical ID. Sized to the MiB, a cache 5 MiB bigger
+            // than the last deploy's was a new handler Lambda, a new ServiceToken
+            // and a replaced custom resource - a full deployment, not a hotswap.
+            const big = (0, path_1.join)(initCacheDir, "server", "app", "big.rsc");
+            const logicalIds = (mib) => {
+                (0, fs_1.writeFileSync)(big, "");
+                (0, fs_1.truncateSync)(big, mib * 1024 * 1024);
+                const template = synth("build-abc123").template;
+                return [
+                    ...Object.keys(template.findResources("Custom::CDKBucketDeployment")),
+                    ...Object.keys(template.findResources("AWS::Lambda::Function")),
+                ].sort();
+            };
+            expect(logicalIds(305)).toEqual(logicalIds(300));
+        });
+        it("keeps the staging copy when asset staging is disabled", () => {
+            // `--no-staging` (and SAM) leaves the asset where it is rather than
+            // copying it into `cdk.out`, so the staging copy *is* the asset, and the
+            // publish after synth needs it.
+            const ownApp = new aws_cdk_lib_1.App({
+                outdir: (0, fs_1.mkdtempSync)((0, path_1.join)(outdir, "app-")),
+                context: { "aws:cdk:disable-asset-staging": true },
+            });
+            const existing = new Set((0, fs_1.readdirSync)((0, os_1.tmpdir)()).filter((name) => name.startsWith("nextjs-init-cache-")));
+            new nextjs_cache_1.NextjsCache(new aws_cdk_lib_1.Stack(ownApp, "TestStack"), "TestCache", {
+                buildId: "build-abc123",
+                initCacheDir,
+            });
+            const kept = (0, fs_1.readdirSync)((0, os_1.tmpdir)()).filter((name) => name.startsWith("nextjs-init-cache-") && !existing.has(name));
+            expect(kept).toHaveLength(1);
+            (0, fs_1.rmSync)((0, path_1.join)((0, os_1.tmpdir)(), kept[0]), { recursive: true, force: true });
+        });
+        it("lets overrides win over the computed sizing", () => {
+            const ownApp = new aws_cdk_lib_1.App({ outdir: (0, fs_1.mkdtempSync)((0, path_1.join)(outdir, "app-")) });
+            const ownStack = new aws_cdk_lib_1.Stack(ownApp, "TestStack");
+            new nextjs_cache_1.NextjsCache(ownStack, "TestCache", {
+                buildId: "build-abc123",
+                initCacheDir,
+                overrides: {
+                    bucketDeploymentProps: {
+                        destinationBucket: aws_s3_1.Bucket.fromBucketName(ownStack, "Existing", "someone-elses-bucket"),
+                        sources: [aws_s3_deployment_1.Source.data("marker", "x")],
+                        ephemeralStorageSize: aws_cdk_lib_1.Size.gibibytes(2),
+                        memoryLimit: 2048,
+                    },
+                },
             });
+            const properties = deploymentLambda(assertions_1.Template.fromStack(ownStack));
+            expect(properties.EphemeralStorage).toEqual({ Size: 2048 });
+            expect(properties.MemorySize).toBe(2048);
         });
     });
 });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"nextjs-cache.test.js","sourceRoot":"","sources":["../src/nextjs-cache.test.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable import/no-extraneous-dependencies */\nimport {\n  mkdirSync,\n  mkdtempSync,\n  readdirSync,\n  rmSync,\n  truncateSync,\n  writeFileSync,\n} from \"fs\";\nimport { tmpdir } from \"os\";\nimport { join } from \"path\";\nimport { App, Size, Stack } from \"aws-cdk-lib\";\nimport { Match, Template } from \"aws-cdk-lib/assertions\";\nimport { AttributeType } from \"aws-cdk-lib/aws-dynamodb\";\nimport { Bucket } from \"aws-cdk-lib/aws-s3\";\nimport { Source } from \"aws-cdk-lib/aws-s3-deployment\";\nimport { NextjsCache } from \"./nextjs-cache\";\n\ndescribe(\"NextjsCache\", () => {\n  let app: App;\n  let stack: Stack;\n\n  beforeEach(() => {\n    app = new App();\n    stack = new Stack(app, \"TestStack\");\n  });\n\n  describe(\"Basic Construction\", () => {\n    it(\"should create S3 bucket and DynamoDB table\", () => {\n      const cache = new NextjsCache(stack, \"TestCache\", {\n        buildId: \"test-build-123\",\n        initCacheDir: \"/tmp/test-cache\",\n      });\n\n      expect(cache.cacheBucket).toBeDefined();\n      expect(cache.revalidationTable).toBeDefined();\n      expect(cache.buildId).toBe(\"test-build-123\");\n\n      const template = Template.fromStack(stack);\n\n      // Verify S3 bucket is created\n      template.hasResourceProperties(\"AWS::S3::Bucket\", {\n        BucketEncryption: {\n          ServerSideEncryptionConfiguration: [\n            {\n              ServerSideEncryptionByDefault: {\n                SSEAlgorithm: \"AES256\",\n              },\n            },\n          ],\n        },\n        PublicAccessBlockConfiguration: {\n          BlockPublicAcls: true,\n          BlockPublicPolicy: true,\n          IgnorePublicAcls: true,\n          RestrictPublicBuckets: true,\n        },\n      });\n\n      // Verify DynamoDB table is created (TableV2 creates GlobalTable resource)\n      template.hasResourceProperties(\"AWS::DynamoDB::GlobalTable\", {\n        KeySchema: [\n          {\n            AttributeName: \"pk\",\n            KeyType: \"HASH\",\n          },\n          {\n            AttributeName: \"sk\",\n            KeyType: \"RANGE\",\n          },\n        ],\n        AttributeDefinitions: [\n          {\n            AttributeName: \"pk\",\n            AttributeType: \"S\",\n          },\n          {\n            AttributeName: \"sk\",\n            AttributeType: \"S\",\n          },\n        ],\n        BillingMode: \"PAY_PER_REQUEST\",\n      });\n    });\n\n    // The 'use cache' revalidation log's rows expire through `ttl`.\n    it(\"expires revalidation log rows through a TTL attribute\", () => {\n      new NextjsCache(stack, \"TestCache\", {\n        buildId: \"test-build-123\",\n        initCacheDir: \"/tmp/test-cache\",\n      });\n      Template.fromStack(stack).hasResourceProperties(\n        \"AWS::DynamoDB::GlobalTable\",\n        {\n          TimeToLiveSpecification: { AttributeName: \"ttl\", Enabled: true },\n        },\n      );\n    });\n\n    it(\"should apply custom overrides\", () => {\n      new NextjsCache(stack, \"TestCache\", {\n        buildId: \"test-build-123\",\n        initCacheDir: \"/tmp/test-cache\",\n        overrides: {\n          cacheBucketProps: {\n            bucketName: \"custom-cache-bucket\",\n          },\n          revalidationTableProps: {\n            tableName: \"custom-revalidation-table\",\n            partitionKey: {\n              name: \"tag\",\n              type: AttributeType.STRING,\n            },\n            sortKey: {\n              name: \"cacheKey\",\n              type: AttributeType.STRING,\n            },\n            timeToLiveAttribute: \"expiresAt\",\n          },\n        },\n      });\n\n      const template = Template.fromStack(stack);\n\n      template.hasResourceProperties(\"AWS::S3::Bucket\", {\n        BucketName: \"custom-cache-bucket\",\n      });\n\n      template.hasResourceProperties(\"AWS::DynamoDB::GlobalTable\", {\n        TableName: \"custom-revalidation-table\",\n        TimeToLiveSpecification: { AttributeName: \"expiresAt\", Enabled: true },\n      });\n    });\n  });\n\n  describe(\"Init cache deployment\", () => {\n    let initCacheDir: string;\n    let outdir: string;\n\n    beforeEach(() => {\n      initCacheDir = mkdtempSync(join(tmpdir(), \"init-cache-src-\"));\n      mkdirSync(join(initCacheDir, \"server\", \"app\"), { recursive: true });\n      writeFileSync(join(initCacheDir, \"server\", \"app\", \"index.html\"), \"<p/>\");\n      outdir = mkdtempSync(join(tmpdir(), \"init-cache-out-\"));\n    });\n\n    afterEach(() => {\n      rmSync(initCacheDir, { recursive: true, force: true });\n      rmSync(outdir, { recursive: true, force: true });\n    });\n\n    /**\n     * The tag `BucketDeployment` stamps on its destination bucket, and the only\n     * one that can vary between two builds. `Tags` on an `AWS::S3::Bucket` are\n     * not hotswappable, so a tag key that carries the build ID costs a full\n     * CloudFormation deployment on every deploy.\n     */\n    function ownerTags(template: Template): string[] {\n      const buckets = template.findResources(\"AWS::S3::Bucket\");\n      return Object.values(buckets)\n        .flatMap((bucket) => bucket.Properties?.Tags ?? [])\n        .map((tag: { Key: string }) => tag.Key)\n        .filter((key) => key.startsWith(\"aws-cdk:cr-owned\"));\n    }\n\n    function synth(buildId: string) {\n      const ownApp = new App({ outdir: mkdtempSync(join(outdir, \"app-\")) });\n      const ownStack = new Stack(ownApp, \"TestStack\");\n      new NextjsCache(ownStack, \"TestCache\", { buildId, initCacheDir });\n      return { app: ownApp, template: Template.fromStack(ownStack) };\n    }\n\n    it(\"keys the objects under the build ID without a destinationKeyPrefix\", () => {\n      const { app: ownApp, template } = synth(\"build-abc123\");\n\n      // Not `DestinationBucketKeyPrefix: Match.absent()` on its own: that would\n      // also pass if the staged tree had lost the build ID, which is what keeps\n      // the S3 keys the same as before this moved.\n      const deployments = template.findResources(\"Custom::CDKBucketDeployment\");\n      expect(Object.keys(deployments)).toHaveLength(1);\n      expect(Object.values(deployments)[0].Properties).not.toHaveProperty(\n        \"DestinationBucketKeyPrefix\",\n      );\n\n      const assembly = ownApp.synth();\n      const stagedUnderBuildId = readdirSync(assembly.directory, {\n        withFileTypes: true,\n      }).some(\n        (entry) =>\n          entry.isDirectory() &&\n          entry.name.startsWith(\"asset.\") &&\n          readdirSync(join(assembly.directory, entry.name)).includes(\n            \"build-abc123\",\n          ),\n      );\n      expect(stagedUnderBuildId).toBe(true);\n    });\n\n    it(\"removes its temporary staging copy once the asset is staged\", () => {\n      // `Source.asset` stages during `BucketDeployment`'s construction, so the\n      // copy is dead as soon as that returns - and it is a whole init cache,\n      // measured at 664 MiB. Leaving one per synth put ~15 GB in the system temp\n      // directory over a CI loop of ~22 deploys.\n      const existing = new Set(\n        readdirSync(tmpdir()).filter((name) =>\n          name.startsWith(\"nextjs-init-cache-\"),\n        ),\n      );\n\n      synth(\"build-abc123\").app.synth();\n\n      const leaked = readdirSync(tmpdir()).filter(\n        (name) => name.startsWith(\"nextjs-init-cache-\") && !existing.has(name),\n      );\n      expect(leaked).toEqual([]);\n    });\n\n    it(\"tags the cache bucket the same way whatever the build ID\", () => {\n      const first = ownerTags(synth(\"build-abc123\").template);\n      const second = ownerTags(synth(\"build-def456\").template);\n\n      expect(first).toHaveLength(1);\n      expect(first[0]).toMatch(/^aws-cdk:cr-owned:[0-9a-f]{8}$/);\n      expect(second).toEqual(first);\n    });\n\n    /**\n     * The unzip Lambda holds the asset zip and its extracted contents in `/tmp`\n     * at once, so a seed directory bigger than the 512 MiB CDK asks for by\n     * default kills it with `[Errno 28] No space left on device` — and under\n     * `cdk deploy --hotswap` that failure is invisible, because the CLI hands the\n     * custom resource a placeholder response URL and never reads its status.\n     */\n    function deploymentLambda(template: Template) {\n      const functions = template.findResources(\"AWS::Lambda::Function\", {\n        Properties: {\n          Handler: \"index.handler\",\n          Runtime: Match.stringLikeRegexp(\"^python\"),\n        },\n      });\n      expect(Object.keys(functions)).toHaveLength(1);\n      return Object.values(functions)[0].Properties;\n    }\n\n    it(\"leaves a small init cache on the default Lambda sizing\", () => {\n      const properties = deploymentLambda(synth(\"build-abc123\").template);\n\n      // The floor, not a computed value: a handful of bytes still wants 512 MiB\n      // because that is the least Lambda will give.\n      expect(properties.EphemeralStorage).toEqual({ Size: 512 });\n      // Absent, not 128: leaving `memoryLimit` alone keeps the property out of\n      // the template, which is Lambda's own 128 MB default.\n      expect(properties.MemorySize).toBeUndefined();\n    });\n\n    it(\"scales /tmp and memory to a large init cache\", () => {\n      // A sparse file: `statSync` reports 300 MiB, the filesystem stores almost\n      // nothing, and the zip of a 300 MiB hole costs no real work.\n      const big = join(initCacheDir, \"server\", \"app\", \"big.rsc\");\n      writeFileSync(big, \"\");\n      truncateSync(big, 300 * 1024 * 1024);\n\n      const properties = deploymentLambda(synth(\"build-abc123\").template);\n\n      // 301 MiB of cache — the 300 MiB hole plus the fixture's own file, rounded\n      // up — doubled for the zip that sits beside it, plus headroom: 730 MiB,\n      // rounded up to the next step.\n      expect(properties.EphemeralStorage).toEqual({ Size: 1024 });\n      expect(properties.MemorySize).toBe(1024);\n    });\n\n    it(\"keeps the deployment's identity while the cache grows by a little\", () => {\n      // `ephemeralStorageSize` is part of the singleton handler's UUID and the\n      // custom resource's logical ID. Sized to the MiB, a cache 5 MiB bigger\n      // than the last deploy's was a new handler Lambda, a new ServiceToken\n      // and a replaced custom resource - a full deployment, not a hotswap.\n      const big = join(initCacheDir, \"server\", \"app\", \"big.rsc\");\n      const logicalIds = (mib: number) => {\n        writeFileSync(big, \"\");\n        truncateSync(big, mib * 1024 * 1024);\n        const template = synth(\"build-abc123\").template;\n        return [\n          ...Object.keys(template.findResources(\"Custom::CDKBucketDeployment\")),\n          ...Object.keys(template.findResources(\"AWS::Lambda::Function\")),\n        ].sort();\n      };\n\n      expect(logicalIds(305)).toEqual(logicalIds(300));\n    });\n\n    it(\"keeps the staging copy when asset staging is disabled\", () => {\n      // `--no-staging` (and SAM) leaves the asset where it is rather than\n      // copying it into `cdk.out`, so the staging copy *is* the asset, and the\n      // publish after synth needs it.\n      const ownApp = new App({\n        outdir: mkdtempSync(join(outdir, \"app-\")),\n        context: { \"aws:cdk:disable-asset-staging\": true },\n      });\n      const existing = new Set(\n        readdirSync(tmpdir()).filter((name) =>\n          name.startsWith(\"nextjs-init-cache-\"),\n        ),\n      );\n\n      new NextjsCache(new Stack(ownApp, \"TestStack\"), \"TestCache\", {\n        buildId: \"build-abc123\",\n        initCacheDir,\n      });\n\n      const kept = readdirSync(tmpdir()).filter(\n        (name) => name.startsWith(\"nextjs-init-cache-\") && !existing.has(name),\n      );\n      expect(kept).toHaveLength(1);\n      rmSync(join(tmpdir(), kept[0]), { recursive: true, force: true });\n    });\n\n    it(\"lets overrides win over the computed sizing\", () => {\n      const ownApp = new App({ outdir: mkdtempSync(join(outdir, \"app-\")) });\n      const ownStack = new Stack(ownApp, \"TestStack\");\n      new NextjsCache(ownStack, \"TestCache\", {\n        buildId: \"build-abc123\",\n        initCacheDir,\n        overrides: {\n          bucketDeploymentProps: {\n            destinationBucket: Bucket.fromBucketName(\n              ownStack,\n              \"Existing\",\n              \"someone-elses-bucket\",\n            ),\n            sources: [Source.data(\"marker\", \"x\")],\n            ephemeralStorageSize: Size.gibibytes(2),\n            memoryLimit: 2048,\n          },\n        },\n      });\n\n      const properties = deploymentLambda(Template.fromStack(ownStack));\n      expect(properties.EphemeralStorage).toEqual({ Size: 2048 });\n      expect(properties.MemorySize).toBe(2048);\n    });\n  });\n});\n"]}