cdktn 0.25.0-pre.8 → 0.25.0

package/lib/asset-staging.js

@@ -0,0 +1,464 @@
+"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.AssetStaging = exports.ASSET_HASH_SALT_CONTEXT_KEY = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+// Copyright (c) HashiCorp, Inc
+// SPDX-License-Identifier: MPL-2.0
+const constructs_1 = require("constructs");
+const crypto = __importStar(require("crypto"));
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const assets_1 = require("./assets");
+const errors_1 = require("./errors");
+const features_1 = require("./features");
+const ignore_strategy_1 = require("./ignore-strategy");
+const fs_1 = require("./private/fs");
+// A resolved hash is used verbatim as a path segment (see `TerraformAsset.path`),
+// so it may only contain characters that are always safe there.
+const SAFE_ASSET_HASH = /^[A-Za-z0-9_.-]+$/;
+/**
+ * Context key for a value folded into every computed asset hash in the
+ * construct tree, alongside `extraHash`. A bulk cache-busting escape hatch —
+ * `extraHash` is scoped to one asset, this is scoped to the whole app.
+ */
+exports.ASSET_HASH_SALT_CONTEXT_KEY = "cdktn:assetHashSalt";
+/**
+ * Caches the base (pre `extraHash`/salt) hash of a `SOURCE`/`OUTPUT` walk,
+ * so that multiple `AssetStaging` instances with identical inputs — the same
+ * asset referenced from more than one resource or stack — hash the source
+ * tree once per synth instead of once per reference.
+ *
+ * Keyed per construct-tree root (the `App`) rather than at module scope: an
+ * App instance lives exactly as long as one synth, so a long-running process
+ * that synths repeatedly against changing files (e.g. `cdktn watch`) always
+ * gets a fresh cache instead of a stale hash from a previous synth.
+ */
+const hashCachesByRoot = new WeakMap();
+/**
+ * The hash cache scoped to a construct-tree root, created on first use.
+ *
+ * See {@link hashCachesByRoot} for why the cache is scoped per root.
+ */
+function hashCacheFor(root) {
+    let cache = hashCachesByRoot.get(root);
+    if (!cache) {
+        cache = new Map();
+        hashCachesByRoot.set(root, cache);
+    }
+    return cache;
+}
+/**
+ * Eager-build scratch directories awaiting cleanup, swept on process exit or
+ * an interrupting signal.
+ *
+ * An `OUTPUT`-hash build runs in the constructor but is normally torn down in
+ * `stage()`. When the asset's stack is not synthesized this pass, `stage()`
+ * never runs, so the sweep reclaims what can be large trees (`node_modules`,
+ * build caches) that `os.tmpdir()` does not clear reliably.
+ */
+const strandedScratchDirs = new Set();
+let exitSweepInstalled = false;
+/**
+ * Synchronously remove every still-registered scratch directory.
+ */
+function sweepStrandedScratch() {
+    for (const stray of strandedScratchDirs) {
+        try {
+            fs.rmSync(stray, { recursive: true, force: true });
+        }
+        catch {
+            // Best-effort on the way out; nothing useful to do if it fails.
+        }
+    }
+    strandedScratchDirs.clear();
+}
+/**
+ * Track a scratch directory for removal if it survives to process exit.
+ *
+ * `exit` alone misses a Ctrl-C or a `kill` during synth — exactly when the
+ * largest trees (`node_modules`, build caches) are left behind — because Node
+ * does not run `exit` handlers on `SIGINT`/`SIGTERM`. The signal handlers
+ * sweep, then re-raise the signal so any other listeners (the CLI's own) still
+ * run, or the default disposition terminates the process if there are none.
+ */
+function registerStrandedScratch(dir) {
+    strandedScratchDirs.add(dir);
+    if (!exitSweepInstalled) {
+        exitSweepInstalled = true;
+        // `exit` handlers must be synchronous; `rmSync` is.
+        process.once("exit", sweepStrandedScratch);
+        for (const signal of ["SIGINT", "SIGTERM"]) {
+            process.once(signal, () => {
+                sweepStrandedScratch();
+                // Re-raise so the signal is not swallowed. `process.once` has already
+                // removed this listener, so the re-raise reaches whatever else is
+                // registered — the CLI's own SIGINT/SIGTERM handlers — or, if nothing
+                // is, the default disposition that terminates the process. Removing
+                // other listeners here would discard exactly those the app relies on.
+                process.kill(process.pid, signal);
+            });
+        }
+    }
+}
+/**
+ * Resolves an asset's identity and stages its content to disk.
+ *
+ * The hash is available immediately after construction; the filesystem write
+ * is deferred to `stage()`, the one window where it is safe. Hashing is
+ * cached per synth (see {@link hashCachesByRoot}) so an asset referenced from
+ * several places is walked once. Without a bundler, `SOURCE` and `OUTPUT` both
+ * hash the source; with one they diverge, as `AssetStagingOptions.bundler`
+ * describes.
+ */
+class AssetStaging extends constructs_1.Construct {
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "cdktn.AssetStaging", version: "0.25.0" };
+    sourcePath;
+    displayName;
+    ignoreStrategy;
+    hasExclusions;
+    hashCache;
+    bundler;
+    /**
+     * Output of an eager `OUTPUT`-hash build, carried to `stage()` for reuse.
+     *
+     * Undefined on every other path, where the build is deferred or absent.
+     */
+    eagerBuild;
+    /**
+     * Set once `stage()` has run, so a second call cannot rebuild. An eager
+     * `OUTPUT` build is captured at construction and consumed by the first
+     * `stage()`; without this guard a second call would fall through to the
+     * deferred build path and stage bytes that no longer match the hash.
+     */
+    staged = false;
+    packaging;
+    isDirectory;
+    assetHash;
+    constructor(scope, id, props) {
+        super(scope, id);
+        this.sourcePath = props.sourcePath;
+        this.displayName = props.displayName ?? id;
+        this.packaging = props.packaging;
+        this.isDirectory = props.packaging.producesDirectory;
+        this.hashCache = hashCacheFor(this.node.root);
+        this.bundler = props.bundler;
+        if (props.exclude?.length && props.ignoreStrategy) {
+            throw (0, errors_1.assetStagingConflictingExcludeOptions)(this.displayName);
+        }
+        this.ignoreStrategy =
+            props.ignoreStrategy ?? new ignore_strategy_1.ExcludeIgnoreStrategy(props.exclude ?? []);
+        // A custom strategy is assumed to exclude something; the built-in one only
+        // does with a non-empty `exclude`. Drives whether the bundler is handed a
+        // materialised filtered copy or the source directly.
+        this.hasExclusions =
+            props.ignoreStrategy !== undefined || !!props.exclude?.length;
+        // Bundler output shape (directory vs file) is only known once `bundle`
+        // runs, so its compatibility with the packaging is checked then, not here
+        // — a deferred SOURCE build has not run yet at construction time.
+        this.assetHash = this.resolveAssetHash(this.displayName, props);
+    }
+    resolveAssetHash(id, props) {
+        const { assetHash, assetHashType, extraHash } = props;
+        if (assetHash !== undefined) {
+            if (assetHashType !== undefined &&
+                assetHashType !== assets_1.AssetHashType.CUSTOM) {
+                throw (0, errors_1.assetHashConflictingHashType)(id);
+            }
+            if (!SAFE_ASSET_HASH.test(assetHash)) {
+                throw (0, errors_1.assetHashInvalid)(id, assetHash);
+            }
+            return assetHash;
+        }
+        switch (assetHashType) {
+            case assets_1.AssetHashType.CUSTOM:
+                throw (0, errors_1.assetHashTypeCustomRequiresHash)(id);
+            case assets_1.AssetHashType.SOURCE:
+            case assets_1.AssetHashType.OUTPUT:
+            case undefined: {
+                const canonical = !!this.node.tryGetContext(features_1.CANONICAL_ASSET_HASHES);
+                const archive = this.packaging.omitsDirectoryEntries;
+                const salt = this.node.tryGetContext(exports.ASSET_HASH_SALT_CONTEXT_KEY);
+                // OUTPUT hashes the built artifact and so must build eagerly, forgoing
+                // skippability (#380); every other case hashes the source verbatim.
+                const baseHash = this.bundler && assetHashType === assets_1.AssetHashType.OUTPUT
+                    ? this.hashOutput(canonical, archive)
+                    : this.hashSource(canonical, archive);
+                // For SOURCE, folding in bundlerKey is the only way build identity
+                // reaches the hash, since the source tree cannot see the build.
+                const bundlerKey = this.bundler?.bundlerKey;
+                if (!extraHash && !salt && !bundlerKey) {
+                    return baseHash;
+                }
+                const folded = crypto.createHash("md5").update(baseHash);
+                if (extraHash) {
+                    folded.update(extraHash);
+                }
+                if (bundlerKey) {
+                    folded.update(bundlerKey);
+                }
+                if (salt) {
+                    folded.update(String(salt));
+                }
+                return folded.digest("hex").slice(0, 32).toUpperCase();
+            }
+            default:
+                // Out-of-range value from a non-TypeScript caller.
+                throw (0, errors_1.assetHashTypeUnknown)(id, assetHashType);
+        }
+    }
+    /**
+     * Hash the source tree, honoring the ignore strategy.
+     *
+     * Cached per synth so an asset referenced more than once is walked once.
+     */
+    hashSource(canonical, archive) {
+        // Only cacheable when the ignore strategy can summarize its behavior
+        // as a string (see `IIgnoreStrategy.cacheKey`); otherwise every call
+        // is treated as unique.
+        const cacheKey = this.ignoreStrategy.cacheKey !== undefined
+            ? JSON.stringify({
+                sourcePath: this.sourcePath,
+                canonical,
+                archive,
+                ignore: this.ignoreStrategy.cacheKey,
+            })
+            : undefined;
+        const cached = cacheKey ? this.hashCache.get(cacheKey) : undefined;
+        if (cached !== undefined) {
+            return cached;
+        }
+        const hash = (0, fs_1.hashPath)(this.sourcePath, {
+            canonical,
+            archive,
+            shouldExclude: (relativePath, isDirectory) => this.ignoreStrategy.ignores({ relativePath, isDirectory }),
+            descendIntoExcludedDirectories: this.ignoreStrategy.pruneExcludedDirectories === false,
+        });
+        if (cacheKey) {
+            this.hashCache.set(cacheKey, hash);
+        }
+        return hash;
+    }
+    /**
+     * Build the bundler's output eagerly and hash the built artifact.
+     *
+     * The output is stashed for `stage()` to reuse, so the build is not
+     * repeated. It is hashed verbatim: `exclude` filters the source a bundler
+     * reads, not the artifact it produces.
+     */
+    hashOutput(canonical, archive) {
+        const scratch = fs.mkdtempSync(path.join(os.tmpdir(), "cdktn-bundle-"));
+        // Registered so the exit sweep reclaims it if stage() never runs for an
+        // unsynthesized stack; stage() removes and unregisters it otherwise.
+        registerStrandedScratch(scratch);
+        try {
+            const { produced, outputType } = this.runBundle(scratch);
+            this.eagerBuild = { scratch, produced, outputType };
+            // A single-file artifact is hashed as a file (no archive framing); a
+            // directory is hashed as the packaged tree would be.
+            const isFile = outputType === assets_1.BundleOutputType.FILE;
+            return (0, fs_1.hashPath)(produced, { canonical, archive: archive && !isFile });
+        }
+        catch (e) {
+            // The build failed before `eagerBuild` was set, so stage() can never
+            // reach this scratch to clean it. Reclaim it now rather than leaving a
+            // potentially large tree (node_modules, build caches) to the exit sweep.
+            this.cleanupScratch(scratch);
+            throw e;
+        }
+    }
+    /**
+     * Run the bundler against the filtered source and return its output.
+     *
+     * The bundler is handed an absolute `source` (its cwd is its own, so a
+     * relative path would resolve elsewhere) that has already had `exclude`
+     * applied. Materialising the filtered input here is what makes the bundler
+     * read exactly the tree the hash was taken over, which a raw source
+     * hand-off would not, since `hashSource` honours `exclude`.
+     */
+    runBundle(scratch) {
+        const outputDir = path.join(scratch, "output");
+        fs.mkdirSync(outputDir);
+        const result = this.bundler.bundle({
+            source: this.filteredSource(scratch),
+            outputDir,
+        });
+        // A bare bundler that declines has nothing to fall back to — declining is
+        // only meaningful inside a ChainBundler, which consumes it before it
+        // reaches here. A non-declined result always carries a path and shape.
+        if (result.isDeclined ||
+            result.path === undefined ||
+            result.outputType === undefined) {
+            throw (0, errors_1.assetStagingBundlerOutputNotDirectory)(this.displayName, String(result.path));
+        }
+        const produced = result.path;
+        this.validateOutputShape(produced, result.outputType);
+        return { produced, outputType: result.outputType };
+    }
+    /**
+     * Reject a bundler result whose declared shape does not match what is on
+     * disk, or does not match the packaging.
+     *
+     * Catching the mismatch here turns an opaque EISDIR/EPERM at pack time into
+     * a clear error naming the packaging the bundler's output shape needs.
+     */
+    validateOutputShape(produced, outputType) {
+        const exists = fs.existsSync(produced);
+        const stat = exists ? fs.statSync(produced) : undefined;
+        if (outputType === assets_1.BundleOutputType.FILE) {
+            if (!stat?.isFile()) {
+                throw (0, errors_1.assetStagingBundlerOutputNotFile)(this.displayName, produced);
+            }
+            if (!this.stagesSingleFile) {
+                throw (0, errors_1.assetStagingBundlerFileOutputNeedsFilePackaging)(this.displayName);
+            }
+            return;
+        }
+        if (!stat?.isDirectory()) {
+            throw (0, errors_1.assetStagingBundlerOutputNotDirectory)(this.displayName, produced);
+        }
+        if (!this.packaging.acceptsDirectorySource) {
+            throw (0, errors_1.assetStagingBundlerDirectoryOutputNeedsDirectoryPackaging)(this.displayName);
+        }
+    }
+    /**
+     * Whether the packaging stages a single file verbatim (AssetType.FILE).
+     *
+     * A verbatim-file packaging neither produces a directory nor reads one as
+     * its source. Derived from existing `IAssetPackaging` flags so out-of-tree
+     * packagings need no new interface member.
+     */
+    get stagesSingleFile() {
+        return (!this.packaging.producesDirectory &&
+            !this.packaging.acceptsDirectorySource);
+    }
+    /**
+     * Absolute path to the source the bundler should read.
+     *
+     * With no exclusions, or with a file source, the resolved source is handed
+     * over directly — a file has no children to filter, matching `hashSource`,
+     * which only ever applies the ignore strategy to a directory's entries and
+     * never to the root itself. Otherwise the excluded source tree is
+     * materialised into the scratch directory, so the bundler sees the same
+     * file set the hash was taken over.
+     */
+    filteredSource(scratch) {
+        const absoluteSource = path.resolve(this.sourcePath);
+        if (!this.hasExclusions || fs.statSync(absoluteSource).isFile()) {
+            return absoluteSource;
+        }
+        const input = path.join(scratch, "input");
+        fs.mkdirSync(input);
+        (0, fs_1.copySync)(absoluteSource, input, {
+            shouldExclude: (relativePath, isDirectory) => this.ignoreStrategy.ignores({ relativePath, isDirectory }),
+            descendIntoExcludedDirectories: this.ignoreStrategy.pruneExcludedDirectories === false,
+        });
+        return input;
+    }
+    /**
+     * Stage the asset's content to `targetPath`.
+     *
+     * Called from the owning construct's `onSynthesize` hook. Without a bundler
+     * the source is packaged verbatim; with one, the bundler's output is, built
+     * eagerly for `OUTPUT` hashing or deferred to here for `SOURCE`.
+     */
+    stage(targetPath) {
+        // Stage exactly once: a rebuild could stage bytes not matching the
+        // already-computed hash (see the `staged` field).
+        if (this.staged) {
+            throw (0, errors_1.assetStagingAlreadyStaged)(this.displayName);
+        }
+        this.staged = true;
+        if (!this.bundler) {
+            this.packaging.pack({
+                source: this.sourcePath,
+                target: targetPath,
+                ignoreStrategy: this.ignoreStrategy,
+            });
+            return;
+        }
+        // `OUTPUT` hashing already built the artifact in the constructor; package
+        // that exact result and clean up its scratch, rather than building twice.
+        if (this.eagerBuild) {
+            const { scratch, produced } = this.eagerBuild;
+            this.eagerBuild = undefined;
+            try {
+                this.packBundlerOutput(produced, targetPath);
+            }
+            finally {
+                this.cleanupScratch(scratch);
+            }
+            return;
+        }
+        // `SOURCE` hashing defers the build to here.
+        const scratch = fs.mkdtempSync(path.join(os.tmpdir(), "cdktn-bundle-"));
+        try {
+            const { produced } = this.runBundle(scratch);
+            this.packBundlerOutput(produced, targetPath);
+        }
+        finally {
+            this.cleanupScratch(scratch);
+        }
+    }
+    /**
+     * Remove a bundler scratch directory and drop it from the exit-sweep set.
+     */
+    cleanupScratch(scratch) {
+        fs.rmSync(scratch, { recursive: true, force: true });
+        strandedScratchDirs.delete(scratch);
+    }
+    /**
+     * Package a bundler's output into `targetPath`, verbatim.
+     *
+     * The output's shape was already validated against the packaging in
+     * {@link runBundle}, so the packaging handles the source directly — a file
+     * source for AssetType.FILE, a directory source otherwise.
+     *
+     * The ignore strategy is deliberately not applied. `exclude` filters the
+     * source a bundler reads, not its product: an install-style bundler
+     * (`npm install --production`, `pip install -t`) writes exactly the
+     * dependency directory a user excludes from source, and re-applying the
+     * exclusion would ship an artifact missing those dependencies.
+     */
+    packBundlerOutput(produced, targetPath) {
+        this.packaging.pack({
+            source: produced,
+            target: targetPath,
+        });
+    }
+}
+exports.AssetStaging = AssetStaging;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"asset-staging.js","sourceRoot":"","sources":["../src/asset-staging.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright (c) HashiCorp, Inc\n// SPDX-License-Identifier: MPL-2.0\nimport { Construct, IConstruct } from \"constructs\";\nimport * as crypto from \"crypto\";\nimport * as fs from \"fs\";\nimport * as os from \"os\";\nimport * as path from \"path\";\nimport {\n  AssetHashType,\n  AssetOptions,\n  BundleOutputType,\n  IAsset,\n  IAssetBundler,\n  IAssetPackaging,\n} from \"./assets\";\nimport {\n  assetHashConflictingHashType,\n  assetHashInvalid,\n  assetHashTypeCustomRequiresHash,\n  assetHashTypeUnknown,\n  assetStagingAlreadyStaged,\n  assetStagingBundlerDirectoryOutputNeedsDirectoryPackaging,\n  assetStagingBundlerFileOutputNeedsFilePackaging,\n  assetStagingBundlerOutputNotDirectory,\n  assetStagingBundlerOutputNotFile,\n  assetStagingConflictingExcludeOptions,\n} from \"./errors\";\nimport { CANONICAL_ASSET_HASHES } from \"./features\";\nimport { ExcludeIgnoreStrategy, IIgnoreStrategy } from \"./ignore-strategy\";\nimport { copySync, hashPath } from \"./private/fs\";\n\n// A resolved hash is used verbatim as a path segment (see `TerraformAsset.path`),\n// so it may only contain characters that are always safe there.\nconst SAFE_ASSET_HASH = /^[A-Za-z0-9_.-]+$/;\n\n/**\n * Context key for a value folded into every computed asset hash in the\n * construct tree, alongside `extraHash`. A bulk cache-busting escape hatch —\n * `extraHash` is scoped to one asset, this is scoped to the whole app.\n */\nexport const ASSET_HASH_SALT_CONTEXT_KEY = \"cdktn:assetHashSalt\";\n\n/**\n * Caches the base (pre `extraHash`/salt) hash of a `SOURCE`/`OUTPUT` walk,\n * so that multiple `AssetStaging` instances with identical inputs — the same\n * asset referenced from more than one resource or stack — hash the source\n * tree once per synth instead of once per reference.\n *\n * Keyed per construct-tree root (the `App`) rather than at module scope: an\n * App instance lives exactly as long as one synth, so a long-running process\n * that synths repeatedly against changing files (e.g. `cdktn watch`) always\n * gets a fresh cache instead of a stale hash from a previous synth.\n */\nconst hashCachesByRoot = new WeakMap<IConstruct, Map<string, string>>();\n\n/**\n * The hash cache scoped to a construct-tree root, created on first use.\n *\n * See {@link hashCachesByRoot} for why the cache is scoped per root.\n */\nfunction hashCacheFor(root: IConstruct): Map<string, string> {\n  let cache = hashCachesByRoot.get(root);\n  if (!cache) {\n    cache = new Map();\n    hashCachesByRoot.set(root, cache);\n  }\n  return cache;\n}\n\n/**\n * Eager-build scratch directories awaiting cleanup, swept on process exit or\n * an interrupting signal.\n *\n * An `OUTPUT`-hash build runs in the constructor but is normally torn down in\n * `stage()`. When the asset's stack is not synthesized this pass, `stage()`\n * never runs, so the sweep reclaims what can be large trees (`node_modules`,\n * build caches) that `os.tmpdir()` does not clear reliably.\n */\nconst strandedScratchDirs = new Set<string>();\nlet exitSweepInstalled = false;\n\n/**\n * Synchronously remove every still-registered scratch directory.\n */\nfunction sweepStrandedScratch(): void {\n  for (const stray of strandedScratchDirs) {\n    try {\n      fs.rmSync(stray, { recursive: true, force: true });\n    } catch {\n      // Best-effort on the way out; nothing useful to do if it fails.\n    }\n  }\n  strandedScratchDirs.clear();\n}\n\n/**\n * Track a scratch directory for removal if it survives to process exit.\n *\n * `exit` alone misses a Ctrl-C or a `kill` during synth — exactly when the\n * largest trees (`node_modules`, build caches) are left behind — because Node\n * does not run `exit` handlers on `SIGINT`/`SIGTERM`. The signal handlers\n * sweep, then re-raise the signal so any other listeners (the CLI's own) still\n * run, or the default disposition terminates the process if there are none.\n */\nfunction registerStrandedScratch(dir: string): void {\n  strandedScratchDirs.add(dir);\n  if (!exitSweepInstalled) {\n    exitSweepInstalled = true;\n    // `exit` handlers must be synchronous; `rmSync` is.\n    process.once(\"exit\", sweepStrandedScratch);\n    for (const signal of [\"SIGINT\", \"SIGTERM\"] as const) {\n      process.once(signal, () => {\n        sweepStrandedScratch();\n        // Re-raise so the signal is not swallowed. `process.once` has already\n        // removed this listener, so the re-raise reaches whatever else is\n        // registered — the CLI's own SIGINT/SIGTERM handlers — or, if nothing\n        // is, the default disposition that terminates the process. Removing\n        // other listeners here would discard exactly those the app relies on.\n        process.kill(process.pid, signal);\n      });\n    }\n  }\n}\n\n/**\n * Options for {@link AssetStaging}.\n */\nexport interface AssetStagingOptions extends AssetOptions {\n  /**\n   * Absolute path to the source file or directory. Resolving a relative path\n   * against `cdktf.json` is the caller's responsibility.\n   */\n  readonly sourcePath: string;\n\n  /**\n   * How the staged result is produced and shaped. The caller decides this\n   * (e.g. from its own `AssetType`) — `AssetStaging` never infers or changes\n   * it based on `exclude`/`extraHash`.\n   */\n  readonly packaging: IAssetPackaging;\n\n  /**\n   * Paths to exclude, relative to `sourcePath`. Cannot be combined with\n   * `ignoreStrategy`, which replaces this matcher rather than layering on\n   * top of it.\n   *\n   * @default - nothing is excluded\n   */\n  readonly exclude?: string[];\n\n  /**\n   * Exclusion matching, for callers that need `.gitignore` / `.dockerignore`\n   * parity rather than the built-in exact-path / suffix / directory matcher.\n   *\n   * @default - `exclude` is used with the built-in matcher\n   */\n  readonly ignoreStrategy?: IIgnoreStrategy;\n\n  /**\n   * Extra information to fold into the hash (e.g. build instructions and\n   * other inputs).\n   *\n   * @default - no extra hash\n   */\n  readonly extraHash?: string;\n\n  /**\n   * A bundler that builds the source into an artifact before staging.\n   *\n   * Under the default `SOURCE` hashing the build is deferred to `stage()` and\n   * stays skippable; `OUTPUT` hashing builds eagerly at construction time to\n   * hash the artifact, forgoing skippability. The bundler's declared output\n   * shape must match the packaging: a `BundleResult.directory` needs a\n   * directory-accepting packaging, a `BundleResult.file` a single-file one\n   * (`AssetType.FILE`). The mismatch is caught once the build runs.\n   *\n   * @default - the source is staged verbatim, with no build step\n   */\n  readonly bundler?: IAssetBundler;\n\n  /**\n   * Identifier used in error messages, so they name the user-facing construct\n   * (e.g. the `TerraformAsset`) rather than this internal staging child.\n   *\n   * @default - the staging construct's own id\n   */\n  readonly displayName?: string;\n}\n\n/**\n * Resolves an asset's identity and stages its content to disk.\n *\n * The hash is available immediately after construction; the filesystem write\n * is deferred to `stage()`, the one window where it is safe. Hashing is\n * cached per synth (see {@link hashCachesByRoot}) so an asset referenced from\n * several places is walked once. Without a bundler, `SOURCE` and `OUTPUT` both\n * hash the source; with one they diverge, as `AssetStagingOptions.bundler`\n * describes.\n */\nexport class AssetStaging extends Construct implements IAsset {\n  private readonly sourcePath: string;\n  private readonly displayName: string;\n  private readonly ignoreStrategy: IIgnoreStrategy;\n  private readonly hasExclusions: boolean;\n  private readonly hashCache: Map<string, string>;\n  private readonly bundler?: IAssetBundler;\n\n  /**\n   * Output of an eager `OUTPUT`-hash build, carried to `stage()` for reuse.\n   *\n   * Undefined on every other path, where the build is deferred or absent.\n   */\n  private eagerBuild?: {\n    readonly scratch: string;\n    readonly produced: string;\n    readonly outputType: BundleOutputType;\n  };\n\n  /**\n   * Set once `stage()` has run, so a second call cannot rebuild. An eager\n   * `OUTPUT` build is captured at construction and consumed by the first\n   * `stage()`; without this guard a second call would fall through to the\n   * deferred build path and stage bytes that no longer match the hash.\n   */\n  private staged = false;\n\n  public readonly packaging: IAssetPackaging;\n  public readonly isDirectory: boolean;\n  public readonly assetHash: string;\n\n  public constructor(scope: Construct, id: string, props: AssetStagingOptions) {\n    super(scope, id);\n\n    this.sourcePath = props.sourcePath;\n    this.displayName = props.displayName ?? id;\n    this.packaging = props.packaging;\n    this.isDirectory = props.packaging.producesDirectory;\n    this.hashCache = hashCacheFor(this.node.root);\n    this.bundler = props.bundler;\n\n    if (props.exclude?.length && props.ignoreStrategy) {\n      throw assetStagingConflictingExcludeOptions(this.displayName);\n    }\n    this.ignoreStrategy =\n      props.ignoreStrategy ?? new ExcludeIgnoreStrategy(props.exclude ?? []);\n    // A custom strategy is assumed to exclude something; the built-in one only\n    // does with a non-empty `exclude`. Drives whether the bundler is handed a\n    // materialised filtered copy or the source directly.\n    this.hasExclusions =\n      props.ignoreStrategy !== undefined || !!props.exclude?.length;\n\n    // Bundler output shape (directory vs file) is only known once `bundle`\n    // runs, so its compatibility with the packaging is checked then, not here\n    // — a deferred SOURCE build has not run yet at construction time.\n\n    this.assetHash = this.resolveAssetHash(this.displayName, props);\n  }\n\n  private resolveAssetHash(id: string, props: AssetStagingOptions): string {\n    const { assetHash, assetHashType, extraHash } = props;\n\n    if (assetHash !== undefined) {\n      if (\n        assetHashType !== undefined &&\n        assetHashType !== AssetHashType.CUSTOM\n      ) {\n        throw assetHashConflictingHashType(id);\n      }\n      if (!SAFE_ASSET_HASH.test(assetHash)) {\n        throw assetHashInvalid(id, assetHash);\n      }\n      return assetHash;\n    }\n\n    switch (assetHashType) {\n      case AssetHashType.CUSTOM:\n        throw assetHashTypeCustomRequiresHash(id);\n      case AssetHashType.SOURCE:\n      case AssetHashType.OUTPUT:\n      case undefined: {\n        const canonical = !!this.node.tryGetContext(CANONICAL_ASSET_HASHES);\n        const archive = this.packaging.omitsDirectoryEntries;\n        const salt = this.node.tryGetContext(ASSET_HASH_SALT_CONTEXT_KEY);\n\n        // OUTPUT hashes the built artifact and so must build eagerly, forgoing\n        // skippability (#380); every other case hashes the source verbatim.\n        const baseHash =\n          this.bundler && assetHashType === AssetHashType.OUTPUT\n            ? this.hashOutput(canonical, archive)\n            : this.hashSource(canonical, archive);\n\n        // For SOURCE, folding in bundlerKey is the only way build identity\n        // reaches the hash, since the source tree cannot see the build.\n        const bundlerKey = this.bundler?.bundlerKey;\n        if (!extraHash && !salt && !bundlerKey) {\n          return baseHash;\n        }\n        const folded = crypto.createHash(\"md5\").update(baseHash);\n        if (extraHash) {\n          folded.update(extraHash);\n        }\n        if (bundlerKey) {\n          folded.update(bundlerKey);\n        }\n        if (salt) {\n          folded.update(String(salt));\n        }\n        return folded.digest(\"hex\").slice(0, 32).toUpperCase();\n      }\n      default:\n        // Out-of-range value from a non-TypeScript caller.\n        throw assetHashTypeUnknown(id, assetHashType);\n    }\n  }\n\n  /**\n   * Hash the source tree, honoring the ignore strategy.\n   *\n   * Cached per synth so an asset referenced more than once is walked once.\n   */\n  private hashSource(canonical: boolean, archive: boolean): string {\n    // Only cacheable when the ignore strategy can summarize its behavior\n    // as a string (see `IIgnoreStrategy.cacheKey`); otherwise every call\n    // is treated as unique.\n    const cacheKey =\n      this.ignoreStrategy.cacheKey !== undefined\n        ? JSON.stringify({\n            sourcePath: this.sourcePath,\n            canonical,\n            archive,\n            ignore: this.ignoreStrategy.cacheKey,\n          })\n        : undefined;\n\n    const cached = cacheKey ? this.hashCache.get(cacheKey) : undefined;\n    if (cached !== undefined) {\n      return cached;\n    }\n\n    const hash = hashPath(this.sourcePath, {\n      canonical,\n      archive,\n      shouldExclude: (relativePath, isDirectory) =>\n        this.ignoreStrategy.ignores({ relativePath, isDirectory }),\n      descendIntoExcludedDirectories:\n        this.ignoreStrategy.pruneExcludedDirectories === false,\n    });\n    if (cacheKey) {\n      this.hashCache.set(cacheKey, hash);\n    }\n    return hash;\n  }\n\n  /**\n   * Build the bundler's output eagerly and hash the built artifact.\n   *\n   * The output is stashed for `stage()` to reuse, so the build is not\n   * repeated. It is hashed verbatim: `exclude` filters the source a bundler\n   * reads, not the artifact it produces.\n   */\n  private hashOutput(canonical: boolean, archive: boolean): string {\n    const scratch = fs.mkdtempSync(path.join(os.tmpdir(), \"cdktn-bundle-\"));\n    // Registered so the exit sweep reclaims it if stage() never runs for an\n    // unsynthesized stack; stage() removes and unregisters it otherwise.\n    registerStrandedScratch(scratch);\n    try {\n      const { produced, outputType } = this.runBundle(scratch);\n      this.eagerBuild = { scratch, produced, outputType };\n      // A single-file artifact is hashed as a file (no archive framing); a\n      // directory is hashed as the packaged tree would be.\n      const isFile = outputType === BundleOutputType.FILE;\n      return hashPath(produced, { canonical, archive: archive && !isFile });\n    } catch (e) {\n      // The build failed before `eagerBuild` was set, so stage() can never\n      // reach this scratch to clean it. Reclaim it now rather than leaving a\n      // potentially large tree (node_modules, build caches) to the exit sweep.\n      this.cleanupScratch(scratch);\n      throw e;\n    }\n  }\n\n  /**\n   * Run the bundler against the filtered source and return its output.\n   *\n   * The bundler is handed an absolute `source` (its cwd is its own, so a\n   * relative path would resolve elsewhere) that has already had `exclude`\n   * applied. Materialising the filtered input here is what makes the bundler\n   * read exactly the tree the hash was taken over, which a raw source\n   * hand-off would not, since `hashSource` honours `exclude`.\n   */\n  private runBundle(scratch: string): {\n    produced: string;\n    outputType: BundleOutputType;\n  } {\n    const outputDir = path.join(scratch, \"output\");\n    fs.mkdirSync(outputDir);\n    const result = this.bundler!.bundle({\n      source: this.filteredSource(scratch),\n      outputDir,\n    });\n\n    // A bare bundler that declines has nothing to fall back to — declining is\n    // only meaningful inside a ChainBundler, which consumes it before it\n    // reaches here. A non-declined result always carries a path and shape.\n    if (\n      result.isDeclined ||\n      result.path === undefined ||\n      result.outputType === undefined\n    ) {\n      throw assetStagingBundlerOutputNotDirectory(\n        this.displayName,\n        String(result.path),\n      );\n    }\n\n    const produced = result.path;\n    this.validateOutputShape(produced, result.outputType);\n    return { produced, outputType: result.outputType };\n  }\n\n  /**\n   * Reject a bundler result whose declared shape does not match what is on\n   * disk, or does not match the packaging.\n   *\n   * Catching the mismatch here turns an opaque EISDIR/EPERM at pack time into\n   * a clear error naming the packaging the bundler's output shape needs.\n   */\n  private validateOutputShape(\n    produced: string,\n    outputType: BundleOutputType,\n  ): void {\n    const exists = fs.existsSync(produced);\n    const stat = exists ? fs.statSync(produced) : undefined;\n\n    if (outputType === BundleOutputType.FILE) {\n      if (!stat?.isFile()) {\n        throw assetStagingBundlerOutputNotFile(this.displayName, produced);\n      }\n      if (!this.stagesSingleFile) {\n        throw assetStagingBundlerFileOutputNeedsFilePackaging(this.displayName);\n      }\n      return;\n    }\n\n    if (!stat?.isDirectory()) {\n      throw assetStagingBundlerOutputNotDirectory(this.displayName, produced);\n    }\n    if (!this.packaging.acceptsDirectorySource) {\n      throw assetStagingBundlerDirectoryOutputNeedsDirectoryPackaging(\n        this.displayName,\n      );\n    }\n  }\n\n  /**\n   * Whether the packaging stages a single file verbatim (AssetType.FILE).\n   *\n   * A verbatim-file packaging neither produces a directory nor reads one as\n   * its source. Derived from existing `IAssetPackaging` flags so out-of-tree\n   * packagings need no new interface member.\n   */\n  private get stagesSingleFile(): boolean {\n    return (\n      !this.packaging.producesDirectory &&\n      !this.packaging.acceptsDirectorySource\n    );\n  }\n\n  /**\n   * Absolute path to the source the bundler should read.\n   *\n   * With no exclusions, or with a file source, the resolved source is handed\n   * over directly — a file has no children to filter, matching `hashSource`,\n   * which only ever applies the ignore strategy to a directory's entries and\n   * never to the root itself. Otherwise the excluded source tree is\n   * materialised into the scratch directory, so the bundler sees the same\n   * file set the hash was taken over.\n   */\n  private filteredSource(scratch: string): string {\n    const absoluteSource = path.resolve(this.sourcePath);\n    if (!this.hasExclusions || fs.statSync(absoluteSource).isFile()) {\n      return absoluteSource;\n    }\n    const input = path.join(scratch, \"input\");\n    fs.mkdirSync(input);\n    copySync(absoluteSource, input, {\n      shouldExclude: (relativePath, isDirectory) =>\n        this.ignoreStrategy.ignores({ relativePath, isDirectory }),\n      descendIntoExcludedDirectories:\n        this.ignoreStrategy.pruneExcludedDirectories === false,\n    });\n    return input;\n  }\n\n  /**\n   * Stage the asset's content to `targetPath`.\n   *\n   * Called from the owning construct's `onSynthesize` hook. Without a bundler\n   * the source is packaged verbatim; with one, the bundler's output is, built\n   * eagerly for `OUTPUT` hashing or deferred to here for `SOURCE`.\n   */\n  public stage(targetPath: string): void {\n    // Stage exactly once: a rebuild could stage bytes not matching the\n    // already-computed hash (see the `staged` field).\n    if (this.staged) {\n      throw assetStagingAlreadyStaged(this.displayName);\n    }\n    this.staged = true;\n\n    if (!this.bundler) {\n      this.packaging.pack({\n        source: this.sourcePath,\n        target: targetPath,\n        ignoreStrategy: this.ignoreStrategy,\n      });\n      return;\n    }\n\n    // `OUTPUT` hashing already built the artifact in the constructor; package\n    // that exact result and clean up its scratch, rather than building twice.\n    if (this.eagerBuild) {\n      const { scratch, produced } = this.eagerBuild;\n      this.eagerBuild = undefined;\n      try {\n        this.packBundlerOutput(produced, targetPath);\n      } finally {\n        this.cleanupScratch(scratch);\n      }\n      return;\n    }\n\n    // `SOURCE` hashing defers the build to here.\n    const scratch = fs.mkdtempSync(path.join(os.tmpdir(), \"cdktn-bundle-\"));\n    try {\n      const { produced } = this.runBundle(scratch);\n      this.packBundlerOutput(produced, targetPath);\n    } finally {\n      this.cleanupScratch(scratch);\n    }\n  }\n\n  /**\n   * Remove a bundler scratch directory and drop it from the exit-sweep set.\n   */\n  private cleanupScratch(scratch: string): void {\n    fs.rmSync(scratch, { recursive: true, force: true });\n    strandedScratchDirs.delete(scratch);\n  }\n\n  /**\n   * Package a bundler's output into `targetPath`, verbatim.\n   *\n   * The output's shape was already validated against the packaging in\n   * {@link runBundle}, so the packaging handles the source directly — a file\n   * source for AssetType.FILE, a directory source otherwise.\n   *\n   * The ignore strategy is deliberately not applied. `exclude` filters the\n   * source a bundler reads, not its product: an install-style bundler\n   * (`npm install --production`, `pip install -t`) writes exactly the\n   * dependency directory a user excludes from source, and re-applying the\n   * exclusion would ship an artifact missing those dependencies.\n   */\n  private packBundlerOutput(produced: string, targetPath: string): void {\n    this.packaging.pack({\n      source: produced,\n      target: targetPath,\n    });\n  }\n}\n"]}