@cdktn/bundler-local 0.0.0 → 0.1.0

package/.jsii

@@ -0,0 +1,346 @@
+{
+  "author": {
+    "name": "cdktn-io",
+    "organization": true,
+    "roles": [
+      "author"
+    ],
+    "url": "https://cdktn.io"
+  },
+  "dependencies": {
+    "cdktn": "^0.25.0",
+    "constructs": "^10.6.0"
+  },
+  "dependencyClosure": {
+    "cdktn": {
+      "submodules": {
+        "cdktn.testingMatchers": {}
+      },
+      "targets": {
+        "dotnet": {
+          "namespace": "Io.Cdktn",
+          "packageId": "Io.Cdktn"
+        },
+        "go": {
+          "moduleName": "github.com/open-constructs/cdk-terrain-go",
+          "packageName": "cdktn"
+        },
+        "java": {
+          "maven": {
+            "artifactId": "cdktn",
+            "groupId": "io.cdktn"
+          },
+          "package": "io.cdktn.cdktn"
+        },
+        "js": {
+          "npm": "cdktn"
+        },
+        "python": {
+          "distName": "cdktn",
+          "module": "cdktn"
+        }
+      }
+    },
+    "constructs": {
+      "targets": {
+        "dotnet": {
+          "namespace": "Constructs",
+          "packageId": "Constructs"
+        },
+        "go": {
+          "moduleName": "github.com/aws/constructs-go"
+        },
+        "java": {
+          "maven": {
+            "artifactId": "constructs",
+            "groupId": "software.constructs"
+          },
+          "package": "software.constructs"
+        },
+        "js": {
+          "npm": "constructs"
+        },
+        "python": {
+          "distName": "constructs",
+          "module": "constructs"
+        }
+      }
+    }
+  },
+  "description": "Host-process asset bundler for CDK Terrain",
+  "homepage": "https://github.com/cdktn-io/cdktn-bundlers.git",
+  "jsiiVersion": "6.0.20 (build 338bb97)",
+  "license": "MPL-2.0",
+  "metadata": {
+    "jsii": {
+      "pacmak": {
+        "hasDefaultInterfaces": true
+      }
+    },
+    "tscOutDir": "lib",
+    "tscRootDir": "src"
+  },
+  "name": "@cdktn/bundler-local",
+  "readme": {
+    "markdown": "# @cdktn/bundler-local\n\nHost-process asset bundler for [CDK Terrain](https://github.com/open-constructs/cdk-terrain).\n\n`LocalBundler` runs a build command directly on the machine performing the\nsynth and stages its output as a `TerraformAsset`. The required toolchain must\nalready be installed on the host; for an isolated, reproducible build use\n`@cdktn/bundler-docker` instead.\n\n## Usage\n\n```ts\nimport { TerraformAsset, AssetType } from \"cdktn\";\nimport { LocalBundler } from \"@cdktn/bundler-local\";\n\nnew TerraformAsset(this, \"asset\", {\n  path: \"./src\",\n  type: AssetType.DIRECTORY,\n  bundler: new LocalBundler({\n    command: [\"sh\", \"-c\", \"npm run build -- --out-dir \\\"$ASSET_OUTPUT_DIR\\\"\"],\n  }),\n});\n```\n\nThe command is spawned directly, without a shell, so environment variable\nreferences like `$ASSET_OUTPUT_DIR` are only expanded if the command itself is a\nshell (`sh -c \"...\"` as above). Two variables are set for it:\n\n- `ASSET_INPUT_DIR` — the asset source (read-only).\n- `ASSET_OUTPUT_DIR` — a caller-owned directory the build writes its artifact into.\n\n### Windows\n\n`LocalBundler` resolves `npm`, `npx`, `pnpm`, and `.cmd`/`.bat` shims under\n`node_modules/.bin` the same way [`cross-spawn`][cross-spawn] does, so these\ncommands work on Windows without a shell. A bare name like `\"tsc\"` is only\nfound this way when the directory containing its shim (for example\n`node_modules/.bin`) is on `PATH`; otherwise pass a relative or absolute path\nto it instead.\n\nThe `sh -c \"...\"` form in the example above still needs `sh` on `PATH` (for\nexample through Git Bash or WSL), since Windows has no built-in shell of that\nname. A command that does not need a shell, such as a package.json script run\ndirectly (`[\"npm\", \"run\", \"build\"]`), works on Windows without that\ndependency.\n\nA script run directly (for example `[\"./build.js\"]`) relies on Windows file\nassociation, not on a shebang line, to pick an interpreter — pass the\ninterpreter explicitly instead (`[\"node\", \"build.js\"]`).\n\n[cross-spawn]: https://github.com/moxystudio/node-cross-spawn\n\n## License\n\nMozilla Public License 2.0\n"
+  },
+  "repository": {
+    "directory": "packages/local",
+    "type": "git",
+    "url": "https://github.com/cdktn-io/cdktn-bundlers.git"
+  },
+  "schema": "jsii/0.10.0",
+  "targets": {
+    "dotnet": {
+      "namespace": "Io.Cdktn.Bundler.Local",
+      "packageId": "Io.Cdktn.Bundler.Local"
+    },
+    "go": {
+      "moduleName": "github.com/cdktn-io/cdktn-bundlers-go",
+      "packageName": "bundlerlocal"
+    },
+    "java": {
+      "maven": {
+        "artifactId": "cdktn-bundler-local",
+        "groupId": "io.cdktn"
+      },
+      "package": "io.cdktn.bundler.local"
+    },
+    "js": {
+      "npm": "@cdktn/bundler-local"
+    },
+    "python": {
+      "distName": "cdktn-bundler-local",
+      "module": "cdktn_bundler_local"
+    }
+  },
+  "types": {
+    "@cdktn/bundler-local.LocalBundler": {
+      "assembly": "@cdktn/bundler-local",
+      "docs": {
+        "remarks": "The command is spawned with the asset source and a caller-owned output\ndirectory exposed through the `ASSET_INPUT_DIR` and `ASSET_OUTPUT_DIR`\nenvironment variables. Unlike a container bundler, the build runs directly\non the machine performing the synth, so the required toolchain must already\nbe installed there.",
+        "summary": "Runs a build command on the host and stages its output as a CDK for Terraform asset."
+      },
+      "fqn": "@cdktn/bundler-local.LocalBundler",
+      "initializer": {
+        "locationInModule": {
+          "filename": "src/local-bundler.ts",
+          "line": 94
+        },
+        "parameters": [
+          {
+            "name": "props",
+            "type": {
+              "fqn": "@cdktn/bundler-local.LocalBundlerProps"
+            }
+          }
+        ]
+      },
+      "interfaces": [
+        "cdktn.IAssetBundler"
+      ],
+      "kind": "class",
+      "locationInModule": {
+        "filename": "src/local-bundler.ts",
+        "line": 85
+      },
+      "methods": [
+        {
+          "docs": {
+            "remarks": "Implementations write into `options.outputDir` and never write back to\n`options.source`. The returned path must exist and match its declared\nshape, or staging rejects it.\n\nA bundler that cannot run in this environment returns\n`BundleResult.declined()` so a {@link ChainBundler} can fall through to\nthe next; a thrown error is a hard failure, not a decline.",
+            "summary": "Produce the artifact and return a {@link BundleResult} describing it."
+          },
+          "locationInModule": {
+            "filename": "src/local-bundler.ts",
+            "line": 130
+          },
+          "name": "bundle",
+          "overrides": "cdktn.IAssetBundler",
+          "parameters": [
+            {
+              "name": "options",
+              "type": {
+                "fqn": "cdktn.BundleOptions"
+              }
+            }
+          ],
+          "returns": {
+            "type": {
+              "fqn": "cdktn.BundleResult"
+            }
+          }
+        }
+      ],
+      "name": "LocalBundler",
+      "properties": [
+        {
+          "docs": {
+            "remarks": "The source tree alone cannot see the build, so swapping a `node:18` base\nimage for `node:20` would otherwise leave identity unchanged. Under\n`SOURCE` hashing this is the only channel by which the build reaches\nidentity, so it must serialize every input that can move the output, or a\nchanged build silently reuses a stale artifact. {@link BundlerKey} builds\none from an ordered set of parts.\n\nMirrors {@link IIgnoreStrategy.cacheKey}: omit it when the build cannot be\nsummarized as a string, and fall back to `extraHash`.",
+            "summary": "A value identifying the build, folded into the asset hash."
+          },
+          "immutable": true,
+          "locationInModule": {
+            "filename": "src/local-bundler.ts",
+            "line": 86
+          },
+          "name": "bundlerKey",
+          "optional": true,
+          "overrides": "cdktn.IAssetBundler",
+          "type": {
+            "primitive": "string"
+          }
+        },
+        {
+          "docs": {
+            "remarks": "A file-producing bundler (`BundleResult.file`) staged with\n`AssetType.FILE` would otherwise take the source path's basename, which is\na directory name when the source is a directory. Declaring the name here\nlets the artifact reflect what the bundler produces. It is static\nconfiguration, needed at construction before a deferred `SOURCE` build\nruns, not the file's runtime name.\n\nValid only for a file-producing bundler: setting it with a directory\npackaging (anything but `AssetType.FILE`) is rejected at construction.",
+            "summary": "The name a single-file artifact is staged under (e.g. `archive.zip`)."
+          },
+          "immutable": true,
+          "locationInModule": {
+            "filename": "src/local-bundler.ts",
+            "line": 87
+          },
+          "name": "outputFileName",
+          "optional": true,
+          "overrides": "cdktn.IAssetBundler",
+          "type": {
+            "primitive": "string"
+          }
+        }
+      ],
+      "symbolId": "src/local-bundler:LocalBundler"
+    },
+    "@cdktn/bundler-local.LocalBundlerProps": {
+      "assembly": "@cdktn/bundler-local",
+      "datatype": true,
+      "docs": {
+        "summary": "Configuration for {@link LocalBundler}."
+      },
+      "fqn": "@cdktn/bundler-local.LocalBundlerProps",
+      "kind": "interface",
+      "locationInModule": {
+        "filename": "src/local-bundler.ts",
+        "line": 19
+      },
+      "name": "LocalBundlerProps",
+      "properties": [
+        {
+          "abstract": true,
+          "docs": {
+            "remarks": "The first element is the program; the rest are its arguments. The command\nruns with `ASSET_INPUT_DIR` set to the source and `ASSET_OUTPUT_DIR` set\nto the output directory, and it is expected to write the built artifact\ninto `ASSET_OUTPUT_DIR`.",
+            "summary": "The command to run on the host, as an argv array."
+          },
+          "immutable": true,
+          "locationInModule": {
+            "filename": "src/local-bundler.ts",
+            "line": 28
+          },
+          "name": "command",
+          "type": {
+            "collection": {
+              "elementtype": {
+                "primitive": "string"
+              },
+              "kind": "array"
+            }
+          }
+        },
+        {
+          "abstract": true,
+          "docs": {
+            "default": "- only the caller's environment plus `ASSET_INPUT_DIR` and\n`ASSET_OUTPUT_DIR`",
+            "summary": "Environment variables to set for the command."
+          },
+          "immutable": true,
+          "locationInModule": {
+            "filename": "src/local-bundler.ts",
+            "line": 36
+          },
+          "name": "environment",
+          "optional": true,
+          "type": {
+            "collection": {
+              "elementtype": {
+                "primitive": "string"
+              },
+              "kind": "map"
+            }
+          }
+        },
+        {
+          "abstract": true,
+          "docs": {
+            "default": "- nothing extra is folded in",
+            "summary": "Extra content folded into the bundler key so a change to it invalidates the asset hash even when the source and command are unchanged."
+          },
+          "immutable": true,
+          "locationInModule": {
+            "filename": "src/local-bundler.ts",
+            "line": 61
+          },
+          "name": "extraHash",
+          "optional": true,
+          "type": {
+            "primitive": "string"
+          }
+        },
+        {
+          "abstract": true,
+          "docs": {
+            "default": "- the basename of the asset source path",
+            "remarks": "Only meaningful when the result is a single file staged as\n`AssetType.FILE`. Without it, a file produced from a directory source is\nstaged under the source directory's basename.",
+            "summary": "The file name to stage a single-file artifact under."
+          },
+          "immutable": true,
+          "locationInModule": {
+            "filename": "src/local-bundler.ts",
+            "line": 72
+          },
+          "name": "outputFileName",
+          "optional": true,
+          "type": {
+            "primitive": "string"
+          }
+        },
+        {
+          "abstract": true,
+          "docs": {
+            "default": "- `FILE` when `outputFileName` is set, otherwise `DIRECTORY`",
+            "remarks": "`DIRECTORY` stages the output directory. `FILE` requires the command to\nwrite exactly one file and stages that file.",
+            "summary": "The shape of the artifact the command writes to `ASSET_OUTPUT_DIR`."
+          },
+          "immutable": true,
+          "locationInModule": {
+            "filename": "src/local-bundler.ts",
+            "line": 53
+          },
+          "name": "outputType",
+          "optional": true,
+          "type": {
+            "fqn": "cdktn.BundleOutputType"
+          }
+        },
+        {
+          "abstract": true,
+          "docs": {
+            "default": "- the asset source directory, or its parent for a file source",
+            "summary": "The working directory the command runs in."
+          },
+          "immutable": true,
+          "locationInModule": {
+            "filename": "src/local-bundler.ts",
+            "line": 43
+          },
+          "name": "workingDirectory",
+          "optional": true,
+          "type": {
+            "primitive": "string"
+          }
+        }
+      ],
+      "symbolId": "src/local-bundler:LocalBundlerProps"
+    }
+  },
+  "version": "0.1.0",
+  "fingerprint": "Q7EtMMHSRw4iZSdcMFvvOvmWxQpTLuyvz87GCTEN13A="
+}

package/README.md

@@ -1,3 +1,55 @@
 # @cdktn/bundler-local
 
-Placeholder (0.0.0) that registers this package name so npm trusted publishing can be configured. Real releases are published from https://github.com/cdktn-io/cdktn-bundlers.
+Host-process asset bundler for [CDK Terrain](https://github.com/open-constructs/cdk-terrain).
+
+`LocalBundler` runs a build command directly on the machine performing the
+synth and stages its output as a `TerraformAsset`. The required toolchain must
+already be installed on the host; for an isolated, reproducible build use
+`@cdktn/bundler-docker` instead.
+
+## Usage
+
+```ts
+import { TerraformAsset, AssetType } from "cdktn";
+import { LocalBundler } from "@cdktn/bundler-local";
+
+new TerraformAsset(this, "asset", {
+  path: "./src",
+  type: AssetType.DIRECTORY,
+  bundler: new LocalBundler({
+    command: ["sh", "-c", "npm run build -- --out-dir \"$ASSET_OUTPUT_DIR\""],
+  }),
+});
+```
+
+The command is spawned directly, without a shell, so environment variable
+references like `$ASSET_OUTPUT_DIR` are only expanded if the command itself is a
+shell (`sh -c "..."` as above). Two variables are set for it:
+
+- `ASSET_INPUT_DIR` — the asset source (read-only).
+- `ASSET_OUTPUT_DIR` — a caller-owned directory the build writes its artifact into.
+
+### Windows
+
+`LocalBundler` resolves `npm`, `npx`, `pnpm`, and `.cmd`/`.bat` shims under
+`node_modules/.bin` the same way [`cross-spawn`][cross-spawn] does, so these
+commands work on Windows without a shell. A bare name like `"tsc"` is only
+found this way when the directory containing its shim (for example
+`node_modules/.bin`) is on `PATH`; otherwise pass a relative or absolute path
+to it instead.
+
+The `sh -c "..."` form in the example above still needs `sh` on `PATH` (for
+example through Git Bash or WSL), since Windows has no built-in shell of that
+name. A command that does not need a shell, such as a package.json script run
+directly (`["npm", "run", "build"]`), works on Windows without that
+dependency.
+
+A script run directly (for example `["./build.js"]`) relies on Windows file
+association, not on a shebang line, to pick an interpreter — pass the
+interpreter explicitly instead (`["node", "build.js"]`).
+
+[cross-spawn]: https://github.com/moxystudio/node-cross-spawn
+
+## License
+
+Mozilla Public License 2.0

package/lib/index.d.ts

@@ -0,0 +1 @@
+export * from "./local-bundler";

package/lib/index.js

@@ -0,0 +1,20 @@
+"use strict";
+// Copyright (c) cdktn-io
+// SPDX-License-Identifier: MPL-2.0
+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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./local-bundler"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBLHlCQUF5QjtBQUN6QixtQ0FBbUM7Ozs7Ozs7Ozs7Ozs7Ozs7QUFFbkMsa0RBQWdDIiwic291cmNlc0NvbnRlbnQiOlsiLy8gQ29weXJpZ2h0IChjKSBjZGt0bi1pb1xuLy8gU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IE1QTC0yLjBcblxuZXhwb3J0ICogZnJvbSBcIi4vbG9jYWwtYnVuZGxlclwiO1xuIl19

package/lib/local-bundler.d.ts

@@ -0,0 +1,76 @@
+import { BundleOptions, BundleOutputType, BundleResult, IAssetBundler } from "cdktn";
+/**
+ * Configuration for {@link LocalBundler}.
+ */
+export interface LocalBundlerProps {
+    /**
+     * The command to run on the host, as an argv array.
+     *
+     * The first element is the program; the rest are its arguments. The command
+     * runs with `ASSET_INPUT_DIR` set to the source and `ASSET_OUTPUT_DIR` set
+     * to the output directory, and it is expected to write the built artifact
+     * into `ASSET_OUTPUT_DIR`.
+     */
+    readonly command: string[];
+    /**
+     * Environment variables to set for the command.
+     *
+     * @default - only the caller's environment plus `ASSET_INPUT_DIR` and
+     * `ASSET_OUTPUT_DIR`
+     */
+    readonly environment?: {
+        [key: string]: string;
+    };
+    /**
+     * The working directory the command runs in.
+     *
+     * @default - the asset source directory, or its parent for a file source
+     */
+    readonly workingDirectory?: string;
+    /**
+     * The shape of the artifact the command writes to `ASSET_OUTPUT_DIR`.
+     *
+     * `DIRECTORY` stages the output directory. `FILE` requires the command to
+     * write exactly one file and stages that file.
+     *
+     * @default - `FILE` when `outputFileName` is set, otherwise `DIRECTORY`
+     */
+    readonly outputType?: BundleOutputType;
+    /**
+     * Extra content folded into the bundler key so a change to it invalidates
+     * the asset hash even when the source and command are unchanged.
+     *
+     * @default - nothing extra is folded in
+     */
+    readonly extraHash?: string;
+    /**
+     * The file name to stage a single-file artifact under.
+     *
+     * Only meaningful when the result is a single file staged as
+     * `AssetType.FILE`. Without it, a file produced from a directory source is
+     * staged under the source directory's basename.
+     *
+     * @default - the basename of the asset source path
+     */
+    readonly outputFileName?: string;
+}
+/**
+ * Runs a build command on the host and stages its output as a CDK for
+ * Terraform asset.
+ *
+ * The command is spawned with the asset source and a caller-owned output
+ * directory exposed through the `ASSET_INPUT_DIR` and `ASSET_OUTPUT_DIR`
+ * environment variables. Unlike a container bundler, the build runs directly
+ * on the machine performing the synth, so the required toolchain must already
+ * be installed there.
+ */
+export declare class LocalBundler implements IAssetBundler {
+    readonly bundlerKey?: string;
+    readonly outputFileName?: string;
+    private readonly command;
+    private readonly environment?;
+    private readonly workingDirectory?;
+    private readonly outputType;
+    constructor(props: LocalBundlerProps);
+    bundle(options: BundleOptions): BundleResult;
+}

package/lib/local-bundler.js

@@ -0,0 +1,170 @@
+"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.LocalBundler = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+// Copyright (c) cdktn-io
+// SPDX-License-Identifier: MPL-2.0
+const crypto_1 = require("crypto");
+const fs_1 = require("fs");
+const path = __importStar(require("path"));
+const cdktn_1 = require("cdktn");
+const windows_spawn_1 = require("./windows-spawn");
+/**
+ * Runs a build command on the host and stages its output as a CDK for
+ * Terraform asset.
+ *
+ * The command is spawned with the asset source and a caller-owned output
+ * directory exposed through the `ASSET_INPUT_DIR` and `ASSET_OUTPUT_DIR`
+ * environment variables. Unlike a container bundler, the build runs directly
+ * on the machine performing the synth, so the required toolchain must already
+ * be installed there.
+ */
+class LocalBundler {
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@cdktn/bundler-local.LocalBundler", version: "0.1.0" };
+    bundlerKey;
+    outputFileName;
+    command;
+    environment;
+    workingDirectory;
+    outputType;
+    constructor(props) {
+        this.command = props.command;
+        this.environment = props.environment;
+        this.workingDirectory = props.workingDirectory;
+        this.outputType =
+            props.outputType ??
+                (props.outputFileName
+                    ? cdktn_1.BundleOutputType.FILE
+                    : cdktn_1.BundleOutputType.DIRECTORY);
+        this.outputFileName = props.outputFileName;
+        // The source tree cannot observe the build, so every input that can move
+        // the output has to reach identity through the key: command, working
+        // directory, environment and the declared output shape. Each segment is
+        // labelled so a value in one field can never serialise to the same string
+        // as a value in another (e.g. an environment entry vs. an extraHash).
+        let key = cdktn_1.BundlerKey.of("local")
+            .add(`cmd=${JSON.stringify(this.command)}`)
+            .add(`out=${this.outputType}`)
+            .add(`cwd=${this.workingDirectory ?? ""}`);
+        if (this.environment) {
+            key = key.add(...Object.keys(this.environment)
+                .sort()
+                .map((k) => `env=${k}=${this.environment[k]}`));
+        }
+        if (props.extraHash) {
+            key = key.add(`extra=${props.extraHash}`);
+        }
+        this.bundlerKey = `local::${(0, crypto_1.createHash)("sha256")
+            .update(key.toString())
+            .digest("hex")
+            .slice(0, 16)}`;
+    }
+    bundle(options) {
+        const { source, outputDir } = options;
+        const [program, ...args] = this.command;
+        const cwd = this.workingDirectory ??
+            ((0, fs_1.existsSync)(source) && (0, fs_1.statSync)(source).isFile()
+                ? path.dirname(source)
+                : source);
+        // Node reports ENOENT for a missing cwd too, which would otherwise be
+        // mistaken for a missing program and silently decline.
+        if (!(0, fs_1.existsSync)(cwd) || !(0, fs_1.statSync)(cwd).isDirectory()) {
+            throw new Error(`Local bundling working directory does not exist: ${cwd}`);
+        }
+        const result = (0, windows_spawn_1.spawnSyncCrossPlatform)(program, args, {
+            cwd,
+            // Stream the build's output straight through instead of capturing it:
+            // capturing is bounded by spawnSync's 1 MiB maxBuffer, which SIGTERMs a
+            // verbose build (e.g. `npm ci`) with ENOBUFS, and hides output until the
+            // build exits.
+            stdio: ["ignore", process.stderr, "inherit"],
+            env: {
+                ...process.env,
+                ...this.environment,
+                ASSET_INPUT_DIR: source,
+                ASSET_OUTPUT_DIR: outputDir,
+            },
+        });
+        if (result.error) {
+            // A missing toolchain is not a hard failure: declining lets a
+            // ChainBundler fall through to its next bundler (the local-then-Docker
+            // case the ChainBundler docs describe). Any other spawn error is real.
+            if (isSpawnUnavailable(result.error)) {
+                return cdktn_1.BundleResult.declined();
+            }
+            throw result.error;
+        }
+        if (result.status !== 0) {
+            const reason = result.signal != null
+                ? `signal ${result.signal}`
+                : `status ${result.status}`;
+            throw new Error(`Local bundling exited with ${reason} (${program} ${args.join(" ")})`);
+        }
+        if (!(0, fs_1.existsSync)(outputDir)) {
+            throw new Error(`Local bundling did not create the output directory ${outputDir}`);
+        }
+        if (this.outputType === cdktn_1.BundleOutputType.DIRECTORY) {
+            return cdktn_1.BundleResult.directory(outputDir);
+        }
+        return cdktn_1.BundleResult.file(determineBundledArtifact(outputDir));
+    }
+}
+exports.LocalBundler = LocalBundler;
+/**
+ * Whether a spawn error means the command could not be run at all.
+ *
+ * These signal an absent or non-executable toolchain, which a chain of
+ * bundlers should be allowed to skip past rather than fail on.
+ */
+function isSpawnUnavailable(error) {
+    return error.code === "ENOENT" || error.code === "EACCES";
+}
+/**
+ * Resolves the single file produced for `BundleOutputType.FILE` inside an
+ * output directory.
+ */
+function determineBundledArtifact(outputDir) {
+    // Require exactly one file. Picking the first of several in readdir order
+    // would stage a different artifact depending on the filesystem (e.g.
+    // bundle.zip vs. its sibling bundle.zip.sha256).
+    const files = (0, fs_1.readdirSync)(outputDir).filter((entry) => (0, fs_1.statSync)(path.join(outputDir, entry)).isFile());
+    if (files.length !== 1) {
+        throw new Error(`Bundling output directory must contain exactly one file for ` +
+            `output type ${cdktn_1.BundleOutputType.FILE}, found ${files.length}: ${outputDir}`);
+    }
+    return path.join(outputDir, files[0]);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"local-bundler.js","sourceRoot":"","sources":["../src/local-bundler.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright (c) cdktn-io\n// SPDX-License-Identifier: MPL-2.0\n\nimport { createHash } from \"crypto\";\nimport { existsSync, readdirSync, statSync } from \"fs\";\nimport * as path from \"path\";\nimport {\n  BundleOptions,\n  BundleOutputType,\n  BundleResult,\n  BundlerKey,\n  IAssetBundler,\n} from \"cdktn\";\nimport { spawnSyncCrossPlatform } from \"./windows-spawn\";\n\n/**\n * Configuration for {@link LocalBundler}.\n */\nexport interface LocalBundlerProps {\n  /**\n   * The command to run on the host, as an argv array.\n   *\n   * The first element is the program; the rest are its arguments. The command\n   * runs with `ASSET_INPUT_DIR` set to the source and `ASSET_OUTPUT_DIR` set\n   * to the output directory, and it is expected to write the built artifact\n   * into `ASSET_OUTPUT_DIR`.\n   */\n  readonly command: string[];\n\n  /**\n   * Environment variables to set for the command.\n   *\n   * @default - only the caller's environment plus `ASSET_INPUT_DIR` and\n   * `ASSET_OUTPUT_DIR`\n   */\n  readonly environment?: { [key: string]: string };\n\n  /**\n   * The working directory the command runs in.\n   *\n   * @default - the asset source directory, or its parent for a file source\n   */\n  readonly workingDirectory?: string;\n\n  /**\n   * The shape of the artifact the command writes to `ASSET_OUTPUT_DIR`.\n   *\n   * `DIRECTORY` stages the output directory. `FILE` requires the command to\n   * write exactly one file and stages that file.\n   *\n   * @default - `FILE` when `outputFileName` is set, otherwise `DIRECTORY`\n   */\n  readonly outputType?: BundleOutputType;\n\n  /**\n   * Extra content folded into the bundler key so a change to it invalidates\n   * the asset hash even when the source and command are unchanged.\n   *\n   * @default - nothing extra is folded in\n   */\n  readonly extraHash?: string;\n\n  /**\n   * The file name to stage a single-file artifact under.\n   *\n   * Only meaningful when the result is a single file staged as\n   * `AssetType.FILE`. Without it, a file produced from a directory source is\n   * staged under the source directory's basename.\n   *\n   * @default - the basename of the asset source path\n   */\n  readonly outputFileName?: string;\n}\n\n/**\n * Runs a build command on the host and stages its output as a CDK for\n * Terraform asset.\n *\n * The command is spawned with the asset source and a caller-owned output\n * directory exposed through the `ASSET_INPUT_DIR` and `ASSET_OUTPUT_DIR`\n * environment variables. Unlike a container bundler, the build runs directly\n * on the machine performing the synth, so the required toolchain must already\n * be installed there.\n */\nexport class LocalBundler implements IAssetBundler {\n  public readonly bundlerKey?: string;\n  public readonly outputFileName?: string;\n\n  private readonly command: string[];\n  private readonly environment?: { [key: string]: string };\n  private readonly workingDirectory?: string;\n  private readonly outputType: BundleOutputType;\n\n  constructor(props: LocalBundlerProps) {\n    this.command = props.command;\n    this.environment = props.environment;\n    this.workingDirectory = props.workingDirectory;\n    this.outputType =\n      props.outputType ??\n      (props.outputFileName\n        ? BundleOutputType.FILE\n        : BundleOutputType.DIRECTORY);\n    this.outputFileName = props.outputFileName;\n\n    // The source tree cannot observe the build, so every input that can move\n    // the output has to reach identity through the key: command, working\n    // directory, environment and the declared output shape. Each segment is\n    // labelled so a value in one field can never serialise to the same string\n    // as a value in another (e.g. an environment entry vs. an extraHash).\n    let key = BundlerKey.of(\"local\")\n      .add(`cmd=${JSON.stringify(this.command)}`)\n      .add(`out=${this.outputType}`)\n      .add(`cwd=${this.workingDirectory ?? \"\"}`);\n    if (this.environment) {\n      key = key.add(\n        ...Object.keys(this.environment)\n          .sort()\n          .map((k) => `env=${k}=${this.environment![k]}`),\n      );\n    }\n    if (props.extraHash) {\n      key = key.add(`extra=${props.extraHash}`);\n    }\n    this.bundlerKey = `local::${createHash(\"sha256\")\n      .update(key.toString())\n      .digest(\"hex\")\n      .slice(0, 16)}`;\n  }\n\n  public bundle(options: BundleOptions): BundleResult {\n    const { source, outputDir } = options;\n    const [program, ...args] = this.command;\n    const cwd =\n      this.workingDirectory ??\n      (existsSync(source) && statSync(source).isFile()\n        ? path.dirname(source)\n        : source);\n\n    // Node reports ENOENT for a missing cwd too, which would otherwise be\n    // mistaken for a missing program and silently decline.\n    if (!existsSync(cwd) || !statSync(cwd).isDirectory()) {\n      throw new Error(\n        `Local bundling working directory does not exist: ${cwd}`,\n      );\n    }\n\n    const result = spawnSyncCrossPlatform(program, args, {\n      cwd,\n      // Stream the build's output straight through instead of capturing it:\n      // capturing is bounded by spawnSync's 1 MiB maxBuffer, which SIGTERMs a\n      // verbose build (e.g. `npm ci`) with ENOBUFS, and hides output until the\n      // build exits.\n      stdio: [\"ignore\", process.stderr, \"inherit\"],\n      env: {\n        ...process.env,\n        ...this.environment,\n        ASSET_INPUT_DIR: source,\n        ASSET_OUTPUT_DIR: outputDir,\n      },\n    });\n\n    if (result.error) {\n      // A missing toolchain is not a hard failure: declining lets a\n      // ChainBundler fall through to its next bundler (the local-then-Docker\n      // case the ChainBundler docs describe). Any other spawn error is real.\n      if (isSpawnUnavailable(result.error)) {\n        return BundleResult.declined();\n      }\n      throw result.error;\n    }\n    if (result.status !== 0) {\n      const reason =\n        result.signal != null\n          ? `signal ${result.signal}`\n          : `status ${result.status}`;\n      throw new Error(\n        `Local bundling exited with ${reason} (${program} ${args.join(\" \")})`,\n      );\n    }\n    if (!existsSync(outputDir)) {\n      throw new Error(\n        `Local bundling did not create the output directory ${outputDir}`,\n      );\n    }\n\n    if (this.outputType === BundleOutputType.DIRECTORY) {\n      return BundleResult.directory(outputDir);\n    }\n    return BundleResult.file(determineBundledArtifact(outputDir));\n  }\n}\n\n/**\n * Whether a spawn error means the command could not be run at all.\n *\n * These signal an absent or non-executable toolchain, which a chain of\n * bundlers should be allowed to skip past rather than fail on.\n */\nfunction isSpawnUnavailable(error: NodeJS.ErrnoException): boolean {\n  return error.code === \"ENOENT\" || error.code === \"EACCES\";\n}\n\n/**\n * Resolves the single file produced for `BundleOutputType.FILE` inside an\n * output directory.\n */\nfunction determineBundledArtifact(outputDir: string): string {\n  // Require exactly one file. Picking the first of several in readdir order\n  // would stage a different artifact depending on the filesystem (e.g.\n  // bundle.zip vs. its sibling bundle.zip.sha256).\n  const files = readdirSync(outputDir).filter((entry) =>\n    statSync(path.join(outputDir, entry)).isFile(),\n  );\n  if (files.length !== 1) {\n    throw new Error(\n      `Bundling output directory must contain exactly one file for ` +\n        `output type ${BundleOutputType.FILE}, found ${files.length}: ${outputDir}`,\n    );\n  }\n  return path.join(outputDir, files[0]);\n}\n"]}

package/lib/windows-spawn.d.ts

@@ -0,0 +1,9 @@
+import { SpawnSyncOptions, SpawnSyncReturns } from "child_process";
+/**
+ * `spawnSync` that resolves Windows `.cmd`/`.bat` shims (as created for
+ * `npm`, `npx`, `pnpm`, and everything under `node_modules/.bin`) through
+ * `cmd.exe` the way a shell would, so they run without the caller having to
+ * invoke a shell itself. A thin pass-through to `child_process.spawnSync`
+ * on every other platform.
+ */
+export declare function spawnSyncCrossPlatform(command: string, args: string[], options: SpawnSyncOptions): SpawnSyncReturns<string | Buffer>;

package/lib/windows-spawn.js

@@ -0,0 +1,190 @@
+"use strict";
+// Copyright (c) cdktn-io
+// SPDX-License-Identifier: MPL-2.0
+//
+// The Windows command resolution and cmd.exe escaping below is adapted from
+// cross-spawn (https://github.com/moxystudio/node-cross-spawn), vendored
+// here instead of taken as an npm dependency: packing it through
+// jsii-pacmak's `npm pack` step pulls in a dependency resolved via pnpm's
+// symlinked store, which reliably triggers an npm packing bug ("Exit
+// handler never called!") in this project's CI. A plain source file has no
+// node_modules involved in packing.
+//
+// cross-spawn is MIT licensed:
+//
+//   The MIT License (MIT)
+//
+//   Copyright (c) 2018 Made With MOXY Lda <hello@moxy.studio>
+//
+//   Permission is hereby granted, free of charge, to any person obtaining a
+//   copy of this software and associated documentation files (the
+//   "Software"), to deal in the Software without restriction, including
+//   without limitation the rights to use, copy, modify, merge, publish,
+//   distribute, sublicense, and/or sell copies of the Software, and to
+//   permit persons to whom the Software is furnished to do so, subject to
+//   the following conditions:
+//
+//   The above copyright notice and this permission notice shall be included
+//   in all copies or substantial portions of the Software.
+//
+//   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+//   OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+//   MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+//   IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+//   CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+//   TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+//   SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+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.spawnSyncCrossPlatform = spawnSyncCrossPlatform;
+const child_process_1 = require("child_process");
+const fs_1 = require("fs");
+const path = __importStar(require("path"));
+const isWin = process.platform === "win32";
+const isNativeExecutableRegExp = /\.(?:com|exe)$/i;
+const isBatchFileRegExp = /\.(?:cmd|bat)$/i;
+const metaCharsRegExp = /([()\][%!^"`<>&|;, *?])/g;
+/**
+ * Looks up an environment variable case-insensitively, as Windows itself
+ * does, and as the env passed to the spawned process (not this process's
+ * own `process.env`) should be read.
+ */
+function envValue(env, name) {
+    const key = Object.keys(env)
+        .reverse()
+        .find((k) => k.toUpperCase() === name.toUpperCase());
+    return key ? env[key] : undefined;
+}
+function windowsPathExtCandidates(command, env) {
+    const pathExtExe = envValue(env, "PATHEXT") || ".EXE;.CMD;.BAT;.COM";
+    const exts = pathExtExe.split(";");
+    return command.includes(".") && exts[0] !== "" ? ["", ...exts] : exts;
+}
+function fileExists(file) {
+    try {
+        const stat = (0, fs_1.statSync)(file);
+        return stat.isFile() || stat.isSymbolicLink();
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Resolves a command to a file on disk the way Windows itself resolves it:
+ * a command containing a path separator is resolved against `cwd` (the
+ * spawned process's working directory, not this process's); a bare command
+ * name is resolved against `cwd` first, then each `PATH` entry; each is
+ * tried with every `PATHEXT` extension in turn.
+ */
+function resolveOnWindows(command, cwd, env) {
+    const hasSlash = /[\\/]/.test(command);
+    const dirs = hasSlash
+        ? [cwd]
+        : [cwd, ...(envValue(env, "PATH") ?? "").split(path.delimiter)];
+    for (const dir of dirs) {
+        const candidate = path.resolve(cwd, dir, command);
+        for (const ext of windowsPathExtCandidates(command, env)) {
+            const full = candidate + ext;
+            if (fileExists(full)) {
+                return full;
+            }
+        }
+    }
+    return undefined;
+}
+function escapeCommand(arg) {
+    return arg.replace(metaCharsRegExp, "^$1");
+}
+/**
+ * Escapes a single command-line argument for cmd.exe. Ported verbatim from
+ * cross-spawn (see https://qntm.org/cmd for the algorithm this implements)
+ * since getting Windows command-line escaping wrong is a real security
+ * issue (e.g. CVE-2024-27980), not just a correctness one.
+ */
+function escapeArgument(arg, doubleEscapeMetaChars) {
+    let escaped = `${arg}`;
+    escaped = escaped.replace(/(?=(\\+?)?)\1"/g, '$1$1\\"');
+    escaped = escaped.replace(/(?=(\\+?)?)\1$/, "$1$1");
+    escaped = `"${escaped}"`;
+    escaped = escaped.replace(metaCharsRegExp, "^$1");
+    if (doubleEscapeMetaChars) {
+        escaped = escaped.replace(metaCharsRegExp, "^$1");
+    }
+    return escaped;
+}
+/**
+ * `spawnSync` that resolves Windows `.cmd`/`.bat` shims (as created for
+ * `npm`, `npx`, `pnpm`, and everything under `node_modules/.bin`) through
+ * `cmd.exe` the way a shell would, so they run without the caller having to
+ * invoke a shell itself. A thin pass-through to `child_process.spawnSync`
+ * on every other platform.
+ */
+function spawnSyncCrossPlatform(command, args, options) {
+    if (!isWin) {
+        return (0, child_process_1.spawnSync)(command, args, options);
+    }
+    // Absolute, so resolveOnWindows doesn't apply a relative cwd twice.
+    const cwd = path.resolve(typeof options.cwd === "string" ? options.cwd : process.cwd());
+    const env = options.env ?? process.env;
+    const file = resolveOnWindows(command, cwd, env);
+    const needsShell = !file || !isNativeExecutableRegExp.test(file);
+    let resolvedCommand = command;
+    let resolvedArgs = args;
+    let windowsVerbatimArguments;
+    if (needsShell) {
+        // A batch file re-parses the arguments it forwards, so meta chars need
+        // escaping twice.
+        const needsDoubleEscape = !!file && isBatchFileRegExp.test(file);
+        const escapedCommand = escapeCommand(path.normalize(command));
+        const escapedArgs = args.map((arg) => escapeArgument(arg, needsDoubleEscape));
+        const shellCommand = [escapedCommand, ...escapedArgs].join(" ");
+        resolvedCommand = process.env.ComSpec || "cmd.exe";
+        resolvedArgs = ["/d", "/s", "/c", `"${shellCommand}"`];
+        windowsVerbatimArguments = true;
+    }
+    const result = (0, child_process_1.spawnSync)(resolvedCommand, resolvedArgs, {
+        ...options,
+        windowsVerbatimArguments,
+    });
+    // cmd.exe reports "command not recognized" as a plain exit code 1, which
+    // would otherwise be mistaken for the command having run and failed.
+    if (!result.error && result.status === 1 && !file) {
+        result.error = Object.assign(new Error(`spawnSync ${command} ENOENT`), {
+            code: "ENOENT",
+        });
+    }
+    return result;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"windows-spawn.js","sourceRoot":"","sources":["../src/windows-spawn.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright (c) cdktn-io\n// SPDX-License-Identifier: MPL-2.0\n//\n// The Windows command resolution and cmd.exe escaping below is adapted from\n// cross-spawn (https://github.com/moxystudio/node-cross-spawn), vendored\n// here instead of taken as an npm dependency: packing it through\n// jsii-pacmak's `npm pack` step pulls in a dependency resolved via pnpm's\n// symlinked store, which reliably triggers an npm packing bug (\"Exit\n// handler never called!\") in this project's CI. A plain source file has no\n// node_modules involved in packing.\n//\n// cross-spawn is MIT licensed:\n//\n//   The MIT License (MIT)\n//\n//   Copyright (c) 2018 Made With MOXY Lda <hello@moxy.studio>\n//\n//   Permission is hereby granted, free of charge, to any person obtaining a\n//   copy of this software and associated documentation files (the\n//   \"Software\"), to deal in the Software without restriction, including\n//   without limitation the rights to use, copy, modify, merge, publish,\n//   distribute, sublicense, and/or sell copies of the Software, and to\n//   permit persons to whom the Software is furnished to do so, subject to\n//   the following conditions:\n//\n//   The above copyright notice and this permission notice shall be included\n//   in all copies or substantial portions of the Software.\n//\n//   THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n//   OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n//   MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.\n//   IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY\n//   CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,\n//   TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE\n//   SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\n\nimport { spawnSync, SpawnSyncOptions, SpawnSyncReturns } from \"child_process\";\nimport { statSync } from \"fs\";\nimport * as path from \"path\";\n\nconst isWin = process.platform === \"win32\";\nconst isNativeExecutableRegExp = /\\.(?:com|exe)$/i;\nconst isBatchFileRegExp = /\\.(?:cmd|bat)$/i;\nconst metaCharsRegExp = /([()\\][%!^\"`<>&|;, *?])/g;\n\n/**\n * Looks up an environment variable case-insensitively, as Windows itself\n * does, and as the env passed to the spawned process (not this process's\n * own `process.env`) should be read.\n */\nfunction envValue(\n  env: NodeJS.ProcessEnv,\n  name: string,\n): string | undefined {\n  const key = Object.keys(env)\n    .reverse()\n    .find((k) => k.toUpperCase() === name.toUpperCase());\n  return key ? env[key] : undefined;\n}\n\nfunction windowsPathExtCandidates(\n  command: string,\n  env: NodeJS.ProcessEnv,\n): string[] {\n  const pathExtExe = envValue(env, \"PATHEXT\") || \".EXE;.CMD;.BAT;.COM\";\n  const exts = pathExtExe.split(\";\");\n  return command.includes(\".\") && exts[0] !== \"\" ? [\"\", ...exts] : exts;\n}\n\nfunction fileExists(file: string): boolean {\n  try {\n    const stat = statSync(file);\n    return stat.isFile() || stat.isSymbolicLink();\n  } catch {\n    return false;\n  }\n}\n\n/**\n * Resolves a command to a file on disk the way Windows itself resolves it:\n * a command containing a path separator is resolved against `cwd` (the\n * spawned process's working directory, not this process's); a bare command\n * name is resolved against `cwd` first, then each `PATH` entry; each is\n * tried with every `PATHEXT` extension in turn.\n */\nfunction resolveOnWindows(\n  command: string,\n  cwd: string,\n  env: NodeJS.ProcessEnv,\n): string | undefined {\n  const hasSlash = /[\\\\/]/.test(command);\n  const dirs = hasSlash\n    ? [cwd]\n    : [cwd, ...(envValue(env, \"PATH\") ?? \"\").split(path.delimiter)];\n\n  for (const dir of dirs) {\n    const candidate = path.resolve(cwd, dir, command);\n    for (const ext of windowsPathExtCandidates(command, env)) {\n      const full = candidate + ext;\n      if (fileExists(full)) {\n        return full;\n      }\n    }\n  }\n  return undefined;\n}\n\nfunction escapeCommand(arg: string): string {\n  return arg.replace(metaCharsRegExp, \"^$1\");\n}\n\n/**\n * Escapes a single command-line argument for cmd.exe. Ported verbatim from\n * cross-spawn (see https://qntm.org/cmd for the algorithm this implements)\n * since getting Windows command-line escaping wrong is a real security\n * issue (e.g. CVE-2024-27980), not just a correctness one.\n */\nfunction escapeArgument(arg: string, doubleEscapeMetaChars: boolean): string {\n  let escaped = `${arg}`;\n  escaped = escaped.replace(/(?=(\\\\+?)?)\\1\"/g, '$1$1\\\\\"');\n  escaped = escaped.replace(/(?=(\\\\+?)?)\\1$/, \"$1$1\");\n  escaped = `\"${escaped}\"`;\n  escaped = escaped.replace(metaCharsRegExp, \"^$1\");\n  if (doubleEscapeMetaChars) {\n    escaped = escaped.replace(metaCharsRegExp, \"^$1\");\n  }\n  return escaped;\n}\n\n/**\n * `spawnSync` that resolves Windows `.cmd`/`.bat` shims (as created for\n * `npm`, `npx`, `pnpm`, and everything under `node_modules/.bin`) through\n * `cmd.exe` the way a shell would, so they run without the caller having to\n * invoke a shell itself. A thin pass-through to `child_process.spawnSync`\n * on every other platform.\n */\nexport function spawnSyncCrossPlatform(\n  command: string,\n  args: string[],\n  options: SpawnSyncOptions,\n): SpawnSyncReturns<string | Buffer> {\n  if (!isWin) {\n    return spawnSync(command, args, options);\n  }\n\n  // Absolute, so resolveOnWindows doesn't apply a relative cwd twice.\n  const cwd = path.resolve(\n    typeof options.cwd === \"string\" ? options.cwd : process.cwd(),\n  );\n  const env = options.env ?? process.env;\n  const file = resolveOnWindows(command, cwd, env);\n  const needsShell = !file || !isNativeExecutableRegExp.test(file);\n\n  let resolvedCommand = command;\n  let resolvedArgs = args;\n  let windowsVerbatimArguments: boolean | undefined;\n\n  if (needsShell) {\n    // A batch file re-parses the arguments it forwards, so meta chars need\n    // escaping twice.\n    const needsDoubleEscape = !!file && isBatchFileRegExp.test(file);\n    const escapedCommand = escapeCommand(path.normalize(command));\n    const escapedArgs = args.map((arg) =>\n      escapeArgument(arg, needsDoubleEscape),\n    );\n    const shellCommand = [escapedCommand, ...escapedArgs].join(\" \");\n\n    resolvedCommand = process.env.ComSpec || \"cmd.exe\";\n    resolvedArgs = [\"/d\", \"/s\", \"/c\", `\"${shellCommand}\"`];\n    windowsVerbatimArguments = true;\n  }\n\n  const result = spawnSync(resolvedCommand, resolvedArgs, {\n    ...options,\n    windowsVerbatimArguments,\n  });\n\n  // cmd.exe reports \"command not recognized\" as a plain exit code 1, which\n  // would otherwise be mistaken for the command having run and failed.\n  if (!result.error && result.status === 1 && !file) {\n    result.error = Object.assign(new Error(`spawnSync ${command} ENOENT`), {\n      code: \"ENOENT\",\n    });\n  }\n\n  return result;\n}\n"]}

package/package.json

@@ -1,12 +1,70 @@
 {
   "name": "@cdktn/bundler-local",
-  "version": "0.0.0",
-  "description": "Placeholder to register npm trusted publishing. Real releases come from cdktn-io/cdktn-bundlers.",
+  "version": "0.1.0",
+  "description": "Host-process asset bundler for CDK Terrain",
   "license": "MPL-2.0",
+  "author": {
+    "name": "cdktn-io",
+    "url": "https://cdktn.io",
+    "organization": true
+  },
   "repository": {
     "type": "git",
     "url": "https://github.com/cdktn-io/cdktn-bundlers.git",
     "directory": "packages/local"
   },
-  "publishConfig": { "access": "public" }
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
+  "files": [
+    "lib/**/*.js",
+    "lib/**/*.d.ts",
+    ".jsii"
+  ],
+  "scripts": {
+    "build": "jsii",
+    "package": "jsii-pacmak",
+    "test": "jest"
+  },
+  "peerDependencies": {
+    "cdktn": "^0.25.0",
+    "constructs": "^10.6.0"
+  },
+  "devDependencies": {
+    "cdktn": "0.25.0",
+    "constructs": "10.8.1",
+    "jest": "30.5.2",
+    "ts-jest": "29.4.15",
+    "@types/jest": "30.0.0"
+  },
+  "jsii": {
+    "outdir": "dist",
+    "tsc": {
+      "outDir": "lib",
+      "rootDir": "src"
+    },
+    "excludeTypescript": [
+      "src/**/__tests__/**"
+    ],
+    "targets": {
+      "python": {
+        "distName": "cdktn-bundler-local",
+        "module": "cdktn_bundler_local"
+      },
+      "java": {
+        "package": "io.cdktn.bundler.local",
+        "maven": {
+          "groupId": "io.cdktn",
+          "artifactId": "cdktn-bundler-local"
+        }
+      },
+      "dotnet": {
+        "namespace": "Io.Cdktn.Bundler.Local",
+        "packageId": "Io.Cdktn.Bundler.Local"
+      },
+      "go": {
+        "moduleName": "github.com/cdktn-io/cdktn-bundlers-go",
+        "packageName": "bundlerlocal"
+      }
+    }
+  }
 }