cdk-nextjs 0.7.11 → 0.7.12

package/lib/nextjs-static-assets.d.ts

@@ -10,6 +10,19 @@ import { Construct } from "constructs";
 export declare function staticAssetsObjectsPattern(keyPrefix?: string): string;
 export interface NextjsStaticAssetsOverrides {
     readonly bucketProps?: BucketProps;
+    /**
+     * Applied to every upload (`public/`, `_next/static/` and
+     * `_next/static/service-worker/`), except that the two `_next/static` uploads
+     * always keep the `Cache-Control` Next.js sends for them. So a `cacheControl`
+     * here sets the header for `public/` files only, while anything else, such as
+     * a `distribution` to invalidate, applies to each upload in turn.
+     *
+     * `sources` and `destinationBucket`, which the type requires, are ignored:
+     * the uploads are always the build's assets, to the bucket CloudFront and
+     * API Gateway read from (pass `bucket` to bring your own). `prune: true` and
+     * `retainOnDelete: false` are rejected, since each would break the other
+     * uploads.
+     */
     readonly bucketDeploymentProps?: BucketDeploymentProps;
 }
 export interface NextjsStaticAssetsProps {
@@ -43,7 +56,35 @@ export interface NextjsStaticAssetsProps {
  */
 export declare class NextjsStaticAssets extends Construct {
     bucket: IBucket;
+    /**
+     * The first of `staticDeployment`, `serviceWorkerDeployment` and
+     * `publicDeployment` the build has files for.
+     *
+     * @deprecated The assets are uploaded by up to three deployments, and this
+     * is only one of them: a dependency on it doesn't wait for the others. Use
+     * `staticDeployment`, `serviceWorkerDeployment` and `publicDeployment`.
+     */
     deployment: BucketDeployment;
+    /**
+     * Uploads `.next/static` to `_next/static/` with
+     * `Cache-Control: public, max-age=31536000, immutable`, except for
+     * `service-worker/` (see `serviceWorkerDeployment`). Absent if the build has
+     * no `.next/static`.
+     */
+    readonly staticDeployment?: BucketDeployment;
+    /**
+     * Uploads `.next/static/service-worker` with
+     * `Cache-Control: public, max-age=0, must-revalidate`, as Next.js serves it:
+     * a service worker keeps its URL across builds, so it can't be `immutable`.
+     * Absent if the build has no service worker.
+     */
+    readonly serviceWorkerDeployment?: BucketDeployment;
+    /**
+     * Uploads `public/`, separately from `staticDeployment` because its files
+     * keep their names when they change and so can't be `immutable`. Absent if
+     * the build has no `public` directory.
+     */
+    readonly publicDeployment?: BucketDeployment;
     /**
      * S3 key prefix the assets are actually uploaded under, normalized to a bare
      * path segment (empty when they live at the bucket root).
@@ -57,9 +98,34 @@ export declare class NextjsStaticAssets extends Construct {
      * bytes were uploaded.
      */
     readonly keyPrefix: string;
-    private stagingDir?;
     private props;
     constructor(scope: Construct, id: string, props: NextjsStaticAssetsProps);
+    /**
+     * Stages each tree and creates its deployment, adding every staging
+     * directory to `staged` as it's made, so the caller can remove them even if
+     * a later step throws.
+     */
+    private createDeployments;
+    /**
+     * Rejects the `bucketDeploymentProps` that can't work across several
+     * deployments sharing one prefix. Each is spread into every one of them:
+     *
+     * - `prune: true` makes each deployment's `s3 sync --delete` remove the files
+     *   the others uploaded.
+     * - `retainOnDelete: false` makes a deployment `s3 rm --recursive` its old
+     *   prefix when the prefix changes, without checking whether the bucket is
+     *   CDK's (only Delete checks), so it can delete files another deployment has
+     *   just uploaded there. On Delete, CDK skips that `rm` only for a bucket it
+     *   tagged, and it can't tag an imported one, so a build that stops having
+     *   files for one deployment would lose the others' files too.
+     *
+     * `sources` and `destinationBucket` aren't rejected, because the type
+     * requires them; `newDeployment` sets them after the spread instead.
+     *
+     * Compared against the exact value, as with `destinationKeyPrefix`, so an
+     * explicit `undefined` from a JSII binding is not mistaken for an override.
+     */
+    private validateDeploymentOverrides;
     /**
      * Resolves the single prefix both the upload and the URLs use. A
      * `bucketDeploymentProps.destinationKeyPrefix` override wins over `basePath`,
@@ -77,11 +143,14 @@ export declare class NextjsStaticAssets extends Construct {
     private createBucket;
     private createDeployment;
     /**
-     * Create a staging directory with the correct structure:
-     * - public/ files go to root
-     * - .next/static/ files go to _next/static/
+     * Copies `sourceDir` to `<staging>/<subPath>` in a new staging directory, or
+     * returns `undefined` if there is no `sourceDir` or no file in it passes
+     * `include`. Staged under `subPath` rather than uploaded with a longer
+     * `destinationKeyPrefix`, so every deployment shares the one prefix
+     * `keyPrefix` resolves. `include` gets each entry's path relative to
+     * `sourceDir`.
      */
-    private createStagingDirectory;
+    private stageDirectory;
     /**
      * Check if a directory exists
      */

package/lib/nextjs-static-assets.js

@@ -1,4 +1,37 @@
 "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.NextjsStaticAssets = void 0;
 exports.staticAssetsObjectsPattern = staticAssetsObjectsPattern;
@@ -9,6 +42,7 @@ const node_path_1 = require("node:path");
 const aws_cdk_lib_1 = require("aws-cdk-lib");
 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");
 const base_path_1 = require("./utils/base-path");
@@ -25,13 +59,90 @@ function staticAssetsObjectsPattern(keyPrefix) {
     const prefix = (0, base_path_1.normalizeBasePath)(keyPrefix);
     return prefix ? `${prefix}/*` : "*";
 }
+/** Where `.next/static` is served from, relative to `keyPrefix`. */
+const STATIC_PATH = (0, node_path_1.join)("_next", "static");
+/** Where Next.js compiles service workers to, relative to `.next/static`. */
+const SERVICE_WORKER_DIR = "service-worker";
+/**
+ * Every file under `dir`, relative to it, through symlinks too: CDK uploads a
+ * linked file or directory as what it points to, under every name it's reached
+ * by.
+ *
+ * An explicit walk rather than `readdirSync({ recursive: true })`, which never
+ * returns on a symlink cycle (Node 24 follows directory links), and whose
+ * `Dirent.parentPath` doesn't exist before Node 20.12. A link back to a
+ * directory already on the current path is a cycle and isn't followed; one that
+ * can't be stat'd (dangling, or a loop of links) counts as a file.
+ */
+function listFiles(dir) {
+    const files = [];
+    const walk = (sub, ancestors) => {
+        const real = (0, node_fs_1.realpathSync)((0, node_path_1.join)(dir, sub));
+        if (ancestors.has(real)) {
+            return;
+        }
+        const path = new Set(ancestors).add(real);
+        for (const entry of (0, node_fs_1.readdirSync)(real, { withFileTypes: true })) {
+            const child = (0, node_path_1.join)(sub, entry.name);
+            if (entry.isDirectory() ||
+                (entry.isSymbolicLink() && isDirectoryLink((0, node_path_1.join)(real, entry.name)))) {
+                walk(child, path);
+            }
+            else {
+                files.push(child);
+            }
+        }
+    };
+    walk("", new Set());
+    return files;
+}
+function isDirectoryLink(path) {
+    try {
+        return (0, node_fs_1.statSync)(path).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+/** Whether the relative `path` is `dir` or inside it. */
+function isWithin(path, dir) {
+    return path === dir || path.startsWith(dir + node_path_1.sep);
+}
 /**
  * Creates S3 Bucket for public and _next/static assets and deploys them using S3Deployment.
  */
 class NextjsStaticAssets extends constructs_1.Construct {
-    static [JSII_RTTI_SYMBOL_1] = { fqn: "cdk-nextjs.NextjsStaticAssets", version: "0.7.11" };
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "cdk-nextjs.NextjsStaticAssets", version: "0.7.12" };
     bucket;
+    /**
+     * The first of `staticDeployment`, `serviceWorkerDeployment` and
+     * `publicDeployment` the build has files for.
+     *
+     * @deprecated The assets are uploaded by up to three deployments, and this
+     * is only one of them: a dependency on it doesn't wait for the others. Use
+     * `staticDeployment`, `serviceWorkerDeployment` and `publicDeployment`.
+     */
     deployment;
+    /**
+     * Uploads `.next/static` to `_next/static/` with
+     * `Cache-Control: public, max-age=31536000, immutable`, except for
+     * `service-worker/` (see `serviceWorkerDeployment`). Absent if the build has
+     * no `.next/static`.
+     */
+    staticDeployment;
+    /**
+     * Uploads `.next/static/service-worker` with
+     * `Cache-Control: public, max-age=0, must-revalidate`, as Next.js serves it:
+     * a service worker keeps its URL across builds, so it can't be `immutable`.
+     * Absent if the build has no service worker.
+     */
+    serviceWorkerDeployment;
+    /**
+     * Uploads `public/`, separately from `staticDeployment` because its files
+     * keep their names when they change and so can't be `immutable`. Absent if
+     * the build has no `public` directory.
+     */
+    publicDeployment;
     /**
      * S3 key prefix the assets are actually uploaded under, normalized to a bare
      * path segment (empty when they live at the bucket root).
@@ -45,14 +156,132 @@ class NextjsStaticAssets extends constructs_1.Construct {
      * bytes were uploaded.
      */
     keyPrefix;
-    stagingDir;
     props;
     constructor(scope, id, props) {
         super(scope, id);
         this.props = props;
+        this.validateDeploymentOverrides();
         this.keyPrefix = this.resolveKeyPrefix();
         this.bucket = props.bucket ?? this.createBucket();
-        this.deployment = this.createDeployment();
+        const staged = [];
+        try {
+            const uploads = this.createDeployments(staged);
+            this.staticDeployment = uploads.staticDeployment;
+            this.serviceWorkerDeployment = uploads.serviceWorkerDeployment;
+            this.publicDeployment = uploads.publicDeployment;
+        }
+        finally {
+            // `Source.asset` stages during `BucketDeployment`'s construction (CDK's
+            // `AssetStaging` copies into `cdk.out` from its own constructor), so the
+            // temporary copies are dead once the deployments exist, or once one of
+            // them failed. Left behind, every synth would add another full copy of
+            // the app's static assets to the temp directory.
+            //
+            // Unless staging is disabled (`cdk synth --no-staging`, and SAM, which
+            // sets the same context): then the asset manifest points at these
+            // directories themselves, and removing them would fail the publish that
+            // follows.
+            if (!this.node.tryGetContext(cxapi.DISABLE_ASSET_STAGING_CONTEXT)) {
+                for (const dir of staged) {
+                    (0, node_fs_1.rmSync)(dir, { recursive: true, force: true });
+                }
+            }
+        }
+        this.deployment = (this.staticDeployment ??
+            this.serviceWorkerDeployment ??
+            this.publicDeployment);
+    }
+    /**
+     * Stages each tree and creates its deployment, adding every staging
+     * directory to `staged` as it's made, so the caller can remove them even if
+     * a later step throws.
+     */
+    createDeployments(staged) {
+        const stage = (...args) => {
+            const dir = this.stageDirectory(...args);
+            if (dir) {
+                staged.push(dir);
+            }
+            return dir;
+        };
+        const builtDir = (0, node_path_1.join)(this.props.buildDirectory, ".next", "static");
+        const publicSourceDir = (0, node_path_1.join)(this.props.buildDirectory, "public");
+        // Only a directory is uploaded as service workers, so only a directory is
+        // left out here.
+        const hasServiceWorkers = this.directoryExists((0, node_path_1.join)(builtDir, SERVICE_WORKER_DIR));
+        const staticDir = stage(builtDir, STATIC_PATH, (path) => !hasServiceWorkers || !isWithin(path, SERVICE_WORKER_DIR));
+        const serviceWorkerDir = stage((0, node_path_1.join)(builtDir, SERVICE_WORKER_DIR), (0, node_path_1.join)(STATIC_PATH, SERVICE_WORKER_DIR));
+        // A `public/_next/static` file with a built file's name would land on the
+        // same key. `next start` serves the built one, so the public copy is left
+        // out; uploading both would leave whichever deployment finished last.
+        // Other `public/_next/static` files are served as `next start` does.
+        // Matched against a listing rather than with `existsSync`, which on macOS
+        // and Windows would let `Legacy.js` shadow `legacy.js`: Next.js and S3 keys
+        // are case-sensitive.
+        const builtFiles = new Set(this.directoryExists(builtDir) ? listFiles(builtDir) : []);
+        const publicDir = stage(publicSourceDir, "", (path) => !isWithin(path, STATIC_PATH) ||
+            !builtFiles.has((0, node_path_1.relative)(STATIC_PATH, path)));
+        if (!staticDir && !serviceWorkerDir && !publicDir) {
+            throw new Error(`No static assets found to deploy. Ensure your Next.js build output contains files in either:
+        - A 'public' directory at: ${publicSourceDir}
+        - A '.next/static' directory at: ${builtDir}`);
+        }
+        // `_next/static/` files are content-hashed, so they get the same header
+        // Next.js sends for them. Nothing else would: CloudFront and API Gateway
+        // serve them straight from S3, where the object's metadata is the only
+        // `Cache-Control` there is. A `BucketDeployment`'s `cacheControl` applies to
+        // every object it uploads, hence one deployment per header.
+        return {
+            staticDeployment: staticDir
+                ? this.createDeployment("Deployment", staticDir, [
+                    aws_s3_deployment_1.CacheControl.setPublic(),
+                    aws_s3_deployment_1.CacheControl.maxAge(aws_cdk_lib_1.Duration.days(365)),
+                    aws_s3_deployment_1.CacheControl.immutable(),
+                ])
+                : undefined,
+            serviceWorkerDeployment: serviceWorkerDir
+                ? this.createDeployment("ServiceWorkerDeployment", serviceWorkerDir, [
+                    aws_s3_deployment_1.CacheControl.setPublic(),
+                    aws_s3_deployment_1.CacheControl.maxAge(aws_cdk_lib_1.Duration.seconds(0)),
+                    aws_s3_deployment_1.CacheControl.mustRevalidate(),
+                ])
+                : undefined,
+            publicDeployment: publicDir
+                ? this.createDeployment("PublicDeployment", publicDir)
+                : undefined,
+        };
+    }
+    /**
+     * Rejects the `bucketDeploymentProps` that can't work across several
+     * deployments sharing one prefix. Each is spread into every one of them:
+     *
+     * - `prune: true` makes each deployment's `s3 sync --delete` remove the files
+     *   the others uploaded.
+     * - `retainOnDelete: false` makes a deployment `s3 rm --recursive` its old
+     *   prefix when the prefix changes, without checking whether the bucket is
+     *   CDK's (only Delete checks), so it can delete files another deployment has
+     *   just uploaded there. On Delete, CDK skips that `rm` only for a bucket it
+     *   tagged, and it can't tag an imported one, so a build that stops having
+     *   files for one deployment would lose the others' files too.
+     *
+     * `sources` and `destinationBucket` aren't rejected, because the type
+     * requires them; `newDeployment` sets them after the spread instead.
+     *
+     * Compared against the exact value, as with `destinationKeyPrefix`, so an
+     * explicit `undefined` from a JSII binding is not mistaken for an override.
+     */
+    validateDeploymentOverrides() {
+        const overrides = this.props.overrides?.bucketDeploymentProps;
+        const rejected = [
+            overrides?.prune === true &&
+                "`prune: true` (old assets are pruned after deploy by NextjsPostDeploy, once they are past its TTL)",
+            overrides?.retainOnDelete === false && "`retainOnDelete: false`",
+        ].filter((reason) => !!reason);
+        if (rejected.length > 0) {
+            throw new Error(`${constants_1.LOG_PREFIX} overrides.bucketDeploymentProps can't set ${rejected.join(", or ")}: ` +
+                "the static assets are uploaded by one deployment per Cache-Control, " +
+                "and each of these would break the others.");
+        }
     }
     /**
      * Resolves the single prefix both the upload and the URLs use. A
@@ -85,24 +314,24 @@ class NextjsStaticAssets extends constructs_1.Construct {
             ...this.props.overrides?.bucketProps,
         });
     }
-    createDeployment() {
-        // Create a staging directory with the correct structure
-        this.stagingDir = this.createStagingDirectory();
-        if (!this.stagingDir) {
-            throw new Error(`No static assets found to deploy. Ensure your Next.js build output contains either:
-        - A 'public' directory at: ${(0, node_path_1.join)(this.props.buildDirectory, "public")}
-        - A '.next/static' directory at: ${(0, node_path_1.join)(this.props.buildDirectory, ".next", "static")}`);
-        }
-        return new aws_s3_deployment_1.BucketDeployment(this, "Deployment", {
-            sources: [aws_s3_deployment_1.Source.asset(this.stagingDir)],
-            destinationBucket: this.bucket,
+    createDeployment(id, stagingDir, cacheControl) {
+        return new aws_s3_deployment_1.BucketDeployment(this, id, {
             // Add BUILD_ID as metadata to all objects for version tracking
             metadata: {
                 BUILD_ID: this.props.buildId,
             },
-            prune: false, // Don't delete existing assets to prevent 404s during deployment, pruning will be handled by post-deploy
             // S3Deployment automatically detects content types based on file extensions
             ...this.props.overrides?.bucketDeploymentProps,
+            // Set after the spread. The type makes callers pass `sources` and
+            // `destinationBucket`, and either would upload something other than the
+            // build's assets, or somewhere CloudFront and API Gateway don't read from.
+            // `validateDeploymentOverrides` lets `prune` through only as `false` or an
+            // explicit `undefined` from a JSII binding, which would turn on CDK's
+            // default `prune: true`.
+            sources: [aws_s3_deployment_1.Source.asset(stagingDir)],
+            destinationBucket: this.bucket,
+            prune: false, // Don't delete existing assets to prevent 404s during deployment, pruning will be handled by post-deploy
+            ...(cacheControl && { cacheControl }),
             // Set after the spread: `resolveKeyPrefix` already folded in any
             // `destinationKeyPrefix` override, so this is the normalized form of it.
             // Letting the raw override through here would upload the assets somewhere
@@ -111,43 +340,49 @@ class NextjsStaticAssets extends constructs_1.Construct {
         });
     }
     /**
-     * Create a staging directory with the correct structure:
-     * - public/ files go to root
-     * - .next/static/ files go to _next/static/
+     * Copies `sourceDir` to `<staging>/<subPath>` in a new staging directory, or
+     * returns `undefined` if there is no `sourceDir` or no file in it passes
+     * `include`. Staged under `subPath` rather than uploaded with a longer
+     * `destinationKeyPrefix`, so every deployment shares the one prefix
+     * `keyPrefix` resolves. `include` gets each entry's path relative to
+     * `sourceDir`.
      */
-    createStagingDirectory() {
+    stageDirectory(sourceDir, subPath, include = () => true) {
+        if (!this.directoryExists(sourceDir)) {
+            return undefined;
+        }
+        // From the real path, and dereferencing links inside it: `cpSync` would
+        // copy a link as a link, which fails for a symlinked `sourceDir` (onto the
+        // directory made for it here) and hides a linked directory's files from
+        // `include`, though CDK uploads them.
+        const realSourceDir = (0, node_fs_1.realpathSync)(sourceDir);
         const stagingDir = (0, node_fs_1.mkdtempSync)((0, node_path_1.join)((0, node_os_1.tmpdir)(), "nextjs-assets-"));
-        let hasAssets = false;
         try {
-            // Copy public directory contents to staging root
-            const publicPath = (0, node_path_1.join)(this.props.buildDirectory, "public");
-            if (this.directoryExists(publicPath)) {
-                (0, node_fs_1.cpSync)(publicPath, stagingDir, { recursive: true });
-                hasAssets = true;
-            }
-            // Copy .next/static to staging/_next/static
-            const staticPath = (0, node_path_1.join)(this.props.buildDirectory, ".next", "static");
-            if (this.directoryExists(staticPath)) {
-                const nextDir = (0, node_path_1.join)(stagingDir, "_next");
-                const staticDestDir = (0, node_path_1.join)(nextDir, "static");
-                // Create _next directory
-                (0, node_fs_1.mkdirSync)(nextDir, { recursive: true });
-                // Copy static assets
-                (0, node_fs_1.cpSync)(staticPath, staticDestDir, { recursive: true });
-                hasAssets = true;
+            const destDir = (0, node_path_1.join)(stagingDir, subPath);
+            (0, node_fs_1.mkdirSync)(destDir, { recursive: true });
+            (0, node_fs_1.cpSync)(realSourceDir, destDir, {
+                recursive: true,
+                dereference: true,
+                filter: (path) => include((0, node_path_1.relative)(realSourceDir, path)),
+            });
+            if (listFiles(destDir).length === 0) {
+                (0, node_fs_1.rmSync)(stagingDir, { recursive: true, force: true });
+                return undefined;
             }
-            return hasAssets ? stagingDir : undefined;
+            return stagingDir;
         }
         catch (error) {
-            console.error(`${constants_1.LOG_PREFIX} Error creating staging directory:`, error);
-            // Clean up on error
+            // Thrown rather than skipped, which would deploy without these assets.
+            // The cleanup's own failure must not replace that error.
             try {
                 (0, node_fs_1.rmSync)(stagingDir, { recursive: true, force: true });
             }
             catch {
                 // Ignore cleanup errors
             }
-            return undefined;
+            throw new Error(`${constants_1.LOG_PREFIX} Could not stage ${sourceDir} for upload`, {
+                cause: error,
+            });
         }
     }
     /**
@@ -163,4 +398,4 @@ class NextjsStaticAssets extends constructs_1.Construct {
     }
 }
 exports.NextjsStaticAssets = NextjsStaticAssets;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"nextjs-static-assets.js","sourceRoot":"","sources":["../src/nextjs-static-assets.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  cpSync,\n  existsSync,\n  mkdirSync,\n  mkdtempSync,\n  rmSync,\n  statSync,\n} from \"node:fs\";\nimport { tmpdir } from \"node:os\";\nimport { join } from \"node:path\";\nimport { RemovalPolicy, Token } from \"aws-cdk-lib\";\nimport {\n  BlockPublicAccess,\n  Bucket,\n  BucketEncryption,\n  BucketProps,\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\";\nimport { normalizeBasePath } from \"./utils/base-path\";\n\n/**\n * The S3 object key pattern covering every static asset uploaded under\n * `keyPrefix` (`NextjsStaticAssets.keyPrefix`): `\"base/*\"`, or `\"*\"` at the\n * bucket root. For scoping the compute's read grant to the app's own objects\n * when several apps share one bucket.\n */\nexport function staticAssetsObjectsPattern(keyPrefix?: string): string {\n  if (keyPrefix && Token.isUnresolved(keyPrefix)) {\n    return \"*\";\n  }\n  const prefix = normalizeBasePath(keyPrefix);\n  return prefix ? `${prefix}/*` : \"*\";\n}\n\nexport interface NextjsStaticAssetsOverrides {\n  readonly bucketProps?: BucketProps;\n  readonly bucketDeploymentProps?: BucketDeploymentProps;\n}\n\nexport interface NextjsStaticAssetsProps {\n  /**\n   * Bring your own S3 bucket for static assets. When provided, cdk-nextjs\n   * will skip creating a new bucket and deploy assets to this bucket instead.\n   * Can be shared only between deployments with different `basePath`s (S3 key\n   * prefixes): pruning is scoped to `<basePath>/_next/`, but two deployments\n   * under the same prefix overwrite each other's `public/` files and prune each\n   * other's older `_next/` assets.\n   */\n  readonly bucket?: IBucket;\n  /**\n   * Directory where the Next.js application is located.\n   * This should contain the .next directory and other build artifacts.\n   */\n  readonly buildDirectory: string;\n  /**\n   * Build ID from NextjsBuild to track asset versions\n   */\n  readonly buildId: string;\n  /**\n   * Prefix to the URI path the app will be served at.\n   * @example \"/my-base-path\"\n   */\n  readonly basePath?: string;\n  readonly overrides?: NextjsStaticAssetsOverrides;\n}\n\n/**\n * Creates S3 Bucket for public and _next/static assets and deploys them using S3Deployment.\n */\nexport class NextjsStaticAssets extends Construct {\n  bucket: IBucket;\n  deployment: BucketDeployment;\n  /**\n   * S3 key prefix the assets are actually uploaded under, normalized to a bare\n   * path segment (empty when they live at the bucket root).\n   *\n   * Consumers that read assets back out of the bucket (the runtime's image\n   * optimizer, `NextjsApi`'s S3 integrations) must use this rather than the\n   * `basePath` prop, since `overrides.bucketDeploymentProps` can replace the\n   * prefix outright. Nor can they derive it from the app's own `basePath`: that\n   * is the prefix of the *URL* the app is served at, which for the API Gateway\n   * deployment types is the stage name and has nothing to do with where the\n   * bytes were uploaded.\n   */\n  readonly keyPrefix: string;\n  private stagingDir?: string;\n\n  private props: NextjsStaticAssetsProps;\n\n  constructor(scope: Construct, id: string, props: NextjsStaticAssetsProps) {\n    super(scope, id);\n    this.props = props;\n    this.keyPrefix = this.resolveKeyPrefix();\n    this.bucket = props.bucket ?? this.createBucket();\n    this.deployment = this.createDeployment();\n  }\n\n  /**\n   * Resolves the single prefix both the upload and the URLs use. A\n   * `bucketDeploymentProps.destinationKeyPrefix` override wins over `basePath`,\n   * but it's normalized here and `createDeployment` sets the normalized value\n   * after the override spread, so `keyPrefix` can't drift from where the assets\n   * land.\n   *\n   * Compared against `undefined` rather than tested with `in`, because a JSII\n   * language binding (or a programmatically built props object) can materialize\n   * an unset optional field as an explicit `undefined`. Treating that as an\n   * intentional \"move the assets to the bucket root\" override would silently\n   * drop `basePath` from the prefix.\n   */\n  private resolveKeyPrefix(): string {\n    const deploymentOverrides = this.props.overrides?.bucketDeploymentProps;\n    const prefix =\n      deploymentOverrides?.destinationKeyPrefix !== undefined\n        ? deploymentOverrides.destinationKeyPrefix\n        : this.props.basePath;\n    return normalizeBasePath(prefix);\n  }\n\n  private createBucket() {\n    return new Bucket(this, \"Bucket\", {\n      removalPolicy: RemovalPolicy.DESTROY,\n      autoDeleteObjects: true,\n      enforceSSL: true,\n      blockPublicAccess: BlockPublicAccess.BLOCK_ALL,\n      encryption: BucketEncryption.S3_MANAGED,\n      minimumTLSVersion: 1.2,\n      ...this.props.overrides?.bucketProps,\n    });\n  }\n\n  private createDeployment() {\n    // Create a staging directory with the correct structure\n    this.stagingDir = this.createStagingDirectory();\n\n    if (!this.stagingDir) {\n      throw new Error(\n        `No static assets found to deploy. Ensure your Next.js build output contains either:\n        - A 'public' directory at: ${join(this.props.buildDirectory, \"public\")}\n        - A '.next/static' directory at: ${join(this.props.buildDirectory, \".next\", \"static\")}`,\n      );\n    }\n\n    return new BucketDeployment(this, \"Deployment\", {\n      sources: [Source.asset(this.stagingDir)],\n      destinationBucket: this.bucket,\n      // Add BUILD_ID as metadata to all objects for version tracking\n      metadata: {\n        BUILD_ID: this.props.buildId,\n      },\n      prune: false, // Don't delete existing assets to prevent 404s during deployment, pruning will be handled by post-deploy\n      // S3Deployment automatically detects content types based on file extensions\n      ...this.props.overrides?.bucketDeploymentProps,\n      // Set after the spread: `resolveKeyPrefix` already folded in any\n      // `destinationKeyPrefix` override, so this is the normalized form of it.\n      // Letting the raw override through here would upload the assets somewhere\n      // other than the `keyPrefix` used to build their URLs.\n      destinationKeyPrefix: this.keyPrefix || undefined,\n    });\n  }\n\n  /**\n   * Create a staging directory with the correct structure:\n   * - public/ files go to root\n   * - .next/static/ files go to _next/static/\n   */\n  private createStagingDirectory(): string | undefined {\n    const stagingDir = mkdtempSync(join(tmpdir(), \"nextjs-assets-\"));\n    let hasAssets = false;\n\n    try {\n      // Copy public directory contents to staging root\n      const publicPath = join(this.props.buildDirectory, \"public\");\n      if (this.directoryExists(publicPath)) {\n        cpSync(publicPath, stagingDir, { recursive: true });\n        hasAssets = true;\n      }\n\n      // Copy .next/static to staging/_next/static\n      const staticPath = join(this.props.buildDirectory, \".next\", \"static\");\n      if (this.directoryExists(staticPath)) {\n        const nextDir = join(stagingDir, \"_next\");\n        const staticDestDir = join(nextDir, \"static\");\n\n        // Create _next directory\n        mkdirSync(nextDir, { recursive: true });\n\n        // Copy static assets\n        cpSync(staticPath, staticDestDir, { recursive: true });\n        hasAssets = true;\n      }\n\n      return hasAssets ? stagingDir : undefined;\n    } catch (error) {\n      console.error(`${LOG_PREFIX} Error creating staging directory:`, error);\n      // Clean up on error\n      try {\n        rmSync(stagingDir, { recursive: true, force: true });\n      } catch {\n        // Ignore cleanup errors\n      }\n      return undefined;\n    }\n  }\n\n  /**\n   * Check if a directory exists\n   */\n  private directoryExists(dirPath: string): boolean {\n    try {\n      return existsSync(dirPath) && statSync(dirPath).isDirectory();\n    } catch {\n      return false;\n    }\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"nextjs-static-assets.js","sourceRoot":"","sources":["../src/nextjs-static-assets.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  cpSync,\n  existsSync,\n  mkdirSync,\n  mkdtempSync,\n  readdirSync,\n  realpathSync,\n  rmSync,\n  statSync,\n} from \"node:fs\";\nimport { tmpdir } from \"node:os\";\nimport { join, relative, sep } from \"node:path\";\nimport { Duration, RemovalPolicy, Token } from \"aws-cdk-lib\";\nimport {\n  BlockPublicAccess,\n  Bucket,\n  BucketEncryption,\n  BucketProps,\n  IBucket,\n} from \"aws-cdk-lib/aws-s3\";\nimport {\n  BucketDeployment,\n  BucketDeploymentProps,\n  CacheControl,\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\";\nimport { normalizeBasePath } from \"./utils/base-path\";\n\n/**\n * The S3 object key pattern covering every static asset uploaded under\n * `keyPrefix` (`NextjsStaticAssets.keyPrefix`): `\"base/*\"`, or `\"*\"` at the\n * bucket root. For scoping the compute's read grant to the app's own objects\n * when several apps share one bucket.\n */\nexport function staticAssetsObjectsPattern(keyPrefix?: string): string {\n  if (keyPrefix && Token.isUnresolved(keyPrefix)) {\n    return \"*\";\n  }\n  const prefix = normalizeBasePath(keyPrefix);\n  return prefix ? `${prefix}/*` : \"*\";\n}\n\n/** Where `.next/static` is served from, relative to `keyPrefix`. */\nconst STATIC_PATH = join(\"_next\", \"static\");\n/** Where Next.js compiles service workers to, relative to `.next/static`. */\nconst SERVICE_WORKER_DIR = \"service-worker\";\n\n/**\n * Every file under `dir`, relative to it, through symlinks too: CDK uploads a\n * linked file or directory as what it points to, under every name it's reached\n * by.\n *\n * An explicit walk rather than `readdirSync({ recursive: true })`, which never\n * returns on a symlink cycle (Node 24 follows directory links), and whose\n * `Dirent.parentPath` doesn't exist before Node 20.12. A link back to a\n * directory already on the current path is a cycle and isn't followed; one that\n * can't be stat'd (dangling, or a loop of links) counts as a file.\n */\nfunction listFiles(dir: string): string[] {\n  const files: string[] = [];\n  const walk = (sub: string, ancestors: ReadonlySet<string>) => {\n    const real = realpathSync(join(dir, sub));\n    if (ancestors.has(real)) {\n      return;\n    }\n    const path = new Set(ancestors).add(real);\n    for (const entry of readdirSync(real, { withFileTypes: true })) {\n      const child = join(sub, entry.name);\n      if (\n        entry.isDirectory() ||\n        (entry.isSymbolicLink() && isDirectoryLink(join(real, entry.name)))\n      ) {\n        walk(child, path);\n      } else {\n        files.push(child);\n      }\n    }\n  };\n  walk(\"\", new Set());\n  return files;\n}\n\nfunction isDirectoryLink(path: string): boolean {\n  try {\n    return statSync(path).isDirectory();\n  } catch {\n    return false;\n  }\n}\n\n/** Whether the relative `path` is `dir` or inside it. */\nfunction isWithin(path: string, dir: string): boolean {\n  return path === dir || path.startsWith(dir + sep);\n}\n\nexport interface NextjsStaticAssetsOverrides {\n  readonly bucketProps?: BucketProps;\n  /**\n   * Applied to every upload (`public/`, `_next/static/` and\n   * `_next/static/service-worker/`), except that the two `_next/static` uploads\n   * always keep the `Cache-Control` Next.js sends for them. So a `cacheControl`\n   * here sets the header for `public/` files only, while anything else, such as\n   * a `distribution` to invalidate, applies to each upload in turn.\n   *\n   * `sources` and `destinationBucket`, which the type requires, are ignored:\n   * the uploads are always the build's assets, to the bucket CloudFront and\n   * API Gateway read from (pass `bucket` to bring your own). `prune: true` and\n   * `retainOnDelete: false` are rejected, since each would break the other\n   * uploads.\n   */\n  readonly bucketDeploymentProps?: BucketDeploymentProps;\n}\n\nexport interface NextjsStaticAssetsProps {\n  /**\n   * Bring your own S3 bucket for static assets. When provided, cdk-nextjs\n   * will skip creating a new bucket and deploy assets to this bucket instead.\n   * Can be shared only between deployments with different `basePath`s (S3 key\n   * prefixes): pruning is scoped to `<basePath>/_next/`, but two deployments\n   * under the same prefix overwrite each other's `public/` files and prune each\n   * other's older `_next/` assets.\n   */\n  readonly bucket?: IBucket;\n  /**\n   * Directory where the Next.js application is located.\n   * This should contain the .next directory and other build artifacts.\n   */\n  readonly buildDirectory: string;\n  /**\n   * Build ID from NextjsBuild to track asset versions\n   */\n  readonly buildId: string;\n  /**\n   * Prefix to the URI path the app will be served at.\n   * @example \"/my-base-path\"\n   */\n  readonly basePath?: string;\n  readonly overrides?: NextjsStaticAssetsOverrides;\n}\n\n/**\n * Creates S3 Bucket for public and _next/static assets and deploys them using S3Deployment.\n */\nexport class NextjsStaticAssets extends Construct {\n  bucket: IBucket;\n  /**\n   * The first of `staticDeployment`, `serviceWorkerDeployment` and\n   * `publicDeployment` the build has files for.\n   *\n   * @deprecated The assets are uploaded by up to three deployments, and this\n   * is only one of them: a dependency on it doesn't wait for the others. Use\n   * `staticDeployment`, `serviceWorkerDeployment` and `publicDeployment`.\n   */\n  deployment: BucketDeployment;\n  /**\n   * Uploads `.next/static` to `_next/static/` with\n   * `Cache-Control: public, max-age=31536000, immutable`, except for\n   * `service-worker/` (see `serviceWorkerDeployment`). Absent if the build has\n   * no `.next/static`.\n   */\n  readonly staticDeployment?: BucketDeployment;\n  /**\n   * Uploads `.next/static/service-worker` with\n   * `Cache-Control: public, max-age=0, must-revalidate`, as Next.js serves it:\n   * a service worker keeps its URL across builds, so it can't be `immutable`.\n   * Absent if the build has no service worker.\n   */\n  readonly serviceWorkerDeployment?: BucketDeployment;\n  /**\n   * Uploads `public/`, separately from `staticDeployment` because its files\n   * keep their names when they change and so can't be `immutable`. Absent if\n   * the build has no `public` directory.\n   */\n  readonly publicDeployment?: BucketDeployment;\n  /**\n   * S3 key prefix the assets are actually uploaded under, normalized to a bare\n   * path segment (empty when they live at the bucket root).\n   *\n   * Consumers that read assets back out of the bucket (the runtime's image\n   * optimizer, `NextjsApi`'s S3 integrations) must use this rather than the\n   * `basePath` prop, since `overrides.bucketDeploymentProps` can replace the\n   * prefix outright. Nor can they derive it from the app's own `basePath`: that\n   * is the prefix of the *URL* the app is served at, which for the API Gateway\n   * deployment types is the stage name and has nothing to do with where the\n   * bytes were uploaded.\n   */\n  readonly keyPrefix: string;\n\n  private props: NextjsStaticAssetsProps;\n\n  constructor(scope: Construct, id: string, props: NextjsStaticAssetsProps) {\n    super(scope, id);\n    this.props = props;\n    this.validateDeploymentOverrides();\n    this.keyPrefix = this.resolveKeyPrefix();\n    this.bucket = props.bucket ?? this.createBucket();\n    const staged: string[] = [];\n    try {\n      const uploads = this.createDeployments(staged);\n      this.staticDeployment = uploads.staticDeployment;\n      this.serviceWorkerDeployment = uploads.serviceWorkerDeployment;\n      this.publicDeployment = uploads.publicDeployment;\n    } finally {\n      // `Source.asset` stages during `BucketDeployment`'s construction (CDK's\n      // `AssetStaging` copies into `cdk.out` from its own constructor), so the\n      // temporary copies are dead once the deployments exist, or once one of\n      // them failed. Left behind, every synth would add another full copy of\n      // the app's static assets to the temp directory.\n      //\n      // Unless staging is disabled (`cdk synth --no-staging`, and SAM, which\n      // sets the same context): then the asset manifest points at these\n      // directories themselves, and removing them would fail the publish that\n      // follows.\n      if (!this.node.tryGetContext(cxapi.DISABLE_ASSET_STAGING_CONTEXT)) {\n        for (const dir of staged) {\n          rmSync(dir, { recursive: true, force: true });\n        }\n      }\n    }\n    this.deployment = (this.staticDeployment ??\n      this.serviceWorkerDeployment ??\n      this.publicDeployment)!;\n  }\n\n  /**\n   * Stages each tree and creates its deployment, adding every staging\n   * directory to `staged` as it's made, so the caller can remove them even if\n   * a later step throws.\n   */\n  private createDeployments(staged: string[]): {\n    staticDeployment?: BucketDeployment;\n    serviceWorkerDeployment?: BucketDeployment;\n    publicDeployment?: BucketDeployment;\n  } {\n    const stage: typeof this.stageDirectory = (...args) => {\n      const dir = this.stageDirectory(...args);\n      if (dir) {\n        staged.push(dir);\n      }\n      return dir;\n    };\n    const builtDir = join(this.props.buildDirectory, \".next\", \"static\");\n    const publicSourceDir = join(this.props.buildDirectory, \"public\");\n    // Only a directory is uploaded as service workers, so only a directory is\n    // left out here.\n    const hasServiceWorkers = this.directoryExists(\n      join(builtDir, SERVICE_WORKER_DIR),\n    );\n    const staticDir = stage(\n      builtDir,\n      STATIC_PATH,\n      (path) => !hasServiceWorkers || !isWithin(path, SERVICE_WORKER_DIR),\n    );\n    const serviceWorkerDir = stage(\n      join(builtDir, SERVICE_WORKER_DIR),\n      join(STATIC_PATH, SERVICE_WORKER_DIR),\n    );\n    // A `public/_next/static` file with a built file's name would land on the\n    // same key. `next start` serves the built one, so the public copy is left\n    // out; uploading both would leave whichever deployment finished last.\n    // Other `public/_next/static` files are served as `next start` does.\n    // Matched against a listing rather than with `existsSync`, which on macOS\n    // and Windows would let `Legacy.js` shadow `legacy.js`: Next.js and S3 keys\n    // are case-sensitive.\n    const builtFiles = new Set(\n      this.directoryExists(builtDir) ? listFiles(builtDir) : [],\n    );\n    const publicDir = stage(\n      publicSourceDir,\n      \"\",\n      (path) =>\n        !isWithin(path, STATIC_PATH) ||\n        !builtFiles.has(relative(STATIC_PATH, path)),\n    );\n    if (!staticDir && !serviceWorkerDir && !publicDir) {\n      throw new Error(\n        `No static assets found to deploy. Ensure your Next.js build output contains files in either:\n        - A 'public' directory at: ${publicSourceDir}\n        - A '.next/static' directory at: ${builtDir}`,\n      );\n    }\n    // `_next/static/` files are content-hashed, so they get the same header\n    // Next.js sends for them. Nothing else would: CloudFront and API Gateway\n    // serve them straight from S3, where the object's metadata is the only\n    // `Cache-Control` there is. A `BucketDeployment`'s `cacheControl` applies to\n    // every object it uploads, hence one deployment per header.\n    return {\n      staticDeployment: staticDir\n        ? this.createDeployment(\"Deployment\", staticDir, [\n            CacheControl.setPublic(),\n            CacheControl.maxAge(Duration.days(365)),\n            CacheControl.immutable(),\n          ])\n        : undefined,\n      serviceWorkerDeployment: serviceWorkerDir\n        ? this.createDeployment(\"ServiceWorkerDeployment\", serviceWorkerDir, [\n            CacheControl.setPublic(),\n            CacheControl.maxAge(Duration.seconds(0)),\n            CacheControl.mustRevalidate(),\n          ])\n        : undefined,\n      publicDeployment: publicDir\n        ? this.createDeployment(\"PublicDeployment\", publicDir)\n        : undefined,\n    };\n  }\n\n  /**\n   * Rejects the `bucketDeploymentProps` that can't work across several\n   * deployments sharing one prefix. Each is spread into every one of them:\n   *\n   * - `prune: true` makes each deployment's `s3 sync --delete` remove the files\n   *   the others uploaded.\n   * - `retainOnDelete: false` makes a deployment `s3 rm --recursive` its old\n   *   prefix when the prefix changes, without checking whether the bucket is\n   *   CDK's (only Delete checks), so it can delete files another deployment has\n   *   just uploaded there. On Delete, CDK skips that `rm` only for a bucket it\n   *   tagged, and it can't tag an imported one, so a build that stops having\n   *   files for one deployment would lose the others' files too.\n   *\n   * `sources` and `destinationBucket` aren't rejected, because the type\n   * requires them; `newDeployment` sets them after the spread instead.\n   *\n   * Compared against the exact value, as with `destinationKeyPrefix`, so an\n   * explicit `undefined` from a JSII binding is not mistaken for an override.\n   */\n  private validateDeploymentOverrides() {\n    const overrides = this.props.overrides?.bucketDeploymentProps;\n    const rejected = [\n      overrides?.prune === true &&\n        \"`prune: true` (old assets are pruned after deploy by NextjsPostDeploy, once they are past its TTL)\",\n      overrides?.retainOnDelete === false && \"`retainOnDelete: false`\",\n    ].filter((reason): reason is string => !!reason);\n    if (rejected.length > 0) {\n      throw new Error(\n        `${LOG_PREFIX} overrides.bucketDeploymentProps can't set ${rejected.join(\", or \")}: ` +\n          \"the static assets are uploaded by one deployment per Cache-Control, \" +\n          \"and each of these would break the others.\",\n      );\n    }\n  }\n\n  /**\n   * Resolves the single prefix both the upload and the URLs use. A\n   * `bucketDeploymentProps.destinationKeyPrefix` override wins over `basePath`,\n   * but it's normalized here and `createDeployment` sets the normalized value\n   * after the override spread, so `keyPrefix` can't drift from where the assets\n   * land.\n   *\n   * Compared against `undefined` rather than tested with `in`, because a JSII\n   * language binding (or a programmatically built props object) can materialize\n   * an unset optional field as an explicit `undefined`. Treating that as an\n   * intentional \"move the assets to the bucket root\" override would silently\n   * drop `basePath` from the prefix.\n   */\n  private resolveKeyPrefix(): string {\n    const deploymentOverrides = this.props.overrides?.bucketDeploymentProps;\n    const prefix =\n      deploymentOverrides?.destinationKeyPrefix !== undefined\n        ? deploymentOverrides.destinationKeyPrefix\n        : this.props.basePath;\n    return normalizeBasePath(prefix);\n  }\n\n  private createBucket() {\n    return new Bucket(this, \"Bucket\", {\n      removalPolicy: RemovalPolicy.DESTROY,\n      autoDeleteObjects: true,\n      enforceSSL: true,\n      blockPublicAccess: BlockPublicAccess.BLOCK_ALL,\n      encryption: BucketEncryption.S3_MANAGED,\n      minimumTLSVersion: 1.2,\n      ...this.props.overrides?.bucketProps,\n    });\n  }\n\n  private createDeployment(\n    id: string,\n    stagingDir: string,\n    cacheControl?: CacheControl[],\n  ) {\n    return new BucketDeployment(this, id, {\n      // Add BUILD_ID as metadata to all objects for version tracking\n      metadata: {\n        BUILD_ID: this.props.buildId,\n      },\n      // S3Deployment automatically detects content types based on file extensions\n      ...this.props.overrides?.bucketDeploymentProps,\n      // Set after the spread. The type makes callers pass `sources` and\n      // `destinationBucket`, and either would upload something other than the\n      // build's assets, or somewhere CloudFront and API Gateway don't read from.\n      // `validateDeploymentOverrides` lets `prune` through only as `false` or an\n      // explicit `undefined` from a JSII binding, which would turn on CDK's\n      // default `prune: true`.\n      sources: [Source.asset(stagingDir)],\n      destinationBucket: this.bucket,\n      prune: false, // Don't delete existing assets to prevent 404s during deployment, pruning will be handled by post-deploy\n      ...(cacheControl && { cacheControl }),\n      // Set after the spread: `resolveKeyPrefix` already folded in any\n      // `destinationKeyPrefix` override, so this is the normalized form of it.\n      // Letting the raw override through here would upload the assets somewhere\n      // other than the `keyPrefix` used to build their URLs.\n      destinationKeyPrefix: this.keyPrefix || undefined,\n    });\n  }\n\n  /**\n   * Copies `sourceDir` to `<staging>/<subPath>` in a new staging directory, or\n   * returns `undefined` if there is no `sourceDir` or no file in it passes\n   * `include`. Staged under `subPath` rather than uploaded with a longer\n   * `destinationKeyPrefix`, so every deployment shares the one prefix\n   * `keyPrefix` resolves. `include` gets each entry's path relative to\n   * `sourceDir`.\n   */\n  private stageDirectory(\n    sourceDir: string,\n    subPath: string,\n    include: (path: string) => boolean = () => true,\n  ): string | undefined {\n    if (!this.directoryExists(sourceDir)) {\n      return undefined;\n    }\n    // From the real path, and dereferencing links inside it: `cpSync` would\n    // copy a link as a link, which fails for a symlinked `sourceDir` (onto the\n    // directory made for it here) and hides a linked directory's files from\n    // `include`, though CDK uploads them.\n    const realSourceDir = realpathSync(sourceDir);\n    const stagingDir = mkdtempSync(join(tmpdir(), \"nextjs-assets-\"));\n    try {\n      const destDir = join(stagingDir, subPath);\n      mkdirSync(destDir, { recursive: true });\n      cpSync(realSourceDir, destDir, {\n        recursive: true,\n        dereference: true,\n        filter: (path) => include(relative(realSourceDir, path)),\n      });\n      if (listFiles(destDir).length === 0) {\n        rmSync(stagingDir, { recursive: true, force: true });\n        return undefined;\n      }\n      return stagingDir;\n    } catch (error) {\n      // Thrown rather than skipped, which would deploy without these assets.\n      // The cleanup's own failure must not replace that error.\n      try {\n        rmSync(stagingDir, { recursive: true, force: true });\n      } catch {\n        // Ignore cleanup errors\n      }\n      throw new Error(`${LOG_PREFIX} Could not stage ${sourceDir} for upload`, {\n        cause: error,\n      });\n    }\n  }\n\n  /**\n   * Check if a directory exists\n   */\n  private directoryExists(dirPath: string): boolean {\n    try {\n      return existsSync(dirPath) && statSync(dirPath).isDirectory();\n    } catch {\n      return false;\n    }\n  }\n}\n"]}