cdktn 0.25.0-pre.9 → 0.25.0

package/README.md

@@ -3,6 +3,18 @@
 cdktn is a framework for defining cloud infrastructure using Terraform providers and modules. It allows for
 users to define infrastructure resources using higher-level programming languages.
 
+CDK Terrain (CDKTN) is the community-maintained successor to CDK for Terraform (CDKTF). Migrating from CDKTF? Follow the [migration guide](https://cdktn.io/docs/release/upgrade-guide-v0-22).
+
+## Use with AI agents
+
+The CDKTN docs are served to AI coding agents by a hosted [MCP server](https://cdktn.io/docs/ai-agents) at `https://cdktn.io/docs/mcp` (streamable HTTP, no auth). Point your agent at it rather than relying on prior CDKTF knowledge:
+
+```bash
+claude mcp add --transport http cdktn https://cdktn.io/docs/mcp
+```
+
+An [agent skill](https://cdktn.io/docs/skill.md) and an [llms.txt index](https://cdktn.io/llms.txt) are also available.
+
 ## Build
 
 Install dependencies

package/lib/annotations.js

@@ -14,7 +14,7 @@ exports.DISABLE_STACK_TRACE_IN_METADATA = "@cdktf/disable_stack_trace_in_metadat
  */
 class Annotations {
     scope;
-    static [JSII_RTTI_SYMBOL_1] = { fqn: "cdktn.Annotations", version: "0.25.0-pre.9" };
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "cdktn.Annotations", version: "0.25.0" };
     /**
      * Returns the annotations API for a construct scope.
      * @param scope The scope

package/lib/app.js

@@ -51,7 +51,7 @@ exports.CONTEXT_ENV = "CDKTF_CONTEXT_JSON";
  * Represents a cdktn application.
  */
 class App extends constructs_1.Construct {
-    static [JSII_RTTI_SYMBOL_1] = { fqn: "cdktn.App", version: "0.25.0-pre.9" };
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "cdktn.App", version: "0.25.0" };
     /**
      * The output directory into which resources will be synthesized.
      */

package/lib/aspect.js

@@ -8,7 +8,7 @@ const ASPECTS_SYMBOL = Symbol("cdktf-aspects");
  * synthesis.
  */
 class Aspects {
-    static [JSII_RTTI_SYMBOL_1] = { fqn: "cdktn.Aspects", version: "0.25.0-pre.9" };
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "cdktn.Aspects", version: "0.25.0" };
     /**
      * Returns the `Aspects` object associated with a construct scope.
      * @param scope The scope for which these aspects will apply.

package/lib/asset-hash.d.ts

@@ -0,0 +1,75 @@
+import { IIgnoreStrategy } from "./ignore-strategy";
+/**
+ * Options for {@link AssetHash.of}.
+ */
+export interface AssetHashOptions {
+    /**
+     * Paths to exclude, relative to the hashed path. Cannot be combined with
+     * `ignoreStrategy`, which replaces this matcher rather than layering on
+     * top of it.
+     *
+     * @default - nothing is excluded
+     */
+    readonly exclude?: string[];
+    /**
+     * Extra information to fold into the hash.
+     *
+     * @default - no extra data
+     */
+    readonly extraHash?: string;
+    /**
+     * Exclusion matching, for callers that need `.gitignore` / `.dockerignore`
+     * parity rather than the built-in exact-path / suffix / directory matcher.
+     *
+     * @default - `exclude` is used with the built-in matcher
+     */
+    readonly ignoreStrategy?: IIgnoreStrategy;
+}
+/**
+ * Computes a content hash of a file or directory without staging it.
+ *
+ * Providers that read a local path directly — a Docker build `context`, for
+ * example — need a content hash to drive `triggers`, but have no use for a
+ * staged copy of the source. `Asset` and `TerraformAsset` always produce a
+ * staged copy; this is the identity half without the staging half.
+ */
+export declare class AssetHash {
+    /**
+     * Content hash of a file or directory, without staging it.
+     *
+     * This is a hash of the source tree, and it does not depend on how the
+     * source is later packaged. `hashPath` is always called with `archive`
+     * unset, so directory records are part of the digest; the hash of a given
+     * tree is therefore the same whether it is later copied, zipped, or packed
+     * by a custom `IAssetPackaging` such as `tar.bz2`.
+     *
+     * A consequence worth stating: this does not equal
+     * `TerraformAsset(dir, { type: ARCHIVE }).assetHash` for a directory with
+     * subdirectories. That asset frames its hash to the emitted ZIP, which has
+     * no directory entries (see #323), so directory-only changes move it and
+     * not this. It equals a `FILE` / `DIRECTORY` `TerraformAsset` hash only
+     * when the `canonicalAssetHashes` flag is enabled, since that flag is what
+     * puts the asset on this same canonical scheme.
+     *
+     * A relative `filePath` is resolved against the directory containing
+     * `cdktf.json`, the same base `TerraformAsset` uses, so both hash the same
+     * source regardless of the process working directory. Absolute paths are
+     * used as-is. Throws if `filePath` is relative and no `cdktf.json` is found
+     * above the working directory.
+     * @param filePath - path to a file or directory to hash
+     * @param options - see {@link AssetHashOptions}
+     */
+    static of(filePath: string, options?: AssetHashOptions): string;
+    /**
+     * Resolve `filePath` to an absolute path using the same base as
+     * `TerraformAsset`: relative paths are anchored to the directory holding
+     * `cdktf.json`, not `process.cwd()`, so a hash taken here matches the one
+     * `TerraformAsset` computes for the same source even when the app is run
+     * from a subdirectory or a test runner. Unlike `TerraformAsset`, there is
+     * no construct scope to read the `cdktfJsonPath` context from, so this uses
+     * the `findFileAboveCwd` fallback directly.
+     * @param filePath - path passed to {@link AssetHash.of}
+     */
+    private static resolvePath;
+    private constructor();
+}

package/lib/asset-hash.js

@@ -0,0 +1,129 @@
+"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.AssetHash = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+// Copyright (c) HashiCorp, Inc
+// SPDX-License-Identifier: MPL-2.0
+const crypto = __importStar(require("crypto"));
+const path = __importStar(require("path"));
+const fs_1 = require("./private/fs");
+const ignore_strategy_1 = require("./ignore-strategy");
+const errors_1 = require("./errors");
+/**
+ * Computes a content hash of a file or directory without staging it.
+ *
+ * Providers that read a local path directly — a Docker build `context`, for
+ * example — need a content hash to drive `triggers`, but have no use for a
+ * staged copy of the source. `Asset` and `TerraformAsset` always produce a
+ * staged copy; this is the identity half without the staging half.
+ */
+class AssetHash {
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "cdktn.AssetHash", version: "0.25.0" };
+    /**
+     * Content hash of a file or directory, without staging it.
+     *
+     * This is a hash of the source tree, and it does not depend on how the
+     * source is later packaged. `hashPath` is always called with `archive`
+     * unset, so directory records are part of the digest; the hash of a given
+     * tree is therefore the same whether it is later copied, zipped, or packed
+     * by a custom `IAssetPackaging` such as `tar.bz2`.
+     *
+     * A consequence worth stating: this does not equal
+     * `TerraformAsset(dir, { type: ARCHIVE }).assetHash` for a directory with
+     * subdirectories. That asset frames its hash to the emitted ZIP, which has
+     * no directory entries (see #323), so directory-only changes move it and
+     * not this. It equals a `FILE` / `DIRECTORY` `TerraformAsset` hash only
+     * when the `canonicalAssetHashes` flag is enabled, since that flag is what
+     * puts the asset on this same canonical scheme.
+     *
+     * A relative `filePath` is resolved against the directory containing
+     * `cdktf.json`, the same base `TerraformAsset` uses, so both hash the same
+     * source regardless of the process working directory. Absolute paths are
+     * used as-is. Throws if `filePath` is relative and no `cdktf.json` is found
+     * above the working directory.
+     * @param filePath - path to a file or directory to hash
+     * @param options - see {@link AssetHashOptions}
+     */
+    static of(filePath, options = {}) {
+        if (options.exclude?.length && options.ignoreStrategy) {
+            throw (0, errors_1.assetHashConflictingExcludeOptions)();
+        }
+        const resolved = AssetHash.resolvePath(filePath);
+        const strategy = options.ignoreStrategy ??
+            new ignore_strategy_1.ExcludeIgnoreStrategy(options.exclude ?? []);
+        // Pinned to the canonical scheme: this is a brand-new API with no
+        // existing hashes to preserve, so it has no reason to start on the
+        // legacy scheme that `canonicalAssetHashes` exists to move away from.
+        const baseHash = (0, fs_1.hashPath)(resolved, {
+            canonical: true,
+            shouldExclude: (relativePath, isDirectory) => strategy.ignores({ relativePath, isDirectory }),
+            descendIntoExcludedDirectories: strategy.pruneExcludedDirectories === false,
+        });
+        if (!options.extraHash) {
+            return baseHash;
+        }
+        return crypto
+            .createHash("md5")
+            .update(baseHash)
+            .update(options.extraHash)
+            .digest("hex")
+            .slice(0, 32)
+            .toUpperCase();
+    }
+    /**
+     * Resolve `filePath` to an absolute path using the same base as
+     * `TerraformAsset`: relative paths are anchored to the directory holding
+     * `cdktf.json`, not `process.cwd()`, so a hash taken here matches the one
+     * `TerraformAsset` computes for the same source even when the app is run
+     * from a subdirectory or a test runner. Unlike `TerraformAsset`, there is
+     * no construct scope to read the `cdktfJsonPath` context from, so this uses
+     * the `findFileAboveCwd` fallback directly.
+     * @param filePath - path passed to {@link AssetHash.of}
+     */
+    static resolvePath(filePath) {
+        if (path.isAbsolute(filePath)) {
+            return filePath;
+        }
+        const cdktfJsonPath = (0, fs_1.findFileAboveCwd)("cdktf.json");
+        if (!cdktfJsonPath) {
+            throw (0, errors_1.assetHashOutOfScopeCdktnJson)(filePath);
+        }
+        return path.resolve(path.dirname(cdktfJsonPath), filePath);
+    }
+    constructor() { }
+}
+exports.AssetHash = AssetHash;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"asset-hash.js","sourceRoot":"","sources":["../src/asset-hash.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,+BAA+B;AAC/B,mCAAmC;AACnC,+CAAiC;AACjC,2CAA6B;AAC7B,qCAA0D;AAC1D,uDAA2E;AAC3E,qCAGkB;AA+BlB;;;;;;;GAOG;AACH,MAAa,SAAS;;IACpB;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACI,MAAM,CAAC,EAAE,CAAC,QAAgB,EAAE,UAA4B,EAAE;QAC/D,IAAI,OAAO,CAAC,OAAO,EAAE,MAAM,IAAI,OAAO,CAAC,cAAc,EAAE,CAAC;YACtD,MAAM,IAAA,2CAAkC,GAAE,CAAC;QAC7C,CAAC;QAED,MAAM,QAAQ,GAAG,SAAS,CAAC,WAAW,CAAC,QAAQ,CAAC,CAAC;QACjD,MAAM,QAAQ,GACZ,OAAO,CAAC,cAAc;YACtB,IAAI,uCAAqB,CAAC,OAAO,CAAC,OAAO,IAAI,EAAE,CAAC,CAAC;QAEnD,kEAAkE;QAClE,mEAAmE;QACnE,sEAAsE;QACtE,MAAM,QAAQ,GAAG,IAAA,aAAQ,EAAC,QAAQ,EAAE;YAClC,SAAS,EAAE,IAAI;YACf,aAAa,EAAE,CAAC,YAAY,EAAE,WAAW,EAAE,EAAE,CAC3C,QAAQ,CAAC,OAAO,CAAC,EAAE,YAAY,EAAE,WAAW,EAAE,CAAC;YACjD,8BAA8B,EAC5B,QAAQ,CAAC,wBAAwB,KAAK,KAAK;SAC9C,CAAC,CAAC;QAEH,IAAI,CAAC,OAAO,CAAC,SAAS,EAAE,CAAC;YACvB,OAAO,QAAQ,CAAC;QAClB,CAAC;QAED,OAAO,MAAM;aACV,UAAU,CAAC,KAAK,CAAC;aACjB,MAAM,CAAC,QAAQ,CAAC;aAChB,MAAM,CAAC,OAAO,CAAC,SAAS,CAAC;aACzB,MAAM,CAAC,KAAK,CAAC;aACb,KAAK,CAAC,CAAC,EAAE,EAAE,CAAC;aACZ,WAAW,EAAE,CAAC;IACnB,CAAC;IAED;;;;;;;;;OASG;IACK,MAAM,CAAC,WAAW,CAAC,QAAgB;QACzC,IAAI,IAAI,CAAC,UAAU,CAAC,QAAQ,CAAC,EAAE,CAAC;YAC9B,OAAO,QAAQ,CAAC;QAClB,CAAC;QACD,MAAM,aAAa,GAAG,IAAA,qBAAgB,EAAC,YAAY,CAAC,CAAC;QACrD,IAAI,CAAC,aAAa,EAAE,CAAC;YACnB,MAAM,IAAA,qCAA4B,EAAC,QAAQ,CAAC,CAAC;QAC/C,CAAC;QACD,OAAO,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,OAAO,CAAC,aAAa,CAAC,EAAE,QAAQ,CAAC,CAAC;IAC7D,CAAC;IAED,gBAAuB,CAAC;;AAjF1B,8BAkFC","sourcesContent":["// Copyright (c) HashiCorp, Inc\n// SPDX-License-Identifier: MPL-2.0\nimport * as crypto from \"crypto\";\nimport * as path from \"path\";\nimport { hashPath, findFileAboveCwd } from \"./private/fs\";\nimport { ExcludeIgnoreStrategy, IIgnoreStrategy } from \"./ignore-strategy\";\nimport {\n  assetHashConflictingExcludeOptions,\n  assetHashOutOfScopeCdktnJson,\n} from \"./errors\";\n\n/**\n * Options for {@link AssetHash.of}.\n */\nexport interface AssetHashOptions {\n  /**\n   * Paths to exclude, relative to the hashed path. 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   * Extra information to fold into the hash.\n   *\n   * @default - no extra data\n   */\n  readonly extraHash?: 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/**\n * Computes a content hash of a file or directory without staging it.\n *\n * Providers that read a local path directly — a Docker build `context`, for\n * example — need a content hash to drive `triggers`, but have no use for a\n * staged copy of the source. `Asset` and `TerraformAsset` always produce a\n * staged copy; this is the identity half without the staging half.\n */\nexport class AssetHash {\n  /**\n   * Content hash of a file or directory, without staging it.\n   *\n   * This is a hash of the source tree, and it does not depend on how the\n   * source is later packaged. `hashPath` is always called with `archive`\n   * unset, so directory records are part of the digest; the hash of a given\n   * tree is therefore the same whether it is later copied, zipped, or packed\n   * by a custom `IAssetPackaging` such as `tar.bz2`.\n   *\n   * A consequence worth stating: this does not equal\n   * `TerraformAsset(dir, { type: ARCHIVE }).assetHash` for a directory with\n   * subdirectories. That asset frames its hash to the emitted ZIP, which has\n   * no directory entries (see #323), so directory-only changes move it and\n   * not this. It equals a `FILE` / `DIRECTORY` `TerraformAsset` hash only\n   * when the `canonicalAssetHashes` flag is enabled, since that flag is what\n   * puts the asset on this same canonical scheme.\n   *\n   * A relative `filePath` is resolved against the directory containing\n   * `cdktf.json`, the same base `TerraformAsset` uses, so both hash the same\n   * source regardless of the process working directory. Absolute paths are\n   * used as-is. Throws if `filePath` is relative and no `cdktf.json` is found\n   * above the working directory.\n   * @param filePath - path to a file or directory to hash\n   * @param options - see {@link AssetHashOptions}\n   */\n  public static of(filePath: string, options: AssetHashOptions = {}): string {\n    if (options.exclude?.length && options.ignoreStrategy) {\n      throw assetHashConflictingExcludeOptions();\n    }\n\n    const resolved = AssetHash.resolvePath(filePath);\n    const strategy =\n      options.ignoreStrategy ??\n      new ExcludeIgnoreStrategy(options.exclude ?? []);\n\n    // Pinned to the canonical scheme: this is a brand-new API with no\n    // existing hashes to preserve, so it has no reason to start on the\n    // legacy scheme that `canonicalAssetHashes` exists to move away from.\n    const baseHash = hashPath(resolved, {\n      canonical: true,\n      shouldExclude: (relativePath, isDirectory) =>\n        strategy.ignores({ relativePath, isDirectory }),\n      descendIntoExcludedDirectories:\n        strategy.pruneExcludedDirectories === false,\n    });\n\n    if (!options.extraHash) {\n      return baseHash;\n    }\n\n    return crypto\n      .createHash(\"md5\")\n      .update(baseHash)\n      .update(options.extraHash)\n      .digest(\"hex\")\n      .slice(0, 32)\n      .toUpperCase();\n  }\n\n  /**\n   * Resolve `filePath` to an absolute path using the same base as\n   * `TerraformAsset`: relative paths are anchored to the directory holding\n   * `cdktf.json`, not `process.cwd()`, so a hash taken here matches the one\n   * `TerraformAsset` computes for the same source even when the app is run\n   * from a subdirectory or a test runner. Unlike `TerraformAsset`, there is\n   * no construct scope to read the `cdktfJsonPath` context from, so this uses\n   * the `findFileAboveCwd` fallback directly.\n   * @param filePath - path passed to {@link AssetHash.of}\n   */\n  private static resolvePath(filePath: string): string {\n    if (path.isAbsolute(filePath)) {\n      return filePath;\n    }\n    const cdktfJsonPath = findFileAboveCwd(\"cdktf.json\");\n    if (!cdktfJsonPath) {\n      throw assetHashOutOfScopeCdktnJson(filePath);\n    }\n    return path.resolve(path.dirname(cdktfJsonPath), filePath);\n  }\n\n  private constructor() {}\n}\n"]}

package/lib/asset-staging.d.ts

@@ -0,0 +1,180 @@
+import { Construct } from "constructs";
+import { AssetOptions, IAsset, IAssetBundler, IAssetPackaging } from "./assets";
+import { IIgnoreStrategy } from "./ignore-strategy";
+/**
+ * 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.
+ */
+export declare const ASSET_HASH_SALT_CONTEXT_KEY = "cdktn:assetHashSalt";
+/**
+ * Options for {@link AssetStaging}.
+ */
+export interface AssetStagingOptions extends AssetOptions {
+    /**
+     * Absolute path to the source file or directory. Resolving a relative path
+     * against `cdktf.json` is the caller's responsibility.
+     */
+    readonly sourcePath: string;
+    /**
+     * How the staged result is produced and shaped. The caller decides this
+     * (e.g. from its own `AssetType`) — `AssetStaging` never infers or changes
+     * it based on `exclude`/`extraHash`.
+     */
+    readonly packaging: IAssetPackaging;
+    /**
+     * Paths to exclude, relative to `sourcePath`. Cannot be combined with
+     * `ignoreStrategy`, which replaces this matcher rather than layering on
+     * top of it.
+     *
+     * @default - nothing is excluded
+     */
+    readonly exclude?: string[];
+    /**
+     * Exclusion matching, for callers that need `.gitignore` / `.dockerignore`
+     * parity rather than the built-in exact-path / suffix / directory matcher.
+     *
+     * @default - `exclude` is used with the built-in matcher
+     */
+    readonly ignoreStrategy?: IIgnoreStrategy;
+    /**
+     * Extra information to fold into the hash (e.g. build instructions and
+     * other inputs).
+     *
+     * @default - no extra hash
+     */
+    readonly extraHash?: string;
+    /**
+     * A bundler that builds the source into an artifact before staging.
+     *
+     * Under the default `SOURCE` hashing the build is deferred to `stage()` and
+     * stays skippable; `OUTPUT` hashing builds eagerly at construction time to
+     * hash the artifact, forgoing skippability. The bundler's declared output
+     * shape must match the packaging: a `BundleResult.directory` needs a
+     * directory-accepting packaging, a `BundleResult.file` a single-file one
+     * (`AssetType.FILE`). The mismatch is caught once the build runs.
+     *
+     * @default - the source is staged verbatim, with no build step
+     */
+    readonly bundler?: IAssetBundler;
+    /**
+     * Identifier used in error messages, so they name the user-facing construct
+     * (e.g. the `TerraformAsset`) rather than this internal staging child.
+     *
+     * @default - the staging construct's own id
+     */
+    readonly displayName?: string;
+}
+/**
+ * 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.
+ */
+export declare class AssetStaging extends Construct implements IAsset {
+    private readonly sourcePath;
+    private readonly displayName;
+    private readonly ignoreStrategy;
+    private readonly hasExclusions;
+    private readonly hashCache;
+    private readonly 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.
+     */
+    private 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.
+     */
+    private staged;
+    readonly packaging: IAssetPackaging;
+    readonly isDirectory: boolean;
+    readonly assetHash: string;
+    constructor(scope: Construct, id: string, props: AssetStagingOptions);
+    private resolveAssetHash;
+    /**
+     * Hash the source tree, honoring the ignore strategy.
+     *
+     * Cached per synth so an asset referenced more than once is walked once.
+     */
+    private hashSource;
+    /**
+     * 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.
+     */
+    private hashOutput;
+    /**
+     * 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`.
+     */
+    private runBundle;
+    /**
+     * 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.
+     */
+    private validateOutputShape;
+    /**
+     * 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.
+     */
+    private get stagesSingleFile();
+    /**
+     * 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.
+     */
+    private filteredSource;
+    /**
+     * 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: string): void;
+    /**
+     * Remove a bundler scratch directory and drop it from the exit-sweep set.
+     */
+    private cleanupScratch;
+    /**
+     * 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.
+     */
+    private packBundlerOutput;
+}