@aws-cdk/integ-runner 2.196.0 → 2.196.1

package/lib/workers/extract/index.js

@@ -4670,7 +4670,7 @@ var require_semver2 = __commonJS({
 // ../cloud-assembly-schema/cli-version.json
 var require_cli_version = __commonJS({
   "../cloud-assembly-schema/cli-version.json"(exports2, module2) {
-    module2.exports = { version: "2.1106.0" };
+    module2.exports = { version: "2.1106.1" };
   }
 });
 
@@ -6799,20 +6799,21 @@ var init_manifest = __esm({
             `${VERSION_MISMATCH}: Maximum schema version supported is ${maxSupported}.x.x, but found ${actual}${cliWarning}`
           );
         }
-        const validator = new jsonschema.Validator();
-        const result2 = validator.validate(manifest, schema, {
-          // does exist but is not in the TypeScript definitions
-          nestedErrors: true,
-          allowUnknownAttributes: false,
-          preValidateProperty: _Manifest.validateAssumeRoleAdditionalOptions
-        });
-        let errors = result2.errors;
-        if (options?.skipEnumCheck) {
-          errors = stripEnumErrors(errors);
-        }
-        if (errors.length > 0) {
-          throw new Error(`Invalid assembly manifest:
+        if (options?.validateSchema ?? process.env.TESTING_CDK === "1") {
+          const validator = new jsonschema.Validator();
+          const result2 = validator.validate(manifest, schema, {
+            nestedErrors: true,
+            allowUnknownAttributes: false,
+            preValidateProperty: _Manifest.validateAssumeRoleAdditionalOptions
+          });
+          let errors = result2.errors;
+          if (options?.skipEnumCheck) {
+            errors = stripEnumErrors(errors);
+          }
+          if (errors.length > 0) {
+            throw new Error(`Invalid assembly manifest:
 ${errors.map((e16) => e16.stack).join("\n")}`);
+          }
         }
       }
       static saveManifest(manifest, filePath, schema, preprocess) {
@@ -14160,6 +14161,8 @@ var init_integ_manifest = __esm({
       static {
         __name(this, "NoManifestError");
       }
+      manifestPath;
+      cause;
       constructor(manifestPath, cause) {
         super(`Cannot read integ manifest '${manifestPath}': ${cause.message}`);
         this.name = "NoManifestError";
@@ -14172,6 +14175,8 @@ var init_integ_manifest = __esm({
       static {
         __name(this, "ManifestLoadError");
       }
+      manifestPath;
+      cause;
       constructor(manifestPath, cause) {
         super(`Failed to load integ manifest '${manifestPath}': ${cause.message}`);
         this.name = "ManifestLoadingError";
@@ -14188,9 +14193,7 @@ var init_integ_manifest = __esm({
       static {
         __name(this, "IntegManifestReader");
       }
-      static {
-        this.DEFAULT_FILENAME = "integ.json";
-      }
+      static DEFAULT_FILENAME = "integ.json";
       /**
        * Reads an integration test manifest from the specified file
        */
@@ -14224,6 +14227,10 @@ var init_integ_manifest = __esm({
         }
         return _IntegManifestReader.fromFile(filePath);
       }
+      /**
+       * The directory where the manifest was found
+       */
+      directory;
       /**
        * List of integration tests in the manifest
        */
@@ -14258,7 +14265,6 @@ var init_integ_test_suite = __esm({
         this.enableLookups = enableLookups;
         this.testSuite = testSuite;
         this.synthContext = synthContext;
-        this.type = "test-suite";
       }
       static {
         __name(this, "IntegTestSuite");
@@ -14274,6 +14280,7 @@ var init_integ_test_suite = __esm({
           reader.tests.synthContext
         );
       }
+      type = "test-suite";
       /**
        * Returns a list of stacks that have stackUpdateWorkflow disabled
        */
@@ -14311,7 +14318,6 @@ var init_integ_test_suite = __esm({
         this.enableLookups = enableLookups;
         this.testSuite = testSuite;
         this.synthContext = synthContext;
-        this.type = "legacy-test-suite";
       }
       static {
         __name(this, "LegacyIntegTestSuite");
@@ -14426,6 +14432,7 @@ var init_integ_test_suite = __esm({
       static pragmas(integSourceFilePath) {
         return this.readIntegPragma(integSourceFilePath).filter((p16) => p16.startsWith(PRAGMA_PREFIX));
       }
+      type = "legacy-test-suite";
       /**
        * Save the integ manifest to a directory
        */
@@ -80543,6 +80550,584 @@ var init_non_interactive_io_host = __esm({
   }
 });
 
+// ../toolkit-lib/lib/api/cloud-assembly/stack-selector.ts
+var StackSelectionStrategy, ExpandStackSelection;
+var init_stack_selector = __esm({
+  "../toolkit-lib/lib/api/cloud-assembly/stack-selector.ts"() {
+    "use strict";
+    StackSelectionStrategy = /* @__PURE__ */ ((StackSelectionStrategy3) => {
+      StackSelectionStrategy3["ALL_STACKS"] = "all-stacks";
+      StackSelectionStrategy3["MAIN_ASSEMBLY"] = "main-assembly";
+      StackSelectionStrategy3["ONLY_SINGLE"] = "only-single";
+      StackSelectionStrategy3["PATTERN_MATCH"] = "pattern-match";
+      StackSelectionStrategy3["PATTERN_MUST_MATCH"] = "pattern-must-match";
+      StackSelectionStrategy3["PATTERN_MUST_MATCH_SINGLE"] = "pattern-must-match-single";
+      return StackSelectionStrategy3;
+    })(StackSelectionStrategy || {});
+    ExpandStackSelection = /* @__PURE__ */ ((ExpandStackSelection3) => {
+      ExpandStackSelection3["NONE"] = "none";
+      ExpandStackSelection3["UPSTREAM"] = "upstream";
+      ExpandStackSelection3["DOWNSTREAM"] = "downstream";
+      return ExpandStackSelection3;
+    })(ExpandStackSelection || {});
+  }
+});
+
+// ../toolkit-lib/lib/api/cloud-assembly/private/borrowed-assembly.ts
+var import_dispose_polyfill, BorrowedAssembly;
+var init_borrowed_assembly = __esm({
+  "../toolkit-lib/lib/api/cloud-assembly/private/borrowed-assembly.ts"() {
+    "use strict";
+    import_dispose_polyfill = __toESM(require_dispose_polyfill());
+    BorrowedAssembly = class {
+      constructor(cloudAssembly) {
+        this.cloudAssembly = cloudAssembly;
+      }
+      static {
+        __name(this, "BorrowedAssembly");
+      }
+      async _unlock() {
+      }
+      async dispose() {
+      }
+      async [Symbol.asyncDispose]() {
+      }
+    };
+  }
+});
+
+// ../toolkit-lib/lib/api/cloud-assembly/cached-source.ts
+var import_dispose_polyfill2, CachedCloudAssembly;
+var init_cached_source = __esm({
+  "../toolkit-lib/lib/api/cloud-assembly/cached-source.ts"() {
+    "use strict";
+    import_dispose_polyfill2 = __toESM(require_dispose_polyfill());
+    init_borrowed_assembly();
+    CachedCloudAssembly = class {
+      static {
+        __name(this, "CachedCloudAssembly");
+      }
+      asm;
+      constructor(asm) {
+        this.asm = asm;
+      }
+      get cloudAssembly() {
+        return this.asm.cloudAssembly;
+      }
+      async produce() {
+        return new BorrowedAssembly(this.asm.cloudAssembly);
+      }
+      _unlock() {
+        return this.asm._unlock();
+      }
+      dispose() {
+        return this.asm.dispose();
+      }
+      [Symbol.asyncDispose]() {
+        return this.dispose();
+      }
+    };
+  }
+});
+
+// ../toolkit-lib/lib/api/settings.ts
+function expandHomeDir(x16) {
+  if (x16.startsWith("~")) {
+    return fs_path.join(os3.homedir(), x16.slice(1));
+  }
+  return x16;
+}
+function stripTransientValues(obj) {
+  const ret = {};
+  for (const [key, value] of Object.entries(obj)) {
+    if (!isTransientValue(value)) {
+      ret[key] = value;
+    }
+  }
+  return ret;
+}
+function isTransientValue(value) {
+  return typeof value === "object" && value !== null && value[TRANSIENT_CONTEXT_KEY];
+}
+var os3, fs_path, fs10, TRANSIENT_CONTEXT_KEY, Settings;
+var init_settings = __esm({
+  "../toolkit-lib/lib/api/settings.ts"() {
+    "use strict";
+    os3 = __toESM(require("os"));
+    fs_path = __toESM(require("path"));
+    fs10 = __toESM(require_lib6());
+    init_toolkit_error();
+    init_util();
+    TRANSIENT_CONTEXT_KEY = "$dontSaveContext";
+    Settings = class _Settings {
+      constructor(settings = {}, readOnly = false) {
+        this.settings = settings;
+        this.readOnly = readOnly;
+      }
+      static {
+        __name(this, "Settings");
+      }
+      static mergeAll(...settings) {
+        let ret = new _Settings();
+        for (const setting of settings) {
+          ret = ret.merge(setting);
+        }
+        return ret;
+      }
+      async save(fileName) {
+        const expanded = expandHomeDir(fileName);
+        await fs10.writeJson(expanded, stripTransientValues(this.settings), {
+          spaces: 2
+        });
+        return this;
+      }
+      get all() {
+        return this.get([]);
+      }
+      merge(other) {
+        return new _Settings(deepMerge(this.settings, other.settings));
+      }
+      subSettings(keyPrefix) {
+        return new _Settings(this.get(keyPrefix) || {}, false);
+      }
+      makeReadOnly() {
+        return new _Settings(this.settings, true);
+      }
+      clear() {
+        if (this.readOnly) {
+          throw new ToolkitError("Cannot clear(): settings are readonly");
+        }
+        this.settings = {};
+      }
+      get empty() {
+        return Object.keys(this.settings).length === 0;
+      }
+      get(path40) {
+        return deepClone(deepGet(this.settings, path40));
+      }
+      set(path40, value) {
+        if (this.readOnly) {
+          throw new ToolkitError(`Can't set ${path40}: settings object is readonly`);
+        }
+        if (path40.length === 0) {
+          this.settings = value;
+        } else {
+          deepSet(this.settings, path40, value);
+        }
+        return this;
+      }
+      unset(path40) {
+        this.set(path40, void 0);
+      }
+    };
+    __name(expandHomeDir, "expandHomeDir");
+    __name(stripTransientValues, "stripTransientValues");
+    __name(isTransientValue, "isTransientValue");
+  }
+});
+
+// ../toolkit-lib/lib/api/context.ts
+var Context;
+var init_context = __esm({
+  "../toolkit-lib/lib/api/context.ts"() {
+    "use strict";
+    init_settings();
+    init_toolkit_error();
+    init_settings();
+    Context = class {
+      static {
+        __name(this, "Context");
+      }
+      bags;
+      fileNames;
+      constructor(...bags) {
+        this.bags = bags.length > 0 ? bags.map((b16) => b16.bag) : [new Settings()];
+        this.fileNames = bags.length > 0 ? bags.map((b16) => b16.fileName) : ["default"];
+      }
+      get keys() {
+        return Object.keys(this.all);
+      }
+      has(key) {
+        return this.keys.indexOf(key) > -1;
+      }
+      get all() {
+        let ret = new Settings();
+        for (const bag of [...this.bags].reverse()) {
+          ret = ret.merge(bag);
+        }
+        return ret.all;
+      }
+      get(key) {
+        for (const bag of this.bags) {
+          const v17 = bag.get([key]);
+          if (v17 !== void 0) {
+            return v17;
+          }
+        }
+        return void 0;
+      }
+      set(key, value) {
+        for (const bag of this.bags) {
+          if (bag.readOnly) {
+            continue;
+          }
+          bag.set([key], value);
+          value = void 0;
+        }
+      }
+      unset(key) {
+        this.set(key, void 0);
+      }
+      clear() {
+        for (const key of this.keys) {
+          this.unset(key);
+        }
+      }
+      /**
+       * Save a specific context file
+       */
+      async save(fileName) {
+        const index = this.fileNames.indexOf(fileName);
+        if (index === -1) {
+          return this;
+        }
+        const bag = this.bags[index];
+        if (bag.readOnly) {
+          throw new ToolkitError(`Context file ${fileName} is read only!`);
+        }
+        await bag.save(fileName);
+        return this;
+      }
+    };
+  }
+});
+
+// ../toolkit-lib/lib/api/cloud-assembly/context-store.ts
+function persistableContext(context) {
+  return Object.fromEntries(Object.entries(context).filter(([_2, value]) => !isTransientValue2(value)));
+}
+function isTransientValue2(x16) {
+  return x16 && typeof x16 === "object" && x16[TRANSIENT_CONTEXT_KEY];
+}
+async function settingsFromFile(filename) {
+  try {
+    const data2 = JSON.parse(await import_fs4.promises.readFile(filename, "utf-8"));
+    return new Settings(data2);
+  } catch (e16) {
+    if (e16.code === "ENOENT") {
+      return new Settings();
+    }
+    throw e16;
+  }
+}
+var import_fs4, os4, path10, CdkAppMultiContext, FileContext, MemoryContext;
+var init_context_store = __esm({
+  "../toolkit-lib/lib/api/cloud-assembly/context-store.ts"() {
+    "use strict";
+    import_fs4 = require("fs");
+    os4 = __toESM(require("os"));
+    path10 = __toESM(require("path"));
+    init_toolkit_error();
+    init_context();
+    init_settings();
+    CdkAppMultiContext = class {
+      constructor(appDirectory, commandlineContext) {
+        this.commandlineContext = commandlineContext;
+        this.configContextFile = path10.join(appDirectory, "cdk.json");
+        this.projectContextFile = path10.join(appDirectory, "cdk.context.json");
+        this.userConfigFile = path10.join(os4.homedir() ?? "/tmp", ".cdk.json");
+      }
+      static {
+        __name(this, "CdkAppMultiContext");
+      }
+      _context;
+      configContextFile;
+      projectContextFile;
+      userConfigFile;
+      async read() {
+        const context = await this.asyncInitialize();
+        return context.all;
+      }
+      async update(updates) {
+        const context = await this.asyncInitialize();
+        for (const [key, value] of Object.entries(updates)) {
+          context.set(key, value);
+        }
+        await context.save(this.projectContextFile);
+      }
+      /**
+       * Initialize the `Context` object
+       *
+       * This code all exists to reuse code that's already there, to minimize
+       * the chances of the new code behaving subtly differently than the
+       * old code.
+       *
+       * It might be most of this is unnecessary now...
+       */
+      async asyncInitialize() {
+        if (this._context) {
+          return this._context;
+        }
+        const contextSources = [
+          { bag: new Settings(this.commandlineContext, true) },
+          {
+            fileName: this.configContextFile,
+            bag: (await settingsFromFile(this.configContextFile)).subSettings(["context"]).makeReadOnly()
+          },
+          {
+            fileName: this.projectContextFile,
+            bag: await settingsFromFile(this.projectContextFile)
+          },
+          {
+            fileName: this.userConfigFile,
+            bag: (await settingsFromFile(this.userConfigFile)).subSettings(["context"]).makeReadOnly()
+          }
+        ];
+        this._context = new Context(...contextSources);
+        return this._context;
+      }
+    };
+    FileContext = class {
+      constructor(fileName) {
+        this.fileName = fileName;
+      }
+      static {
+        __name(this, "FileContext");
+      }
+      _cache;
+      async read() {
+        if (!this._cache) {
+          try {
+            this._cache = JSON.parse(await import_fs4.promises.readFile(this.fileName, "utf-8"));
+          } catch (e16) {
+            if (e16.code === "ENOENT") {
+              this._cache = {};
+            } else {
+              throw e16;
+            }
+          }
+        }
+        if (!this._cache || typeof this._cache !== "object") {
+          throw new ToolkitError(`${this.fileName} must contain an object, got: ${JSON.stringify(this._cache)}`);
+        }
+        return this._cache;
+      }
+      async update(updates) {
+        this._cache = {
+          ...await this.read(),
+          ...updates
+        };
+        const persistable = persistableContext(this._cache);
+        await import_fs4.promises.writeFile(this.fileName, JSON.stringify(persistable, void 0, 2), "utf-8");
+      }
+    };
+    MemoryContext = class {
+      static {
+        __name(this, "MemoryContext");
+      }
+      context = {};
+      constructor(initialContext) {
+        this.context = { ...initialContext };
+      }
+      read() {
+        return Promise.resolve(this.context);
+      }
+      update(updates) {
+        this.context = {
+          ...this.context,
+          ...updates
+        };
+        return Promise.resolve();
+      }
+    };
+    __name(persistableContext, "persistableContext");
+    __name(isTransientValue2, "isTransientValue");
+    __name(settingsFromFile, "settingsFromFile");
+  }
+});
+
+// ../toolkit-lib/lib/api/rwlock.ts
+async function readFileIfExists(filename) {
+  try {
+    return await import_fs5.promises.readFile(filename, { encoding: "utf-8" });
+  } catch (e16) {
+    if (e16.code === "ENOENT") {
+      return void 0;
+    }
+    throw e16;
+  }
+}
+async function writeFileAtomic(filename, contents) {
+  await import_fs5.promises.mkdir(path11.dirname(filename), { recursive: true });
+  const tmpFile = `${filename}.${process.pid}_${++tmpCounter}`;
+  await import_fs5.promises.writeFile(tmpFile, contents, { encoding: "utf-8" });
+  await import_fs5.promises.rename(tmpFile, filename);
+}
+async function deleteFile(filename) {
+  try {
+    await import_fs5.promises.unlink(filename);
+  } catch (e16) {
+    if (e16.code === "ENOENT") {
+      return;
+    }
+    throw e16;
+  }
+}
+function processExists(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (e16) {
+    return false;
+  }
+}
+var import_fs5, path11, RWLock, tmpCounter;
+var init_rwlock = __esm({
+  "../toolkit-lib/lib/api/rwlock.ts"() {
+    "use strict";
+    import_fs5 = require("fs");
+    path11 = __toESM(require("path"));
+    init_toolkit_error();
+    RWLock = class {
+      constructor(directory) {
+        this.directory = directory;
+        this.pidString = `${process.pid}`;
+        this.writerFile = path11.join(this.directory, "synth.lock");
+      }
+      static {
+        __name(this, "RWLock");
+      }
+      pidString;
+      writerFile;
+      readCounter = 0;
+      /**
+       * Acquire a writer lock.
+       *
+       * No other readers or writers must exist for the given directory.
+       */
+      async acquireWrite() {
+        await this.assertNoOtherWriters();
+        const readers = await this._currentReaders();
+        if (readers.length > 0) {
+          throw new ToolkitError(`Other CLIs (PID=${readers}) are currently reading from ${this.directory}. Invoke the CLI in sequence, or use '--output' to synth into different directories.`);
+        }
+        await writeFileAtomic(this.writerFile, this.pidString);
+        let released = false;
+        return {
+          release: /* @__PURE__ */ __name(async () => {
+            if (!released) {
+              await deleteFile(this.writerFile);
+              released = true;
+            }
+          }, "release"),
+          convertToReaderLock: /* @__PURE__ */ __name(async () => {
+            const ret = await this.doAcquireRead();
+            await deleteFile(this.writerFile);
+            return ret;
+          }, "convertToReaderLock")
+        };
+      }
+      /**
+       * Acquire a read lock
+       *
+       * Will fail if there are any writers.
+       */
+      async acquireRead() {
+        await this.assertNoOtherWriters();
+        return this.doAcquireRead();
+      }
+      /**
+       * Obtains the name fo a (new) `readerFile` to use. This includes a counter so
+       * that if multiple threads of the same PID attempt to concurrently acquire
+       * the same lock, they're guaranteed to use a different reader file name (only
+       * one thread will ever execute JS code at once, guaranteeing the readCounter
+       * is incremented "atomically" from the point of view of this PID.).
+       */
+      readerFile() {
+        return path11.join(this.directory, `read.${this.pidString}.${++this.readCounter}.lock`);
+      }
+      /**
+       * Do the actual acquiring of a read lock.
+       */
+      async doAcquireRead() {
+        const readerFile = this.readerFile();
+        await writeFileAtomic(readerFile, this.pidString);
+        let released = false;
+        return {
+          release: /* @__PURE__ */ __name(async () => {
+            if (!released) {
+              await deleteFile(readerFile);
+              released = true;
+            }
+          }, "release")
+        };
+      }
+      async assertNoOtherWriters() {
+        const writer = await this._currentWriter();
+        if (writer) {
+          throw new ToolkitError(`Another CLI (PID=${writer}) is currently synthing to ${this.directory}. Invoke the CLI in sequence, or use '--output' to synth into different directories.`);
+        }
+      }
+      /**
+       * Check the current writer (if any)
+       *
+       * Publicly accessible for testing purposes. Do not use.
+       *
+       * @internal
+       */
+      async _currentWriter() {
+        const contents = await readFileIfExists(this.writerFile);
+        if (!contents) {
+          return void 0;
+        }
+        const pid = parseInt(contents, 10);
+        if (!processExists(pid)) {
+          await deleteFile(this.writerFile);
+          return void 0;
+        }
+        return pid;
+      }
+      /**
+       * Check the current readers (if any)
+       *
+       * Publicly accessible for testing purposes. Do not use.
+       *
+       * @internal
+       */
+      async _currentReaders() {
+        const re = /^read\.([^.]+)\.[^.]+\.lock$/;
+        const ret = new Array();
+        let children;
+        try {
+          children = await import_fs5.promises.readdir(this.directory, { encoding: "utf-8" });
+        } catch (e16) {
+          if (e16.code === "ENOENT") {
+            return [];
+          }
+          throw e16;
+        }
+        for (const fname of children) {
+          const m16 = fname.match(re);
+          if (m16) {
+            const pid = parseInt(m16[1], 10);
+            if (processExists(pid)) {
+              ret.push(pid);
+            } else {
+              await deleteFile(path11.join(this.directory, fname));
+            }
+          }
+        }
+        return ret;
+      }
+    };
+    __name(readFileIfExists, "readFileIfExists");
+    tmpCounter = 0;
+    __name(writeFileAtomic, "writeFileAtomic");
+    __name(deleteFile, "deleteFile");
+    __name(processExists, "processExists");
+  }
+});
+
 // ../../../node_modules/@smithy/types/dist-cjs/index.js
 var require_dist_cjs = __commonJS({
   "../../../node_modules/@smithy/types/dist-cjs/index.js"(exports2) {
@@ -316709,12 +317294,12 @@ to input.params.ContentLength in bytes.
 });
 
 // ../toolkit-lib/lib/api/aws-auth/account-cache.ts
-var path10, fs10, AccountAccessKeyCache;
+var path12, fs13, AccountAccessKeyCache;
 var init_account_cache = __esm({
   "../toolkit-lib/lib/api/aws-auth/account-cache.ts"() {
     "use strict";
-    path10 = __toESM(require("path"));
-    fs10 = __toESM(require_lib6());
+    path12 = __toESM(require("path"));
+    fs13 = __toESM(require_lib6());
     init_util();
     AccountAccessKeyCache = class _AccountAccessKeyCache {
       static {
@@ -316728,7 +317313,7 @@ var init_account_cache = __esm({
        * The default path used for the accounts access key cache
        */
       static get DEFAULT_PATH() {
-        return path10.join(cdkCacheDir(), "accounts_partitions.json");
+        return path12.join(cdkCacheDir(), "accounts_partitions.json");
       }
       cacheFile;
       debug;
@@ -316778,7 +317363,7 @@ var init_account_cache = __esm({
       }
       async loadMap() {
         try {
-          return await fs10.readJson(this.cacheFile);
+          return await fs13.readJson(this.cacheFile);
         } catch (e16) {
           if (e16.code === "ENOENT" || e16.code === "EACCES") {
             return {};
@@ -316791,8 +317376,8 @@ var init_account_cache = __esm({
       }
       async saveMap(map2) {
         try {
-          await fs10.ensureFile(this.cacheFile);
-          await fs10.writeJson(this.cacheFile, map2, { spaces: 2 });
+          await fs13.ensureFile(this.cacheFile);
+          await fs13.writeJson(this.cacheFile, map2, { spaces: 2 });
         } catch (e16) {
           if (e16.code === "ENOENT" || e16.code === "EACCES" || e16.code === "EROFS") {
             return;
@@ -316878,19 +317463,19 @@ var init_tracing = __esm({
 // ../toolkit-lib/lib/api/aws-auth/util.ts
 function readIfPossible(filename) {
   try {
-    if (!fs11.pathExistsSync(filename)) {
+    if (!fs14.pathExistsSync(filename)) {
       return void 0;
     }
-    return fs11.readFileSync(filename, { encoding: "utf-8" });
+    return fs14.readFileSync(filename, { encoding: "utf-8" });
   } catch (e16) {
     return void 0;
   }
 }
-var fs11;
+var fs14;
 var init_util2 = __esm({
   "../toolkit-lib/lib/api/aws-auth/util.ts"() {
     "use strict";
-    fs11 = __toESM(require_lib6());
+    fs14 = __toESM(require_lib6());
     __name(readIfPossible, "readIfPossible");
   }
 });
@@ -316898,16 +317483,16 @@ var init_util2 = __esm({
 // ../toolkit-lib/lib/api/aws-auth/user-agent.ts
 function defaultCliUserAgent() {
   const root = bundledPackageRootDir(__dirname, false);
-  const pkg = JSON.parse((root ? readIfPossible(path11.join(root, "package.json")) : void 0) ?? "{}");
-  const name = pkg.name ?? path11.basename(process.argv[1] ?? "cdk-cli");
+  const pkg = JSON.parse((root ? readIfPossible(path13.join(root, "package.json")) : void 0) ?? "{}");
+  const name = pkg.name ?? path13.basename(process.argv[1] ?? "cdk-cli");
   const version = pkg.version ?? "<unknown>";
   return `${name}/${version}`;
 }
-var path11;
+var path13;
 var init_user_agent = __esm({
   "../toolkit-lib/lib/api/aws-auth/user-agent.ts"() {
     "use strict";
-    path11 = __toESM(require("path"));
+    path13 = __toESM(require("path"));
     init_util2();
     init_util();
     __name(defaultCliUserAgent, "defaultCliUserAgent");
@@ -320753,7 +321338,7 @@ var init_plugin2 = __esm({
 // ../toolkit-lib/lib/api/aws-auth/sdk-provider.ts
 function safeUsername() {
   try {
-    return os3.userInfo().username.replace(/[^\w+=,.@-]/g, "@");
+    return os5.userInfo().username.replace(/[^\w+=,.@-]/g, "@");
   } catch {
     return "noname";
   }
@@ -320798,11 +321383,11 @@ async function initContextProviderSdk(aws, options) {
   };
   return (await aws.forEnvironment(import_cloud_assembly_api.EnvironmentUtils.make(account, region), 0 /* ForReading */, creds)).sdk;
 }
-var os3, import_cloud_assembly_api, import_credential_providers2, CACHED_ACCOUNT, SdkProvider;
+var os5, import_cloud_assembly_api, import_credential_providers2, CACHED_ACCOUNT, SdkProvider;
 var init_sdk_provider = __esm({
   "../toolkit-lib/lib/api/aws-auth/sdk-provider.ts"() {
     "use strict";
-    os3 = __toESM(require("os"));
+    os5 = __toESM(require("os"));
     import_cloud_assembly_api = __toESM(require_lib3());
     import_credential_providers2 = __toESM(require_dist_cjs186());
     init_awscli_compatible();
@@ -322206,184 +322791,12 @@ var init_vpcs = __esm({
   }
 });
 
-// ../toolkit-lib/lib/api/settings.ts
-function expandHomeDir(x16) {
-  if (x16.startsWith("~")) {
-    return fs_path.join(os4.homedir(), x16.slice(1));
-  }
-  return x16;
-}
-function stripTransientValues(obj) {
-  const ret = {};
-  for (const [key, value] of Object.entries(obj)) {
-    if (!isTransientValue(value)) {
-      ret[key] = value;
-    }
-  }
-  return ret;
-}
-function isTransientValue(value) {
-  return typeof value === "object" && value !== null && value[TRANSIENT_CONTEXT_KEY];
-}
-var os4, fs_path, fs12, TRANSIENT_CONTEXT_KEY, Settings;
-var init_settings = __esm({
-  "../toolkit-lib/lib/api/settings.ts"() {
-    "use strict";
-    os4 = __toESM(require("os"));
-    fs_path = __toESM(require("path"));
-    fs12 = __toESM(require_lib6());
-    init_toolkit_error();
-    init_util();
-    TRANSIENT_CONTEXT_KEY = "$dontSaveContext";
-    Settings = class _Settings {
-      constructor(settings = {}, readOnly = false) {
-        this.settings = settings;
-        this.readOnly = readOnly;
-      }
-      static {
-        __name(this, "Settings");
-      }
-      static mergeAll(...settings) {
-        let ret = new _Settings();
-        for (const setting of settings) {
-          ret = ret.merge(setting);
-        }
-        return ret;
-      }
-      async save(fileName) {
-        const expanded = expandHomeDir(fileName);
-        await fs12.writeJson(expanded, stripTransientValues(this.settings), {
-          spaces: 2
-        });
-        return this;
-      }
-      get all() {
-        return this.get([]);
-      }
-      merge(other) {
-        return new _Settings(deepMerge(this.settings, other.settings));
-      }
-      subSettings(keyPrefix) {
-        return new _Settings(this.get(keyPrefix) || {}, false);
-      }
-      makeReadOnly() {
-        return new _Settings(this.settings, true);
-      }
-      clear() {
-        if (this.readOnly) {
-          throw new ToolkitError("Cannot clear(): settings are readonly");
-        }
-        this.settings = {};
-      }
-      get empty() {
-        return Object.keys(this.settings).length === 0;
-      }
-      get(path40) {
-        return deepClone(deepGet(this.settings, path40));
-      }
-      set(path40, value) {
-        if (this.readOnly) {
-          throw new ToolkitError(`Can't set ${path40}: settings object is readonly`);
-        }
-        if (path40.length === 0) {
-          this.settings = value;
-        } else {
-          deepSet(this.settings, path40, value);
-        }
-        return this;
-      }
-      unset(path40) {
-        this.set(path40, void 0);
-      }
-    };
-    __name(expandHomeDir, "expandHomeDir");
-    __name(stripTransientValues, "stripTransientValues");
-    __name(isTransientValue, "isTransientValue");
-  }
-});
-
-// ../toolkit-lib/lib/api/context.ts
-var Context;
-var init_context = __esm({
-  "../toolkit-lib/lib/api/context.ts"() {
-    "use strict";
-    init_settings();
-    init_toolkit_error();
-    init_settings();
-    Context = class {
-      static {
-        __name(this, "Context");
-      }
-      bags;
-      fileNames;
-      constructor(...bags) {
-        this.bags = bags.length > 0 ? bags.map((b16) => b16.bag) : [new Settings()];
-        this.fileNames = bags.length > 0 ? bags.map((b16) => b16.fileName) : ["default"];
-      }
-      get keys() {
-        return Object.keys(this.all);
-      }
-      has(key) {
-        return this.keys.indexOf(key) > -1;
-      }
-      get all() {
-        let ret = new Settings();
-        for (const bag of [...this.bags].reverse()) {
-          ret = ret.merge(bag);
-        }
-        return ret.all;
-      }
-      get(key) {
-        for (const bag of this.bags) {
-          const v17 = bag.get([key]);
-          if (v17 !== void 0) {
-            return v17;
-          }
-        }
-        return void 0;
-      }
-      set(key, value) {
-        for (const bag of this.bags) {
-          if (bag.readOnly) {
-            continue;
-          }
-          bag.set([key], value);
-          value = void 0;
-        }
-      }
-      unset(key) {
-        this.set(key, void 0);
-      }
-      clear() {
-        for (const key of this.keys) {
-          this.unset(key);
-        }
-      }
-      /**
-       * Save a specific context file
-       */
-      async save(fileName) {
-        const index = this.fileNames.indexOf(fileName);
-        if (index === -1) {
-          return this;
-        }
-        const bag = this.bags[index];
-        if (bag.readOnly) {
-          throw new ToolkitError(`Context file ${fileName} is read only!`);
-        }
-        await bag.save(fileName);
-        return this;
-      }
-    };
-  }
-});
-
 // ../toolkit-lib/lib/api/notices/cached-data-source.ts
-var fs13, TIME_TO_LIVE_SUCCESS, TIME_TO_LIVE_ERROR, CachedDataSource;
+var fs15, TIME_TO_LIVE_SUCCESS, TIME_TO_LIVE_ERROR, CachedDataSource;
 var init_cached_data_source = __esm({
   "../toolkit-lib/lib/api/notices/cached-data-source.ts"() {
     "use strict";
-    fs13 = __toESM(require_lib6());
+    fs15 = __toESM(require_lib6());
     init_toolkit_error();
     TIME_TO_LIVE_SUCCESS = 60 * 60 * 1e3;
     TIME_TO_LIVE_ERROR = 1 * 60 * 1e3;
@@ -322433,7 +322846,7 @@ var init_cached_data_source = __esm({
           notices: []
         };
         try {
-          return fs13.existsSync(this.fileName) ? await fs13.readJSON(this.fileName) : defaultValue;
+          return fs15.existsSync(this.fileName) ? await fs15.readJSON(this.fileName) : defaultValue;
         } catch (e16) {
           await this.ioHelper.defaults.debug(`Failed to load notices from cache: ${e16}`);
           return defaultValue;
@@ -322441,8 +322854,8 @@ var init_cached_data_source = __esm({
       }
       async save(cached3) {
         try {
-          await fs13.ensureFile(this.fileName);
-          await fs13.writeJSON(this.fileName, cached3);
+          await fs15.ensureFile(this.fileName);
+          await fs15.writeJSON(this.fileName, cached3);
         } catch (e16) {
           await this.ioHelper.defaults.debug(`Failed to store notices in the cache: ${e16}`);
         }
@@ -322463,7 +322876,7 @@ async function loadTree(assembly, trace3) {
   try {
     const outdir = assembly.directory;
     const fileName = assembly.tree()?.file;
-    return fileName ? fs14.readJSONSync(path12.join(outdir, fileName)).tree : {};
+    return fileName ? fs16.readJSONSync(path14.join(outdir, fileName)).tree : {};
   } catch (e16) {
     await trace3(`Failed to get tree.json file: ${e16}. Proceeding with empty tree.`);
     return void 0;
@@ -322471,18 +322884,18 @@ async function loadTree(assembly, trace3) {
 }
 async function loadTreeFromDir(outdir, trace3) {
   try {
-    return fs14.readJSONSync(path12.join(outdir, "tree.json")).tree;
+    return fs16.readJSONSync(path14.join(outdir, "tree.json")).tree;
   } catch (e16) {
     await trace3(`Failed to get tree.json file: ${e16}. Proceeding with empty tree.`);
     return void 0;
   }
 }
-var path12, fs14;
+var path14, fs16;
 var init_tree = __esm({
   "../toolkit-lib/lib/api/tree.ts"() {
     "use strict";
-    path12 = __toESM(require("node:path"));
-    fs14 = __toESM(require_lib6());
+    path14 = __toESM(require("node:path"));
+    fs16 = __toESM(require_lib6());
     __name(some, "some");
     __name(loadTree, "loadTree");
     __name(loadTreeFromDir, "loadTreeFromDir");
@@ -322678,16 +323091,16 @@ var init_filter = __esm({
 });
 
 // ../toolkit-lib/lib/api/network-detector/network-detector.ts
-var https, path13, fs15, TIME_TO_LIVE_SUCCESS2, CACHE_FILE_PATH, NetworkDetector;
+var https, path15, fs17, TIME_TO_LIVE_SUCCESS2, CACHE_FILE_PATH, NetworkDetector;
 var init_network_detector = __esm({
   "../toolkit-lib/lib/api/network-detector/network-detector.ts"() {
     "use strict";
     https = __toESM(require("node:https"));
-    path13 = __toESM(require("path"));
-    fs15 = __toESM(require_lib6());
+    path15 = __toESM(require("path"));
+    fs17 = __toESM(require_lib6());
     init_util();
     TIME_TO_LIVE_SUCCESS2 = 60 * 60 * 1e3;
-    CACHE_FILE_PATH = path13.join(cdkCacheDir(), "connection.json");
+    CACHE_FILE_PATH = path15.join(cdkCacheDir(), "connection.json");
     NetworkDetector = class _NetworkDetector {
       static {
         __name(this, "NetworkDetector");
@@ -322726,15 +323139,15 @@ var init_network_detector = __esm({
           hasConnectivity: false
         };
         try {
-          return fs15.existsSync(CACHE_FILE_PATH) ? await fs15.readJSON(CACHE_FILE_PATH) : defaultValue;
+          return fs17.existsSync(CACHE_FILE_PATH) ? await fs17.readJSON(CACHE_FILE_PATH) : defaultValue;
         } catch {
           return defaultValue;
         }
       }
       static async save(cached3) {
         try {
-          await fs15.ensureFile(CACHE_FILE_PATH);
-          await fs15.writeJSON(CACHE_FILE_PATH, cached3);
+          await fs17.ensureFile(CACHE_FILE_PATH);
+          await fs17.writeJSON(CACHE_FILE_PATH, cached3);
         } catch {
         }
       }
@@ -322792,7 +323205,7 @@ var init_web_data_source = __esm({
         if (!hasConnectivity) {
           throw new ToolkitError("No internet connectivity detected");
         }
-        const timeout = process.env.TESTING_CDK ? 3e4 : 3e3;
+        const timeout = process.env.CDK_NOTICES_TIMEOUT !== void 0 ? parseInt(process.env.CDK_NOTICES_TIMEOUT, 10) : process.env.TESTING_CDK ? 3e4 : 3e3;
         const options = {
           agent: this.agent
         };
@@ -322849,17 +323262,17 @@ var init_web_data_source = __esm({
 });
 
 // ../toolkit-lib/lib/api/notices/notices.ts
-var path14, CACHE_FILE_PATH2, Notices;
+var path16, CACHE_FILE_PATH2, Notices;
 var init_notices = __esm({
   "../toolkit-lib/lib/api/notices/notices.ts"() {
     "use strict";
-    path14 = __toESM(require("path"));
+    path16 = __toESM(require("path"));
     init_util();
     init_cached_data_source();
     init_filter();
     init_web_data_source();
     init_private();
-    CACHE_FILE_PATH2 = path14.join(cdkCacheDir(), "notices.json");
+    CACHE_FILE_PATH2 = path16.join(cdkCacheDir(), "notices.json");
     Notices = class _Notices {
       static {
         __name(this, "Notices");
@@ -323064,8 +323477,8 @@ var init_progress = __esm({
 
 // ../cdk-assets-lib/lib/private/docker-credentials.ts
 function cdkCredentialsConfigFile() {
-  return process.env.CDK_DOCKER_CREDS_FILE ?? path15.join(
-    (os5.userInfo().homedir ?? os5.homedir()).trim() || "/",
+  return process.env.CDK_DOCKER_CREDS_FILE ?? path17.join(
+    (os6.userInfo().homedir ?? os6.homedir()).trim() || "/",
     ".cdk",
     "cdk-docker-creds.json"
   );
@@ -323074,7 +323487,7 @@ function cdkCredentialsConfig() {
   if (!_cdkCredentials) {
     try {
       _cdkCredentials = JSON.parse(
-        fs16.readFileSync(cdkCredentialsConfigFile(), { encoding: "utf-8" })
+        fs18.readFileSync(cdkCredentialsConfigFile(), { encoding: "utf-8" })
       );
     } catch {
     }
@@ -323100,13 +323513,13 @@ async function obtainEcrCredentials(ecr, eventEmitter) {
     endpoint: authData[0].proxyEndpoint
   };
 }
-var fs16, os5, path15, _cdkCredentials;
+var fs18, os6, path17, _cdkCredentials;
 var init_docker_credentials = __esm({
   "../cdk-assets-lib/lib/private/docker-credentials.ts"() {
     "use strict";
-    fs16 = __toESM(require("fs"));
-    os5 = __toESM(require("os"));
-    path15 = __toESM(require("path"));
+    fs18 = __toESM(require("fs"));
+    os6 = __toESM(require("os"));
+    path17 = __toESM(require("path"));
     init_progress();
     __name(cdkCredentialsConfigFile, "cdkCredentialsConfigFile");
     __name(cdkCredentialsConfig, "cdkCredentialsConfig");
@@ -323250,13 +323663,13 @@ function getDockerCmd() {
 function flatten3(x16) {
   return Array.prototype.concat([], ...x16);
 }
-var fs17, os6, path16, Docker, DockerFactory;
+var fs19, os7, path18, Docker, DockerFactory;
 var init_docker = __esm({
   "../cdk-assets-lib/lib/private/docker.ts"() {
     "use strict";
-    fs17 = __toESM(require("fs"));
-    os6 = __toESM(require("os"));
-    path16 = __toESM(require("path"));
+    fs19 = __toESM(require("fs"));
+    os7 = __toESM(require("os"));
+    path18 = __toESM(require("path"));
     init_docker_credentials();
     init_shell();
     init_util3();
@@ -323364,13 +323777,13 @@ var init_docker = __esm({
         if (!config) {
           return false;
         }
-        this.configDir = fs17.mkdtempSync(path16.join(os6.tmpdir(), "cdkDockerConfig"));
+        this.configDir = fs19.mkdtempSync(path18.join(os7.tmpdir(), "cdkDockerConfig"));
         const domains = Object.keys(config.domainCredentials);
         const credHelpers = domains.reduce((map2, domain) => {
           map2[domain] = "cdk-assets";
           return map2;
         }, {});
-        fs17.writeFileSync(path16.join(this.configDir, "config.json"), JSON.stringify({ credHelpers }), {
+        fs19.writeFileSync(path18.join(this.configDir, "config.json"), JSON.stringify({ credHelpers }), {
           encoding: "utf-8"
         });
         return true;
@@ -323386,7 +323799,7 @@ var init_docker = __esm({
       }
       async execute(args, options = {}) {
         const configArgs = this.configDir ? ["--config", this.configDir] : [];
-        const pathToCdkAssets = path16.resolve(__dirname, "..", "..", "bin");
+        const pathToCdkAssets = path18.resolve(__dirname, "..", "..", "bin");
         const shellEventPublisher = shellEventPublisherFromEventEmitter(this.eventEmitter);
         try {
           await shell([getDockerCmd(), ...configArgs, ...args], {
@@ -323395,7 +323808,7 @@ var init_docker = __esm({
             env: {
               ...process.env,
               ...options.env,
-              PATH: `${pathToCdkAssets}${path16.delimiter}${options.env?.PATH ?? process.env.PATH}`
+              PATH: `${pathToCdkAssets}${path18.delimiter}${options.env?.PATH ?? process.env.PATH}`
             }
           });
         } catch (e16) {
@@ -323535,11 +323948,11 @@ async function repositoryUri(ecr, repositoryName) {
     return void 0;
   }
 }
-var path17, ContainerImageAssetHandler, ContainerImageBuilder;
+var path19, ContainerImageAssetHandler, ContainerImageBuilder;
 var init_container_images = __esm({
   "../cdk-assets-lib/lib/private/handlers/container-images.ts"() {
     "use strict";
-    path17 = __toESM(require("path"));
+    path19 = __toESM(require("path"));
     init_client_options();
     init_progress();
     init_placeholders2();
@@ -323710,7 +324123,7 @@ var init_container_images = __esm({
             `'directory' is expected in the DockerImage asset source, got: ${JSON.stringify(source)}`
           );
         }
-        const fullPath = path17.resolve(this.workDir, source.directory);
+        const fullPath = path19.resolve(this.workDir, source.directory);
         this.host.emitMessage("build" /* BUILD */, `Building Docker image at ${fullPath}`);
         await this.docker.build({
           directory: fullPath,
@@ -323834,15 +324247,15 @@ function writeZipFile(directory, outputFile) {
       cwd: directory
     };
     const files = sync("**", globOptions);
-    const output = (0, import_fs4.createWriteStream)(outputFile);
+    const output = (0, import_fs6.createWriteStream)(outputFile);
     const archive = archiver2("zip");
     archive.on("warning", fail);
     archive.on("error", fail);
     output.once("close", ok);
     archive.pipe(output);
     for (const file of files) {
-      const fullPath = path18.resolve(directory, file);
-      const [data2, stat6] = await Promise.all([import_fs4.promises.readFile(fullPath), import_fs4.promises.stat(fullPath)]);
+      const fullPath = path20.resolve(directory, file);
+      const [data2, stat6] = await Promise.all([import_fs6.promises.readFile(fullPath), import_fs6.promises.stat(fullPath)]);
       archive.append(data2, {
         name: file,
         date: /* @__PURE__ */ new Date("1980-01-01T00:00:00.000Z"),
@@ -323858,7 +324271,7 @@ async function moveIntoPlace(source, target, eventEmitter) {
   let attempts = 5;
   while (true) {
     try {
-      await import_fs4.promises.rename(source, target);
+      await import_fs6.promises.rename(source, target);
       return;
     } catch (e16) {
       if (e16.code !== "EPERM" || attempts-- <= 0) {
@@ -323876,12 +324289,12 @@ function sleep(ms) {
 function randomString() {
   return Math.random().toString(36).replace(/[^a-z0-9]+/g, "");
 }
-var import_fs4, path18, archiver2;
+var import_fs6, path20, archiver2;
 var init_archive2 = __esm({
   "../cdk-assets-lib/lib/private/archive.ts"() {
     "use strict";
-    import_fs4 = require("fs");
-    path18 = __toESM(require("path"));
+    import_fs6 = require("fs");
+    path20 = __toESM(require("path"));
     init_esm10();
     archiver2 = require_archiver();
     __name(zipDirectory, "zipDirectory");
@@ -323904,12 +324317,12 @@ async function pathExists(pathName) {
     return false;
   }
 }
-var fs19, pfs;
+var fs21, pfs;
 var init_fs_extra = __esm({
   "../cdk-assets-lib/lib/private/fs-extra.ts"() {
     "use strict";
-    fs19 = __toESM(require("fs"));
-    pfs = fs19.promises;
+    fs21 = __toESM(require("fs"));
+    pfs = fs21.promises;
     __name(pathExists, "pathExists");
   }
 });
@@ -323933,12 +324346,12 @@ async function cached2(cache16, key, factory) {
   cache16.set(key, fresh);
   return fresh;
 }
-var import_fs5, path19, import_cloud_assembly_schema3, mime, EMPTY_ZIP_FILE_SIZE, FileAssetHandler, BucketInformation;
+var import_fs7, path21, import_cloud_assembly_schema3, mime, EMPTY_ZIP_FILE_SIZE, FileAssetHandler, BucketInformation;
 var init_files = __esm({
   "../cdk-assets-lib/lib/private/handlers/files.ts"() {
     "use strict";
-    import_fs5 = require("fs");
-    path19 = __toESM(require("path"));
+    import_fs7 = require("fs");
+    path21 = __toESM(require("path"));
     import_cloud_assembly_schema3 = __toESM(require_lib2());
     mime = __toESM(require_mime());
     init_client_options();
@@ -323953,7 +324366,7 @@ var init_files = __esm({
         this.workDir = workDir;
         this.asset = asset;
         this.host = host;
-        this.fileCacheRoot = path19.join(workDir, ".cache");
+        this.fileCacheRoot = path21.join(workDir, ".cache");
       }
       static {
         __name(this, "FileAssetHandler");
@@ -324067,7 +324480,7 @@ var init_files = __esm({
           {
             Bucket: destination.bucketName,
             Key: destination.objectKey,
-            Body: (0, import_fs5.createReadStream)(publishFile.packagedPath),
+            Body: (0, import_fs7.createReadStream)(publishFile.packagedPath),
             ContentType: publishFile.contentType,
             ChecksumAlgorithm: "SHA256"
           },
@@ -324081,11 +324494,11 @@ var init_files = __esm({
             `'path' is expected in the File asset source, got: ${JSON.stringify(source)}`
           );
         }
-        const fullPath = path19.resolve(this.workDir, source.path);
+        const fullPath = path21.resolve(this.workDir, source.path);
         if (source.packaging === import_cloud_assembly_schema3.FileAssetPackaging.ZIP_DIRECTORY) {
           const contentType = "application/zip";
-          await import_fs5.promises.mkdir(this.fileCacheRoot, { recursive: true });
-          const packagedPath = path19.join(this.fileCacheRoot, `${this.asset.id.assetId}.zip`);
+          await import_fs7.promises.mkdir(this.fileCacheRoot, { recursive: true });
+          const packagedPath = path21.join(this.fileCacheRoot, `${this.asset.id.assetId}.zip`);
           if (await pathExists(packagedPath)) {
             this.host.emitMessage("cached" /* CACHED */, `From cache ${packagedPath}`);
             return { packagedPath, contentType };
@@ -324226,12 +324639,12 @@ function prefixTreeChars(xs, prefix = "") {
   }
   return ret;
 }
-var fs21, path20, import_cloud_assembly_schema4, AssetManifest, ASSET_TYPES, FileManifestEntry, DockerImageManifestEntry, DestinationIdentifier, DestinationPattern;
+var fs23, path22, import_cloud_assembly_schema4, AssetManifest, ASSET_TYPES, FileManifestEntry, DockerImageManifestEntry, DestinationIdentifier, DestinationPattern;
 var init_asset_manifest = __esm({
   "../cdk-assets-lib/lib/asset-manifest.ts"() {
     "use strict";
-    fs21 = __toESM(require("fs"));
-    path20 = __toESM(require("path"));
+    fs23 = __toESM(require("fs"));
+    path22 = __toESM(require("path"));
     import_cloud_assembly_schema4 = __toESM(require_lib2());
     AssetManifest = class _AssetManifest {
       constructor(directory, manifest) {
@@ -324253,7 +324666,7 @@ var init_asset_manifest = __esm({
       static fromFile(fileName) {
         try {
           const obj = import_cloud_assembly_schema4.Manifest.loadAssetManifest(fileName);
-          return new _AssetManifest(path20.dirname(fileName), obj);
+          return new _AssetManifest(path22.dirname(fileName), obj);
         } catch (e16) {
           throw new Error(`Cannot read asset manifest '${fileName}': ${e16.message}`);
         }
@@ -324266,12 +324679,12 @@ var init_asset_manifest = __esm({
       static fromPath(filePath) {
         let st;
         try {
-          st = fs21.statSync(filePath);
+          st = fs23.statSync(filePath);
         } catch (e16) {
           throw new Error(`Cannot read asset manifest at '${filePath}': ${e16.message}`);
         }
         if (st.isDirectory()) {
-          return _AssetManifest.fromFile(path20.join(filePath, _AssetManifest.DEFAULT_FILENAME));
+          return _AssetManifest.fromFile(path22.join(filePath, _AssetManifest.DEFAULT_FILENAME));
         }
         return _AssetManifest.fromFile(filePath);
       }
@@ -324732,16 +325145,16 @@ __export(aws_exports, {
 });
 function safeUsername2() {
   try {
-    return os7.userInfo().username.replace(/[^\w+=,.@-]/g, "@");
+    return os8.userInfo().username.replace(/[^\w+=,.@-]/g, "@");
   } catch {
     return "noname";
   }
 }
-var os7, import_client_ecr2, import_client_s32, import_client_secrets_manager2, import_client_sts2, import_credential_providers3, import_lib_storage2, import_config_resolver31, import_node_config_provider16, USER_AGENT, DefaultAwsClient;
+var os8, import_client_ecr2, import_client_s32, import_client_secrets_manager2, import_client_sts2, import_credential_providers3, import_lib_storage2, import_config_resolver31, import_node_config_provider16, USER_AGENT, DefaultAwsClient;
 var init_aws = __esm({
   "../cdk-assets-lib/lib/aws.ts"() {
     "use strict";
-    os7 = __toESM(require("os"));
+    os8 = __toESM(require("os"));
     import_client_ecr2 = __toESM(require_dist_cjs117());
     import_client_s32 = __toESM(require_dist_cjs156());
     import_client_secrets_manager2 = __toESM(require_dist_cjs157());
@@ -325430,8 +325843,8 @@ Run the following command in order to setup an S3 bucket in this environment, an
   let templateFile = stack.templateFile;
   if (overrideTemplate) {
     templateFile = `${stack.templateFile}-${templateHash}.yaml`;
-    const templateFilePath = path21.join(stack.assembly.directory, templateFile);
-    await fs22.writeFile(templateFilePath, templateJson, { encoding: "utf-8" });
+    const templateFilePath = path23.join(stack.assembly.directory, templateFile);
+    await fs24.writeFile(templateFilePath, templateJson, { encoding: "utf-8" });
   }
   assetManifest.addFileAsset(
     templateHash,
@@ -325483,12 +325896,12 @@ function setEnv(name, value) {
     delete process.env[name];
   }
 }
-var fs22, path21, util4, import_cloud_assembly_api5, import_client_s33, import_middleware_endpoint37, chalk4, LARGE_TEMPLATE_SIZE_KB;
+var fs24, path23, util4, import_cloud_assembly_api5, import_client_s33, import_middleware_endpoint37, chalk4, LARGE_TEMPLATE_SIZE_KB;
 var init_template_body_parameter = __esm({
   "../toolkit-lib/lib/api/cloudformation/template-body-parameter.ts"() {
     "use strict";
-    fs22 = __toESM(require("node:fs/promises"));
-    path21 = __toESM(require("node:path"));
+    fs24 = __toESM(require("node:fs/promises"));
+    path23 = __toESM(require("node:path"));
     util4 = __toESM(require("node:util"));
     import_cloud_assembly_api5 = __toESM(require_lib3());
     import_client_s33 = __toESM(require_dist_cjs156());
@@ -326191,11 +326604,11 @@ async function loadNestedStacks(rootStackArtifact, sdk, parentTemplates) {
   return nestedStacks;
 }
 async function getNestedStackTemplates(rootStackArtifact, nestedTemplateAssetPath, nestedStackLogicalId, listStackResources, sdk) {
-  const nestedTemplatePath = path22.join(rootStackArtifact.assembly.directory, nestedTemplateAssetPath);
+  const nestedTemplatePath = path24.join(rootStackArtifact.assembly.directory, nestedTemplateAssetPath);
   const nestedStackArn = await getNestedStackArn(nestedStackLogicalId, listStackResources);
   const deployedStackName = nestedStackArn?.slice(nestedStackArn.indexOf("/") + 1, nestedStackArn.lastIndexOf("/"));
   return {
-    generatedTemplate: JSON.parse(fs23.readFileSync(nestedTemplatePath, "utf-8")),
+    generatedTemplate: JSON.parse(fs25.readFileSync(nestedTemplatePath, "utf-8")),
     deployedTemplate: deployedStackName ? await loadCurrentStackTemplate(deployedStackName, sdk) : {},
     deployedStackName
   };
@@ -326214,12 +326627,12 @@ async function getNestedStackArn(nestedStackLogicalId, listStackResources) {
 function isCdkManagedNestedStack(stackResource) {
   return stackResource.Type === "AWS::CloudFormation::Stack" && stackResource.Metadata && stackResource.Metadata["aws:asset:path"];
 }
-var path22, fs23;
+var path24, fs25;
 var init_nested_stack_helpers = __esm({
   "../toolkit-lib/lib/api/cloudformation/nested-stack-helpers.ts"() {
     "use strict";
-    path22 = __toESM(require("path"));
-    fs23 = __toESM(require_lib6());
+    path24 = __toESM(require("path"));
+    fs25 = __toESM(require_lib6());
     init_evaluate_cloudformation_template();
     init_stack_helpers();
     init_util();
@@ -327396,6 +327809,864 @@ var init_context_aware_source = __esm({
   }
 });
 
+// ../toolkit-lib/node_modules/split2/index.js
+var require_split2 = __commonJS({
+  "../toolkit-lib/node_modules/split2/index.js"(exports2, module2) {
+    "use strict";
+    var { Transform } = require("stream");
+    var { StringDecoder: StringDecoder3 } = require("string_decoder");
+    var kLast = /* @__PURE__ */ Symbol("last");
+    var kDecoder = /* @__PURE__ */ Symbol("decoder");
+    function transform(chunk, enc, cb) {
+      let list2;
+      if (this.overflow) {
+        const buf = this[kDecoder].write(chunk);
+        list2 = buf.split(this.matcher);
+        if (list2.length === 1) return cb();
+        list2.shift();
+        this.overflow = false;
+      } else {
+        this[kLast] += this[kDecoder].write(chunk);
+        list2 = this[kLast].split(this.matcher);
+      }
+      this[kLast] = list2.pop();
+      for (let i16 = 0; i16 < list2.length; i16++) {
+        try {
+          push(this, this.mapper(list2[i16]));
+        } catch (error4) {
+          return cb(error4);
+        }
+      }
+      this.overflow = this[kLast].length > this.maxLength;
+      if (this.overflow && !this.skipOverflow) {
+        cb(new Error("maximum buffer reached"));
+        return;
+      }
+      cb();
+    }
+    __name(transform, "transform");
+    function flush(cb) {
+      this[kLast] += this[kDecoder].end();
+      if (this[kLast]) {
+        try {
+          push(this, this.mapper(this[kLast]));
+        } catch (error4) {
+          return cb(error4);
+        }
+      }
+      cb();
+    }
+    __name(flush, "flush");
+    function push(self2, val) {
+      if (val !== void 0) {
+        self2.push(val);
+      }
+    }
+    __name(push, "push");
+    function noop(incoming) {
+      return incoming;
+    }
+    __name(noop, "noop");
+    function split2(matcher, mapper, options) {
+      matcher = matcher || /\r?\n/;
+      mapper = mapper || noop;
+      options = options || {};
+      switch (arguments.length) {
+        case 1:
+          if (typeof matcher === "function") {
+            mapper = matcher;
+            matcher = /\r?\n/;
+          } else if (typeof matcher === "object" && !(matcher instanceof RegExp) && !matcher[Symbol.split]) {
+            options = matcher;
+            matcher = /\r?\n/;
+          }
+          break;
+        case 2:
+          if (typeof matcher === "function") {
+            options = mapper;
+            mapper = matcher;
+            matcher = /\r?\n/;
+          } else if (typeof mapper === "object") {
+            options = mapper;
+            mapper = noop;
+          }
+      }
+      options = Object.assign({}, options);
+      options.autoDestroy = true;
+      options.transform = transform;
+      options.flush = flush;
+      options.readableObjectMode = true;
+      const stream2 = new Transform(options);
+      stream2[kLast] = "";
+      stream2[kDecoder] = new StringDecoder3("utf8");
+      stream2.matcher = matcher;
+      stream2.mapper = mapper;
+      stream2.maxLength = options.maxLength;
+      stream2.skipOverflow = options.skipOverflow || false;
+      stream2.overflow = false;
+      stream2._destroy = function(err, cb) {
+        this._writableState.errorEmitted = false;
+        cb(err);
+      };
+      return stream2;
+    }
+    __name(split2, "split");
+    module2.exports = split2;
+  }
+});
+
+// ../toolkit-lib/lib/api/cloud-assembly/private/exec.ts
+async function execInChildProcess(commandAndArgs, options = {}) {
+  return new Promise((ok, fail) => {
+    const proc2 = child_process2.spawn(commandAndArgs, {
+      stdio: ["ignore", "pipe", "pipe"],
+      detached: false,
+      cwd: options.cwd,
+      env: options.env,
+      // We are using 'shell: true' on purprose. Traditionally we have allowed shell features in
+      // this string, so we have to continue to do so into the future. On Windows, this is simply
+      // necessary to run .bat and .cmd files properly.
+      // Code scanning tools will flag this as a risk. The input comes from a trusted source,
+      // so it does not represent a security risk.
+      shell: true
+    });
+    const eventPublisher = options.eventPublisher ?? ((type, line) => {
+      switch (type) {
+        case "data_stdout":
+          process.stdout.write(line);
+          return;
+        case "data_stderr":
+          process.stderr.write(line);
+          return;
+        case "open":
+        case "close":
+          return;
+      }
+    });
+    const stderr2 = new Array();
+    proc2.stdout.pipe(split()).on("data", (line) => eventPublisher("data_stdout", line));
+    proc2.stderr.pipe(split()).on("data", (line) => {
+      stderr2.push(line);
+      return eventPublisher("data_stderr", line);
+    });
+    proc2.on("error", fail);
+    proc2.on("exit", (code) => {
+      if (code === 0) {
+        return ok();
+      } else {
+        let cause;
+        if (stderr2.length) {
+          cause = new Error(stderr2.join("\n"));
+          cause.name = "ExecutionError";
+        }
+        return fail(AssemblyError.withCause(`${commandAndArgs}: Subprocess exited with error ${code}`, cause));
+      }
+    });
+  });
+}
+var child_process2, split;
+var init_exec = __esm({
+  "../toolkit-lib/lib/api/cloud-assembly/private/exec.ts"() {
+    "use strict";
+    child_process2 = __toESM(require("node:child_process"));
+    init_toolkit_error();
+    split = require_split2();
+    __name(execInChildProcess, "execInChildProcess");
+  }
+});
+
+// ../toolkit-lib/lib/api/cloud-assembly/environment.ts
+async function prepareDefaultEnvironment(aws, debugFn) {
+  const env = {};
+  env[cxapi2.DEFAULT_REGION_ENV] = aws.defaultRegion;
+  await debugFn(`Setting "${cxapi2.DEFAULT_REGION_ENV}" environment variable to ${env[cxapi2.DEFAULT_REGION_ENV]}`);
+  const accountId = (await aws.defaultAccount())?.accountId;
+  if (accountId) {
+    env[cxapi2.DEFAULT_ACCOUNT_ENV] = accountId;
+    await debugFn(`Setting "${cxapi2.DEFAULT_ACCOUNT_ENV}" environment variable to ${env[cxapi2.DEFAULT_ACCOUNT_ENV]}`);
+  }
+  return env;
+}
+function contextFromSettings(settings) {
+  const context = {};
+  const pathMetadata = settings.get(["pathMetadata"]) ?? true;
+  if (pathMetadata) {
+    context[cxapi2.PATH_METADATA_ENABLE_CONTEXT] = true;
+  }
+  const assetMetadata = settings.get(["assetMetadata"]) ?? true;
+  if (assetMetadata) {
+    context[cxapi2.ASSET_RESOURCE_METADATA_ENABLED_CONTEXT] = true;
+  }
+  const versionReporting = settings.get(["versionReporting"]) ?? true;
+  if (versionReporting) {
+    context[cxapi2.ANALYTICS_REPORTING_ENABLED_CONTEXT] = true;
+  }
+  if (!versionReporting) {
+    context["aws:cdk:disable-version-reporting"] = true;
+  }
+  const stagingEnabled = settings.get(["staging"]) ?? true;
+  if (!stagingEnabled) {
+    context[cxapi2.DISABLE_ASSET_STAGING_CONTEXT] = true;
+  }
+  const bundlingStacks = settings.get(["bundlingStacks"]) ?? ["**"];
+  context[cxapi2.BUNDLING_STACKS] = bundlingStacks;
+  return context;
+}
+function synthParametersFromSettings(settings) {
+  return {
+    context: contextFromSettings(settings),
+    env: {
+      // An environment variable instead of a context variable, so it can also
+      // be accessed in framework code where we don't have access to a construct tree.
+      ...settings.get(["debug"]) ? { CDK_DEBUG: "true" } : {}
+    }
+  };
+}
+function spaceAvailableForContext(env, limit) {
+  const size = /* @__PURE__ */ __name((value) => value != null ? Buffer.byteLength(value) : 0, "size");
+  const usedSpace = Object.entries(env).map(([k16, v17]) => k16 === cxapi2.CONTEXT_ENV ? size(k16) : size(k16) + size(v17)).reduce((a16, b16) => a16 + b16, 0);
+  return Math.max(0, limit - usedSpace);
+}
+async function guessExecutable(commandLine, debugFn) {
+  const fullFile = await checkFile(commandLine);
+  if (fullFile) {
+    return guessInterpreter(fullFile);
+  }
+  const [first, rest] = splitFirstShellWord(commandLine);
+  const firstFile = await checkFile(first);
+  if (firstFile) {
+    return `${guessInterpreter(firstFile)} ${rest}`.trim();
+  }
+  await debugFn(`Not a file: '${commandLine}'. Using '${commandLine} as command-line`);
+  return commandLine;
+}
+function guessInterpreter(file) {
+  const isWindows2 = process.platform === "win32";
+  const handler = EXTENSION_MAP[path25.extname(file.fileName)];
+  if (handler && (!file.isExecutable || isWindows2)) {
+    return handler(file.fileName);
+  }
+  return quoteSpaces(file.fileName);
+}
+function executeNode(scriptFile) {
+  return `${quoteSpaces(process.execPath)} ${quoteSpaces(scriptFile)}`;
+}
+function splitFirstShellWord(commandLine) {
+  commandLine = commandLine.trim();
+  if (commandLine[0] === '"') {
+    const endQuote = commandLine.indexOf('"', 1);
+    return endQuote > -1 ? [commandLine.slice(1, endQuote), commandLine.slice(endQuote + 1).trim()] : [commandLine, ""];
+  } else {
+    const space = commandLine.indexOf(" ");
+    return space > -1 ? [commandLine.slice(0, space), commandLine.slice(space + 1)] : [commandLine, ""];
+  }
+}
+async function checkFile(fileName) {
+  try {
+    const fstat = await fs26.stat(fileName);
+    return {
+      fileName,
+      // eslint-disable-next-line no-bitwise
+      isExecutable: (fstat.mode & fs26.constants.X_OK) !== 0
+    };
+  } catch {
+    return void 0;
+  }
+}
+function quoteSpaces(part) {
+  if (part.includes(" ")) {
+    return `"${part}"`;
+  }
+  return part;
+}
+var path25, cxapi2, fs26, EXTENSION_MAP;
+var init_environment3 = __esm({
+  "../toolkit-lib/lib/api/cloud-assembly/environment.ts"() {
+    "use strict";
+    path25 = __toESM(require("path"));
+    cxapi2 = __toESM(require_lib4());
+    fs26 = __toESM(require_lib6());
+    __name(prepareDefaultEnvironment, "prepareDefaultEnvironment");
+    __name(contextFromSettings, "contextFromSettings");
+    __name(synthParametersFromSettings, "synthParametersFromSettings");
+    __name(spaceAvailableForContext, "spaceAvailableForContext");
+    __name(guessExecutable, "guessExecutable");
+    __name(guessInterpreter, "guessInterpreter");
+    EXTENSION_MAP = {
+      ".js": executeNode
+    };
+    __name(executeNode, "executeNode");
+    __name(splitFirstShellWord, "splitFirstShellWord");
+    __name(checkFile, "checkFile");
+    __name(quoteSpaces, "quoteSpaces");
+  }
+});
+
+// ../toolkit-lib/lib/api/cloud-assembly/private/prepare-source.ts
+function writeContextToEnv(env, context, completeness) {
+  let contextOverflowLocation = null;
+  const envVariableSizeLimit = os9.platform() === "win32" ? 32760 : 131072;
+  const completeEnv = { ...completeness === "add-process-env-later" ? process.env : {}, ...env };
+  const [smallContext, overflow] = splitBySize(context, spaceAvailableForContext(completeEnv, envVariableSizeLimit));
+  env[cxapi3.CONTEXT_ENV] = JSON.stringify(smallContext);
+  if (Object.keys(overflow ?? {}).length > 0) {
+    const contextDir = fs27.mkdtempSync(path26.join(os9.tmpdir(), "cdk-context"));
+    contextOverflowLocation = path26.join(contextDir, "context-overflow.json");
+    fs27.writeJSONSync(contextOverflowLocation, overflow);
+    env[cxapi3.CONTEXT_OVERFLOW_LOCATION_ENV] = contextOverflowLocation;
+  }
+  return async () => {
+    if (contextOverflowLocation) {
+      await fs27.promises.rm(path26.dirname(contextOverflowLocation), { recursive: true, force: true });
+    }
+  };
+}
+async function checkContextOverflowSupport(assembly, ioHelper) {
+  const traceFn = /* @__PURE__ */ __name((msg) => ioHelper.defaults.trace(msg), "traceFn");
+  const tree = await loadTree(assembly, traceFn);
+  if (!frameworkSupportsContextOverflow(tree)) {
+    await ioHelper.notify(IO.CDK_ASSEMBLY_W0010.msg("Part of the context could not be sent to the application. Please update the AWS CDK library to the latest version."));
+  }
+}
+function frameworkSupportsContextOverflow(tree) {
+  return !some(tree, (node) => {
+    const fqn = node.constructInfo?.fqn;
+    const version = node.constructInfo?.version;
+    return fqn === "aws-cdk-lib.App" && version !== "0.0.0" && version != null && (0, import_semver.lte)(version, "2.38.0") || fqn === "@aws-cdk/core.App";
+  });
+}
+async function assemblyFromDirectory(assemblyDir, ioHelper, loadOptions = {}) {
+  try {
+    const assembly = new import_cloud_assembly_api9.CloudAssembly(assemblyDir, {
+      skipVersionCheck: !(loadOptions.checkVersion ?? true),
+      skipEnumCheck: !(loadOptions.checkEnums ?? true),
+      // We sort as we deploy
+      topoSort: false
+    });
+    await checkContextOverflowSupport(assembly, ioHelper);
+    return assembly;
+  } catch (err) {
+    if (err.message.includes(cxschema7.VERSION_MISMATCH)) {
+      const message2 = "This AWS CDK Toolkit is not compatible with the AWS CDK library used by your application. Please upgrade to the latest version.";
+      await ioHelper.notify(IO.CDK_ASSEMBLY_E1111.msg(message2, { error: err }));
+      throw new ToolkitError(`${message2}
+(${err.message}`);
+    }
+    throw err;
+  }
+}
+function settingsFromSynthOptions(synthOpts = {}) {
+  return new Settings({
+    debug: false,
+    pathMetadata: true,
+    versionReporting: true,
+    assetMetadata: true,
+    assetStaging: true,
+    ...synthOpts
+  }, true);
+}
+function parametersFromSynthOptions(synthOptions) {
+  return synthParametersFromSettings(settingsFromSynthOptions(synthOptions ?? {}));
+}
+var import_dispose_polyfill3, os9, path26, import_node_util2, import_cloud_assembly_api9, cxschema7, cxapi3, fs27, import_semver, ExecutionEnvironment;
+var init_prepare_source = __esm({
+  "../toolkit-lib/lib/api/cloud-assembly/private/prepare-source.ts"() {
+    "use strict";
+    import_dispose_polyfill3 = __toESM(require_dispose_polyfill());
+    os9 = __toESM(require("node:os"));
+    path26 = __toESM(require("node:path"));
+    import_node_util2 = require("node:util");
+    import_cloud_assembly_api9 = __toESM(require_lib3());
+    cxschema7 = __toESM(require_lib2());
+    cxapi3 = __toESM(require_lib4());
+    fs27 = __toESM(require_lib6());
+    import_semver = __toESM(require_semver4());
+    init_toolkit_error();
+    init_util();
+    init_private();
+    init_rwlock();
+    init_settings();
+    init_tree();
+    init_environment3();
+    ExecutionEnvironment = class _ExecutionEnvironment {
+      static {
+        __name(this, "ExecutionEnvironment");
+      }
+      /**
+       * Create an ExecutionEnvironment
+       *
+       * An ExecutionEnvironment holds a writer lock on the given directory which will
+       * be cleaned up when the object is disposed.
+       *
+       * A temporary directory will be created if none is supplied, which will be cleaned
+       * up when this object is disposed.
+       *
+       * If `markSuccessful()` is called, the writer lock is converted to a reader lock
+       * and temporary directories will not be cleaned up anymore.
+       */
+      static async create(services, options) {
+        let outDirIsTemporary = false;
+        let dir = options.outdir;
+        if (!dir) {
+          outDirIsTemporary = true;
+          dir = fs27.mkdtempSync(path26.join(fs27.realpathSync(os9.tmpdir()), "cdk.out"));
+        }
+        const lock = await new RWLock(dir).acquireWrite();
+        const opts = {
+          outdir: dir,
+          resolveDefaultAppEnv: options.resolveDefaultAppEnv
+        };
+        return new _ExecutionEnvironment(services, opts, {
+          lock,
+          outDirIsTemporary
+        });
+      }
+      /**
+       * Should the outdir be disposed of.
+       */
+      get shouldDisposeOutDir() {
+        return this.shouldClean;
+      }
+      /**
+       * The directory the cloud assembly will be written to.
+       */
+      outdir;
+      options;
+      ioHelper;
+      sdkProvider;
+      debugFn;
+      lock;
+      shouldClean;
+      constructor(services, options, { lock, outDirIsTemporary }) {
+        this.ioHelper = services.ioHelper;
+        this.sdkProvider = services.sdkProvider;
+        this.debugFn = (msg) => this.ioHelper.defaults.debug(msg);
+        this.lock = lock;
+        this.shouldClean = outDirIsTemporary;
+        this.outdir = options.outdir;
+        this.options = options;
+      }
+      async [Symbol.asyncDispose]() {
+        await this.lock?.release();
+        if (this.shouldDisposeOutDir) {
+          await fs27.rm(this.outdir, { recursive: true, force: true });
+        }
+      }
+      /**
+       * Mark the execution as successful, which stops the writer lock from being released upon disposal
+       */
+      async markSuccessful() {
+        if (!this.lock) {
+          throw new TypeError("Cannot mark successful more than once");
+        }
+        const readLock = await this.lock.convertToReaderLock();
+        this.lock = void 0;
+        this.shouldClean = false;
+        return { readLock };
+      }
+      /**
+       * Begin an execution in this environment
+       *
+       * This will acquire a write lock on the given environment. The write lock
+       * will be released automatically when the return object is disposed, unless it
+       * is converted to a reader lock.
+       */
+      async beginExecution() {
+        const lock = await new RWLock(this.outdir).acquireWrite();
+        let converted = false;
+        return {
+          async writeToReadLock() {
+            converted = true;
+            return lock.convertToReaderLock();
+          },
+          [Symbol.asyncDispose]: async () => {
+            if (!converted) {
+              await lock.release();
+            }
+          }
+        };
+      }
+      /**
+       * Guess the executable from the command-line argument
+       *
+       * Only do this if the file is NOT marked as executable. If it is,
+       * we'll defer to the shebang inside the file itself.
+       *
+       * If we're on Windows, we ALWAYS take the handler, since it's hard to
+       * verify if registry associations have or have not been set up for this
+       * file type, so we'll assume the worst and take control.
+       */
+      guessExecutable(app) {
+        return guessExecutable(app, this.debugFn);
+      }
+      /**
+       * If we don't have region/account defined in context, we fall back to the default SDK behavior
+       * where region is retrieved from ~/.aws/config and account is based on default credentials provider
+       * chain and then STS is queried.
+       *
+       * This is done opportunistically: for example, if we can't access STS for some reason or the region
+       * is not configured, the context value will be 'null' and there could failures down the line. In
+       * some cases, synthesis does not require region/account information at all, so that might be perfectly
+       * fine in certain scenarios.
+       */
+      async defaultEnvVars() {
+        const debugFn = /* @__PURE__ */ __name((msg) => this.ioHelper.notify(IO.CDK_ASSEMBLY_I0010.msg(msg)), "debugFn");
+        const env = this.options.resolveDefaultAppEnv ? await prepareDefaultEnvironment(this.sdkProvider, debugFn) : {};
+        env[cxapi3.OUTDIR_ENV] = this.outdir;
+        await debugFn((0, import_node_util2.format)("outdir:", this.outdir));
+        env[cxapi3.CLI_ASM_VERSION_ENV] = cxschema7.Manifest.version();
+        env[cxapi3.CLI_VERSION_ENV] = versionNumber();
+        await debugFn((0, import_node_util2.format)("env:", env));
+        return env;
+      }
+      /**
+       * Run code from a different working directory
+       */
+      async changeDir(block, workingDir) {
+        const originalWorkingDir = process.cwd();
+        try {
+          if (workingDir) {
+            process.chdir(workingDir);
+          }
+          return await block();
+        } finally {
+          if (workingDir) {
+            process.chdir(originalWorkingDir);
+          }
+        }
+      }
+    };
+    __name(writeContextToEnv, "writeContextToEnv");
+    __name(checkContextOverflowSupport, "checkContextOverflowSupport");
+    __name(frameworkSupportsContextOverflow, "frameworkSupportsContextOverflow");
+    __name(assemblyFromDirectory, "assemblyFromDirectory");
+    __name(settingsFromSynthOptions, "settingsFromSynthOptions");
+    __name(parametersFromSynthOptions, "parametersFromSynthOptions");
+  }
+});
+
+// ../toolkit-lib/lib/api/cloud-assembly/private/readable-assembly.ts
+var import_node_fs, ReadableCloudAssembly;
+var init_readable_assembly = __esm({
+  "../toolkit-lib/lib/api/cloud-assembly/private/readable-assembly.ts"() {
+    "use strict";
+    import_node_fs = require("node:fs");
+    ReadableCloudAssembly = class {
+      constructor(cloudAssembly, lock, options) {
+        this.cloudAssembly = cloudAssembly;
+        this.lock = lock;
+        this.options = options;
+      }
+      static {
+        __name(this, "ReadableCloudAssembly");
+      }
+      async _unlock() {
+        return this.lock.release();
+      }
+      async dispose() {
+        await this.lock.release();
+        if (this.options?.deleteOnDispose) {
+          await import_node_fs.promises.rm(this.cloudAssembly.directory, { recursive: true, force: true });
+        }
+      }
+      [Symbol.asyncDispose]() {
+        return this.dispose();
+      }
+    };
+  }
+});
+
+// ../toolkit-lib/lib/api/cloud-assembly/source-builder.ts
+var path27, import_util32, cxapi4, fs29, CloudAssemblySourceBuilder;
+var init_source_builder = __esm({
+  "../toolkit-lib/lib/api/cloud-assembly/source-builder.ts"() {
+    "use strict";
+    path27 = __toESM(require("path"));
+    import_util32 = require("util");
+    cxapi4 = __toESM(require_lib3());
+    fs29 = __toESM(require_lib6());
+    init_context_store();
+    init_rwlock();
+    init_cached_source();
+    init_context_aware_source();
+    init_exec();
+    init_prepare_source();
+    init_readable_assembly();
+    init_toolkit_error();
+    init_util();
+    init_private();
+    init_helpers();
+    CloudAssemblySourceBuilder = class {
+      static {
+        __name(this, "CloudAssemblySourceBuilder");
+      }
+      /**
+       * Create a Cloud Assembly from a Cloud Assembly builder function.
+       *
+       * ## Outdir
+       *
+       * If no output directory is given, it will synthesize into a temporary system
+       * directory. The temporary directory will be cleaned up, unless
+       * `disposeOutdir: false`.
+       *
+       * A write lock will be acquired on the output directory for the duration of
+       * the CDK app synthesis (which means that no two apps can synthesize at the
+       * same time), and after synthesis a read lock will be acquired on the
+       * directory. This means that while the CloudAssembly is being used, no CDK
+       * app synthesis can take place into that directory.
+       *
+       * ## Context
+       *
+       * If no `contextStore` is given, a `MemoryContext` will be used. This means
+       * no provider lookups will be persisted anywhere by default. Use a different
+       * type of context store if you want persistence between synth operations.
+       *
+       * @param builder - the builder function
+       * @param props - additional configuration properties
+       * @returns the CloudAssembly source
+       */
+      async fromAssemblyBuilder(builder, props = {}) {
+        const services = await this.sourceBuilderServices();
+        const contextStore = props.contextStore ?? new MemoryContext();
+        const contextAssemblyProps = {
+          services,
+          contextStore,
+          lookups: props.lookups
+        };
+        const outdir = props.outdir ? path27.resolve(props.outdir) : void 0;
+        return new ContextAwareCloudAssemblySource(
+          {
+            produce: /* @__PURE__ */ __name(async () => {
+              var _stack = [];
+              try {
+                const execution = __using(_stack, await ExecutionEnvironment.create(services, {
+                  outdir,
+                  resolveDefaultAppEnv: props.resolveDefaultEnvironment ?? true
+                }), true);
+                const synthParams = parametersFromSynthOptions(props.synthOptions);
+                const fullContext = {
+                  ...await contextStore.read(),
+                  ...synthParams.context
+                };
+                await services.ioHelper.defaults.debug((0, import_util32.format)("context:", fullContext));
+                const env = noUndefined({
+                  // Versioning, outdir, default account and region
+                  ...await execution.defaultEnvVars(),
+                  // Environment variables derived from settings
+                  ...synthParams.env
+                });
+                const cleanupContextTemp = writeContextToEnv(env, fullContext, "env-is-complete");
+                const _cleanupEnv = __using(_stack, props.clobberEnv ?? true ? temporarilyWriteEnv(env) : void 0);
+                let assembly;
+                try {
+                  assembly = await builder({
+                    outdir: execution.outdir,
+                    context: fullContext,
+                    env
+                  });
+                } catch (error4) {
+                  if (ToolkitError.isToolkitError(error4)) {
+                    throw error4;
+                  }
+                  throw AssemblyError.withCause("Assembly builder failed", error4);
+                } finally {
+                  await cleanupContextTemp();
+                }
+                const asm = cxapi4.CloudAssembly.isCloudAssembly(assembly) ? assembly : await assemblyFromDirectory(assembly.directory, services.ioHelper, props.loadAssemblyOptions);
+                const success2 = await execution.markSuccessful();
+                const deleteOnDispose = props.disposeOutdir ?? execution.shouldDisposeOutDir;
+                return new ReadableCloudAssembly(asm, success2.readLock, { deleteOnDispose });
+              } catch (_2) {
+                var _error = _2, _hasError = true;
+              } finally {
+                var _promise = __callDispose(_stack, _error, _hasError);
+                _promise && await _promise;
+              }
+            }, "produce")
+          },
+          contextAssemblyProps
+        );
+      }
+      /**
+       * Creates a Cloud Assembly from an existing assembly directory.
+       *
+       * A read lock will be acquired for the directory. This means that while
+       * the CloudAssembly is being used, no CDK app synthesis can take place into
+       * that directory.
+       *
+       * @param directory - directory the directory of a already produced Cloud Assembly.
+       * @returns the CloudAssembly source
+       */
+      async fromAssemblyDirectory(directory, props = {}) {
+        const services = await this.sourceBuilderServices();
+        return {
+          async produce() {
+            await services.ioHelper.notify(IO.CDK_ASSEMBLY_I0150.msg("--app points to a cloud assembly, so we bypass synth"));
+            const readLock = await new RWLock(directory).acquireRead();
+            try {
+              const asm = await assemblyFromDirectory(directory, services.ioHelper, props.loadAssemblyOptions);
+              const assembly = new ReadableCloudAssembly(asm, readLock, { deleteOnDispose: false });
+              if (assembly.cloudAssembly.manifest.missing && assembly.cloudAssembly.manifest.missing.length > 0) {
+                if (props.failOnMissingContext ?? true) {
+                  const missingKeysSet = missingContextKeys(assembly.cloudAssembly.manifest.missing);
+                  const missingKeys = Array.from(missingKeysSet);
+                  throw AssemblyError.withCause(
+                    `Assembly contains missing context. Make sure all necessary context is already in 'cdk.context.json' by running 'cdk synth' on a machine with sufficient AWS credentials and committing the result. Missing context keys: '${missingKeys.join(", ")}'`,
+                    "Error producing assembly"
+                  );
+                }
+              }
+              return new CachedCloudAssembly(assembly);
+            } catch (e16) {
+              await readLock.release();
+              throw e16;
+            }
+          }
+        };
+      }
+      /**
+       * Use an AWS CDK app exectuable as source.
+       *
+       * `app` is a command line that will be executed to produce a Cloud Assembly.
+       * The command will be executed in a shell, so it must come from a trusted source.
+       *
+       * The subprocess will execute in `workingDirectory`, which defaults to
+       * the current process' working directory if not given.
+       *
+       * ## Outdir
+       *
+       * If an output directory is supplied, relative paths are evaluated with
+       * respect to the current process' working directory. If an output directory
+       * is not supplied, the default is a `cdk.out` directory underneath
+       * `workingDirectory`. The output directory will not be cleaned up unless
+       * `disposeOutdir: true`.
+       *
+       * A write lock will be acquired on the output directory for the duration of
+       * the CDK app synthesis (which means that no two apps can synthesize at the
+       * same time), and after synthesis a read lock will be acquired on the
+       * directory.  This means that while the CloudAssembly is being used, no CDK
+       * app synthesis can take place into that directory.
+       *
+       * ## Context
+       *
+       * If no `contextStore` is given, a `CdkAppMultiContext` will be used, initialized
+       * to the app's `workingDirectory`. This means that context will be loaded from
+       * all the CDK's default context sources, and updates will be written to
+       * `cdk.context.json`.
+       *
+       * @param props - additional configuration properties
+       * @returns the CloudAssembly source
+       */
+      async fromCdkApp(app, props = {}) {
+        const services = await this.sourceBuilderServices();
+        const workingDirectory = props.workingDirectory ?? process.cwd();
+        const outdir = props.outdir ? path27.resolve(props.outdir) : path27.resolve(workingDirectory, "cdk.out");
+        const contextStore = props.contextStore ?? new CdkAppMultiContext(workingDirectory);
+        const contextAssemblyProps = {
+          services,
+          contextStore,
+          lookups: props.lookups
+        };
+        return new ContextAwareCloudAssemblySource(
+          {
+            produce: /* @__PURE__ */ __name(async () => {
+              var _stack = [];
+              try {
+                try {
+                  fs29.mkdirpSync(outdir);
+                } catch (e16) {
+                  throw new ToolkitError(`Could not create output directory at '${outdir}' (${e16.message}).`);
+                }
+                const execution = __using(_stack, await ExecutionEnvironment.create(services, {
+                  outdir,
+                  resolveDefaultAppEnv: props.resolveDefaultEnvironment ?? true
+                }), true);
+                const commandLine = await execution.guessExecutable(app);
+                const synthParams = parametersFromSynthOptions(props.synthOptions);
+                const fullContext = {
+                  ...await contextStore.read(),
+                  ...synthParams.context
+                };
+                await services.ioHelper.defaults.debug((0, import_util32.format)("context:", fullContext));
+                const env = noUndefined({
+                  // Need to start with full env of `writeContextToEnv` will not be able to do the size
+                  // calculation correctly.
+                  ...process.env,
+                  // User gave us something
+                  ...props.env,
+                  // Versioning, outdir, default account and region
+                  ...await execution.defaultEnvVars(),
+                  // Environment variables derived from settings
+                  ...synthParams.env
+                });
+                const cleanupTemp = writeContextToEnv(env, fullContext, "env-is-complete");
+                try {
+                  await execInChildProcess(commandLine, {
+                    eventPublisher: /* @__PURE__ */ __name(async (type, line) => {
+                      switch (type) {
+                        case "data_stdout":
+                          await services.ioHelper.notify(IO.CDK_ASSEMBLY_I1001.msg(line));
+                          break;
+                        case "data_stderr":
+                          await services.ioHelper.notify(IO.CDK_ASSEMBLY_E1002.msg(line));
+                          break;
+                      }
+                    }, "eventPublisher"),
+                    env,
+                    cwd: workingDirectory
+                  });
+                } finally {
+                  await cleanupTemp();
+                }
+                const asm = await assemblyFromDirectory(outdir, services.ioHelper, props.loadAssemblyOptions);
+                const success2 = await execution.markSuccessful();
+                const deleteOnDispose = props.disposeOutdir ?? execution.shouldDisposeOutDir;
+                return new ReadableCloudAssembly(asm, success2.readLock, { deleteOnDispose });
+              } catch (_2) {
+                var _error = _2, _hasError = true;
+              } finally {
+                var _promise = __callDispose(_stack, _error, _hasError);
+                _promise && await _promise;
+              }
+            }, "produce")
+          },
+          contextAssemblyProps
+        );
+      }
+    };
+  }
+});
+
+// ../toolkit-lib/lib/api/cloud-assembly/types.ts
+var init_types4 = __esm({
+  "../toolkit-lib/lib/api/cloud-assembly/types.ts"() {
+    "use strict";
+  }
+});
+
+// ../toolkit-lib/lib/api/cloud-assembly/index.ts
+var cloud_assembly_exports3 = {};
+__export(cloud_assembly_exports3, {
+  CachedCloudAssembly: () => CachedCloudAssembly,
+  CdkAppMultiContext: () => CdkAppMultiContext,
+  CloudAssemblySourceBuilder: () => CloudAssemblySourceBuilder,
+  ExpandStackSelection: () => ExpandStackSelection,
+  FileContext: () => FileContext,
+  MemoryContext: () => MemoryContext,
+  StackSelectionStrategy: () => StackSelectionStrategy,
+  persistableContext: () => persistableContext
+});
+var init_cloud_assembly3 = __esm({
+  "../toolkit-lib/lib/api/cloud-assembly/index.ts"() {
+    "use strict";
+    init_stack_selector();
+    init_cached_source();
+    init_source_builder();
+    init_types4();
+    init_context_store();
+  }
+});
+
 // ../toolkit-lib/node_modules/minimatch/dist/esm/assert-valid-pattern.js
 var MAX_PATTERN_LENGTH2, assertValidPattern2;
 var init_assert_valid_pattern2 = __esm({
@@ -328036,7 +329307,7 @@ var init_escape2 = __esm({
 });
 
 // ../toolkit-lib/node_modules/minimatch/dist/esm/index.js
-var import_brace_expansion2, minimatch2, starDotExtRE2, starDotExtTest2, starDotExtTestDot2, starDotExtTestNocase2, starDotExtTestNocaseDot2, starDotStarRE2, starDotStarTest2, starDotStarTestDot2, dotStarRE2, dotStarTest2, starRE2, starTest2, starTestDot2, qmarksRE2, qmarksTestNocase2, qmarksTestNocaseDot2, qmarksTestDot2, qmarksTest2, qmarksTestNoExt2, qmarksTestNoExtDot2, defaultPlatform4, path23, sep2, GLOBSTAR2, qmark4, star4, twoStarDot2, twoStarNoDot2, filter2, ext2, defaults2, braceExpand2, makeRe2, match2, globMagic2, regExpEscape4, Minimatch2;
+var import_brace_expansion2, minimatch2, starDotExtRE2, starDotExtTest2, starDotExtTestDot2, starDotExtTestNocase2, starDotExtTestNocaseDot2, starDotStarRE2, starDotStarTest2, starDotStarTestDot2, dotStarRE2, dotStarTest2, starRE2, starTest2, starTestDot2, qmarksRE2, qmarksTestNocase2, qmarksTestNocaseDot2, qmarksTestDot2, qmarksTest2, qmarksTestNoExt2, qmarksTestNoExtDot2, defaultPlatform4, path28, sep2, GLOBSTAR2, qmark4, star4, twoStarDot2, twoStarNoDot2, filter2, ext2, defaults2, braceExpand2, makeRe2, match2, globMagic2, regExpEscape4, Minimatch2;
 var init_esm11 = __esm({
   "../toolkit-lib/node_modules/minimatch/dist/esm/index.js"() {
     import_brace_expansion2 = __toESM(require_brace_expansion(), 1);
@@ -328105,11 +329376,11 @@ var init_esm11 = __esm({
       return (f16) => f16.length === len && f16 !== "." && f16 !== "..";
     }, "qmarksTestNoExtDot");
     defaultPlatform4 = typeof process === "object" && process ? typeof process.env === "object" && process.env && process.env.__MINIMATCH_TESTING_PLATFORM__ || process.platform : "posix";
-    path23 = {
+    path28 = {
       win32: { sep: "\\" },
       posix: { sep: "/" }
     };
-    sep2 = defaultPlatform4 === "win32" ? path23.win32.sep : path23.posix.sep;
+    sep2 = defaultPlatform4 === "win32" ? path28.win32.sep : path28.posix.sep;
     minimatch2.sep = sep2;
     GLOBSTAR2 = /* @__PURE__ */ Symbol("globstar **");
     minimatch2.GLOBSTAR = GLOBSTAR2;
@@ -328776,11 +330047,11 @@ var init_esm11 = __esm({
 });
 
 // ../toolkit-lib/lib/api/cloud-assembly/stack-collection.ts
-var import_cloud_assembly_api9, StackCollection;
+var import_cloud_assembly_api10, StackCollection;
 var init_stack_collection = __esm({
   "../toolkit-lib/lib/api/cloud-assembly/stack-collection.ts"() {
     "use strict";
-    import_cloud_assembly_api9 = __toESM(require_lib3());
+    import_cloud_assembly_api10 = __toESM(require_lib3());
     init_toolkit_error();
     StackCollection = class _StackCollection {
       constructor(assembly, stackArtifacts) {
@@ -328862,15 +330133,15 @@ var init_stack_collection = __esm({
         for (const stack of this.stackArtifacts) {
           for (const message2 of stack.messages) {
             switch (message2.level) {
-              case import_cloud_assembly_api9.SynthesisMessageLevel.WARNING:
+              case import_cloud_assembly_api10.SynthesisMessageLevel.WARNING:
                 warnings = true;
                 await logger3("warn", message2);
                 break;
-              case import_cloud_assembly_api9.SynthesisMessageLevel.ERROR:
+              case import_cloud_assembly_api10.SynthesisMessageLevel.ERROR:
                 errors = true;
                 await logger3("error", message2);
                 break;
-              case import_cloud_assembly_api9.SynthesisMessageLevel.INFO:
+              case import_cloud_assembly_api10.SynthesisMessageLevel.INFO:
                 await logger3("info", message2);
                 break;
             }
@@ -328999,29 +330270,6 @@ var init_stack_assembly = __esm({
   }
 });
 
-// ../toolkit-lib/lib/api/cloud-assembly/stack-selector.ts
-var StackSelectionStrategy, ExpandStackSelection;
-var init_stack_selector = __esm({
-  "../toolkit-lib/lib/api/cloud-assembly/stack-selector.ts"() {
-    "use strict";
-    StackSelectionStrategy = /* @__PURE__ */ ((StackSelectionStrategy3) => {
-      StackSelectionStrategy3["ALL_STACKS"] = "all-stacks";
-      StackSelectionStrategy3["MAIN_ASSEMBLY"] = "main-assembly";
-      StackSelectionStrategy3["ONLY_SINGLE"] = "only-single";
-      StackSelectionStrategy3["PATTERN_MATCH"] = "pattern-match";
-      StackSelectionStrategy3["PATTERN_MUST_MATCH"] = "pattern-must-match";
-      StackSelectionStrategy3["PATTERN_MUST_MATCH_SINGLE"] = "pattern-must-match-single";
-      return StackSelectionStrategy3;
-    })(StackSelectionStrategy || {});
-    ExpandStackSelection = /* @__PURE__ */ ((ExpandStackSelection3) => {
-      ExpandStackSelection3["NONE"] = "none";
-      ExpandStackSelection3["UPSTREAM"] = "upstream";
-      ExpandStackSelection3["DOWNSTREAM"] = "downstream";
-      return ExpandStackSelection3;
-    })(ExpandStackSelection || {});
-  }
-});
-
 // ../toolkit-lib/lib/api/cloud-assembly/private/stack-assembly.ts
 function expandToExtendEnum(extend) {
   switch (extend) {
@@ -329035,12 +330283,12 @@ function expandToExtendEnum(extend) {
       return void 0;
   }
 }
-var import_dispose_polyfill, import_semver, StackAssembly;
+var import_dispose_polyfill4, import_semver2, StackAssembly;
 var init_stack_assembly2 = __esm({
   "../toolkit-lib/lib/api/cloud-assembly/private/stack-assembly.ts"() {
     "use strict";
-    import_dispose_polyfill = __toESM(require_dispose_polyfill());
-    import_semver = __toESM(require_semver4());
+    import_dispose_polyfill4 = __toESM(require_dispose_polyfill());
+    import_semver2 = __toESM(require_semver4());
     init_toolkit_error();
     init_stack_assembly();
     init_stack_collection();
@@ -329073,7 +330321,7 @@ var init_stack_assembly2 = __esm({
       async selectStacksV2(selector) {
         const asm = this.assembly;
         const topLevelStacks = asm.stacks;
-        const allStacks = (0, import_semver.major)(asm.version) < 10 ? asm.stacks : asm.stacksRecursively;
+        const allStacks = (0, import_semver2.major)(asm.version) < 10 ? asm.stacks : asm.stacksRecursively;
         if (allStacks.length === 0 && (selector.failOnEmpty ?? true)) {
           throw new ToolkitError("This app contains no stacks");
         }
@@ -329116,7 +330364,7 @@ Stacks: ${allStacks.map((x16) => x16.hierarchicalId).join(" \xB7 ")}`);
        * @returns a `StackCollection` of all stacks
        */
       selectAllStacks() {
-        const allStacks = (0, import_semver.major)(this.assembly.version) < 10 ? this.assembly.stacks : this.assembly.stacksRecursively;
+        const allStacks = (0, import_semver2.major)(this.assembly.version) < 10 ? this.assembly.stacks : this.assembly.stacksRecursively;
         return new StackCollection(this, allStacks);
       }
       /**
@@ -329133,724 +330381,6 @@ Stacks: ${allStacks.map((x16) => x16.hierarchicalId).join(" \xB7 ")}`);
   }
 });
 
-// ../toolkit-lib/node_modules/split2/index.js
-var require_split2 = __commonJS({
-  "../toolkit-lib/node_modules/split2/index.js"(exports2, module2) {
-    "use strict";
-    var { Transform } = require("stream");
-    var { StringDecoder: StringDecoder3 } = require("string_decoder");
-    var kLast = /* @__PURE__ */ Symbol("last");
-    var kDecoder = /* @__PURE__ */ Symbol("decoder");
-    function transform(chunk, enc, cb) {
-      let list2;
-      if (this.overflow) {
-        const buf = this[kDecoder].write(chunk);
-        list2 = buf.split(this.matcher);
-        if (list2.length === 1) return cb();
-        list2.shift();
-        this.overflow = false;
-      } else {
-        this[kLast] += this[kDecoder].write(chunk);
-        list2 = this[kLast].split(this.matcher);
-      }
-      this[kLast] = list2.pop();
-      for (let i16 = 0; i16 < list2.length; i16++) {
-        try {
-          push(this, this.mapper(list2[i16]));
-        } catch (error4) {
-          return cb(error4);
-        }
-      }
-      this.overflow = this[kLast].length > this.maxLength;
-      if (this.overflow && !this.skipOverflow) {
-        cb(new Error("maximum buffer reached"));
-        return;
-      }
-      cb();
-    }
-    __name(transform, "transform");
-    function flush(cb) {
-      this[kLast] += this[kDecoder].end();
-      if (this[kLast]) {
-        try {
-          push(this, this.mapper(this[kLast]));
-        } catch (error4) {
-          return cb(error4);
-        }
-      }
-      cb();
-    }
-    __name(flush, "flush");
-    function push(self2, val) {
-      if (val !== void 0) {
-        self2.push(val);
-      }
-    }
-    __name(push, "push");
-    function noop(incoming) {
-      return incoming;
-    }
-    __name(noop, "noop");
-    function split2(matcher, mapper, options) {
-      matcher = matcher || /\r?\n/;
-      mapper = mapper || noop;
-      options = options || {};
-      switch (arguments.length) {
-        case 1:
-          if (typeof matcher === "function") {
-            mapper = matcher;
-            matcher = /\r?\n/;
-          } else if (typeof matcher === "object" && !(matcher instanceof RegExp) && !matcher[Symbol.split]) {
-            options = matcher;
-            matcher = /\r?\n/;
-          }
-          break;
-        case 2:
-          if (typeof matcher === "function") {
-            options = mapper;
-            mapper = matcher;
-            matcher = /\r?\n/;
-          } else if (typeof mapper === "object") {
-            options = mapper;
-            mapper = noop;
-          }
-      }
-      options = Object.assign({}, options);
-      options.autoDestroy = true;
-      options.transform = transform;
-      options.flush = flush;
-      options.readableObjectMode = true;
-      const stream2 = new Transform(options);
-      stream2[kLast] = "";
-      stream2[kDecoder] = new StringDecoder3("utf8");
-      stream2.matcher = matcher;
-      stream2.mapper = mapper;
-      stream2.maxLength = options.maxLength;
-      stream2.skipOverflow = options.skipOverflow || false;
-      stream2.overflow = false;
-      stream2._destroy = function(err, cb) {
-        this._writableState.errorEmitted = false;
-        cb(err);
-      };
-      return stream2;
-    }
-    __name(split2, "split");
-    module2.exports = split2;
-  }
-});
-
-// ../toolkit-lib/lib/api/cloud-assembly/private/exec.ts
-async function execInChildProcess(commandAndArgs, options = {}) {
-  return new Promise((ok, fail) => {
-    const proc2 = child_process2.spawn(commandAndArgs, {
-      stdio: ["ignore", "pipe", "pipe"],
-      detached: false,
-      cwd: options.cwd,
-      env: options.env,
-      // We are using 'shell: true' on purprose. Traditionally we have allowed shell features in
-      // this string, so we have to continue to do so into the future. On Windows, this is simply
-      // necessary to run .bat and .cmd files properly.
-      // Code scanning tools will flag this as a risk. The input comes from a trusted source,
-      // so it does not represent a security risk.
-      shell: true
-    });
-    const eventPublisher = options.eventPublisher ?? ((type, line) => {
-      switch (type) {
-        case "data_stdout":
-          process.stdout.write(line);
-          return;
-        case "data_stderr":
-          process.stderr.write(line);
-          return;
-        case "open":
-        case "close":
-          return;
-      }
-    });
-    const stderr2 = new Array();
-    proc2.stdout.pipe(split()).on("data", (line) => eventPublisher("data_stdout", line));
-    proc2.stderr.pipe(split()).on("data", (line) => {
-      stderr2.push(line);
-      return eventPublisher("data_stderr", line);
-    });
-    proc2.on("error", fail);
-    proc2.on("exit", (code) => {
-      if (code === 0) {
-        return ok();
-      } else {
-        let cause;
-        if (stderr2.length) {
-          cause = new Error(stderr2.join("\n"));
-          cause.name = "ExecutionError";
-        }
-        return fail(AssemblyError.withCause(`${commandAndArgs}: Subprocess exited with error ${code}`, cause));
-      }
-    });
-  });
-}
-var child_process2, split;
-var init_exec = __esm({
-  "../toolkit-lib/lib/api/cloud-assembly/private/exec.ts"() {
-    "use strict";
-    child_process2 = __toESM(require("node:child_process"));
-    init_toolkit_error();
-    split = require_split2();
-    __name(execInChildProcess, "execInChildProcess");
-  }
-});
-
-// ../toolkit-lib/lib/api/rwlock.ts
-async function readFileIfExists(filename) {
-  try {
-    return await import_fs6.promises.readFile(filename, { encoding: "utf-8" });
-  } catch (e16) {
-    if (e16.code === "ENOENT") {
-      return void 0;
-    }
-    throw e16;
-  }
-}
-async function writeFileAtomic(filename, contents) {
-  await import_fs6.promises.mkdir(path24.dirname(filename), { recursive: true });
-  const tmpFile = `${filename}.${process.pid}_${++tmpCounter}`;
-  await import_fs6.promises.writeFile(tmpFile, contents, { encoding: "utf-8" });
-  await import_fs6.promises.rename(tmpFile, filename);
-}
-async function deleteFile(filename) {
-  try {
-    await import_fs6.promises.unlink(filename);
-  } catch (e16) {
-    if (e16.code === "ENOENT") {
-      return;
-    }
-    throw e16;
-  }
-}
-function processExists(pid) {
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch (e16) {
-    return false;
-  }
-}
-var import_fs6, path24, RWLock, tmpCounter;
-var init_rwlock = __esm({
-  "../toolkit-lib/lib/api/rwlock.ts"() {
-    "use strict";
-    import_fs6 = require("fs");
-    path24 = __toESM(require("path"));
-    init_toolkit_error();
-    RWLock = class {
-      constructor(directory) {
-        this.directory = directory;
-        this.pidString = `${process.pid}`;
-        this.writerFile = path24.join(this.directory, "synth.lock");
-      }
-      static {
-        __name(this, "RWLock");
-      }
-      pidString;
-      writerFile;
-      readCounter = 0;
-      /**
-       * Acquire a writer lock.
-       *
-       * No other readers or writers must exist for the given directory.
-       */
-      async acquireWrite() {
-        await this.assertNoOtherWriters();
-        const readers = await this._currentReaders();
-        if (readers.length > 0) {
-          throw new ToolkitError(`Other CLIs (PID=${readers}) are currently reading from ${this.directory}. Invoke the CLI in sequence, or use '--output' to synth into different directories.`);
-        }
-        await writeFileAtomic(this.writerFile, this.pidString);
-        let released = false;
-        return {
-          release: /* @__PURE__ */ __name(async () => {
-            if (!released) {
-              await deleteFile(this.writerFile);
-              released = true;
-            }
-          }, "release"),
-          convertToReaderLock: /* @__PURE__ */ __name(async () => {
-            const ret = await this.doAcquireRead();
-            await deleteFile(this.writerFile);
-            return ret;
-          }, "convertToReaderLock")
-        };
-      }
-      /**
-       * Acquire a read lock
-       *
-       * Will fail if there are any writers.
-       */
-      async acquireRead() {
-        await this.assertNoOtherWriters();
-        return this.doAcquireRead();
-      }
-      /**
-       * Obtains the name fo a (new) `readerFile` to use. This includes a counter so
-       * that if multiple threads of the same PID attempt to concurrently acquire
-       * the same lock, they're guaranteed to use a different reader file name (only
-       * one thread will ever execute JS code at once, guaranteeing the readCounter
-       * is incremented "atomically" from the point of view of this PID.).
-       */
-      readerFile() {
-        return path24.join(this.directory, `read.${this.pidString}.${++this.readCounter}.lock`);
-      }
-      /**
-       * Do the actual acquiring of a read lock.
-       */
-      async doAcquireRead() {
-        const readerFile = this.readerFile();
-        await writeFileAtomic(readerFile, this.pidString);
-        let released = false;
-        return {
-          release: /* @__PURE__ */ __name(async () => {
-            if (!released) {
-              await deleteFile(readerFile);
-              released = true;
-            }
-          }, "release")
-        };
-      }
-      async assertNoOtherWriters() {
-        const writer = await this._currentWriter();
-        if (writer) {
-          throw new ToolkitError(`Another CLI (PID=${writer}) is currently synthing to ${this.directory}. Invoke the CLI in sequence, or use '--output' to synth into different directories.`);
-        }
-      }
-      /**
-       * Check the current writer (if any)
-       *
-       * Publicly accessible for testing purposes. Do not use.
-       *
-       * @internal
-       */
-      async _currentWriter() {
-        const contents = await readFileIfExists(this.writerFile);
-        if (!contents) {
-          return void 0;
-        }
-        const pid = parseInt(contents, 10);
-        if (!processExists(pid)) {
-          await deleteFile(this.writerFile);
-          return void 0;
-        }
-        return pid;
-      }
-      /**
-       * Check the current readers (if any)
-       *
-       * Publicly accessible for testing purposes. Do not use.
-       *
-       * @internal
-       */
-      async _currentReaders() {
-        const re = /^read\.([^.]+)\.[^.]+\.lock$/;
-        const ret = new Array();
-        let children;
-        try {
-          children = await import_fs6.promises.readdir(this.directory, { encoding: "utf-8" });
-        } catch (e16) {
-          if (e16.code === "ENOENT") {
-            return [];
-          }
-          throw e16;
-        }
-        for (const fname of children) {
-          const m16 = fname.match(re);
-          if (m16) {
-            const pid = parseInt(m16[1], 10);
-            if (processExists(pid)) {
-              ret.push(pid);
-            } else {
-              await deleteFile(path24.join(this.directory, fname));
-            }
-          }
-        }
-        return ret;
-      }
-    };
-    __name(readFileIfExists, "readFileIfExists");
-    tmpCounter = 0;
-    __name(writeFileAtomic, "writeFileAtomic");
-    __name(deleteFile, "deleteFile");
-    __name(processExists, "processExists");
-  }
-});
-
-// ../toolkit-lib/lib/api/cloud-assembly/environment.ts
-async function prepareDefaultEnvironment(aws, debugFn) {
-  const env = {};
-  env[cxapi2.DEFAULT_REGION_ENV] = aws.defaultRegion;
-  await debugFn(`Setting "${cxapi2.DEFAULT_REGION_ENV}" environment variable to ${env[cxapi2.DEFAULT_REGION_ENV]}`);
-  const accountId = (await aws.defaultAccount())?.accountId;
-  if (accountId) {
-    env[cxapi2.DEFAULT_ACCOUNT_ENV] = accountId;
-    await debugFn(`Setting "${cxapi2.DEFAULT_ACCOUNT_ENV}" environment variable to ${env[cxapi2.DEFAULT_ACCOUNT_ENV]}`);
-  }
-  return env;
-}
-function contextFromSettings(settings) {
-  const context = {};
-  const pathMetadata = settings.get(["pathMetadata"]) ?? true;
-  if (pathMetadata) {
-    context[cxapi2.PATH_METADATA_ENABLE_CONTEXT] = true;
-  }
-  const assetMetadata = settings.get(["assetMetadata"]) ?? true;
-  if (assetMetadata) {
-    context[cxapi2.ASSET_RESOURCE_METADATA_ENABLED_CONTEXT] = true;
-  }
-  const versionReporting = settings.get(["versionReporting"]) ?? true;
-  if (versionReporting) {
-    context[cxapi2.ANALYTICS_REPORTING_ENABLED_CONTEXT] = true;
-  }
-  if (!versionReporting) {
-    context["aws:cdk:disable-version-reporting"] = true;
-  }
-  const stagingEnabled = settings.get(["staging"]) ?? true;
-  if (!stagingEnabled) {
-    context[cxapi2.DISABLE_ASSET_STAGING_CONTEXT] = true;
-  }
-  const bundlingStacks = settings.get(["bundlingStacks"]) ?? ["**"];
-  context[cxapi2.BUNDLING_STACKS] = bundlingStacks;
-  return context;
-}
-function synthParametersFromSettings(settings) {
-  return {
-    context: contextFromSettings(settings),
-    env: {
-      // An environment variable instead of a context variable, so it can also
-      // be accessed in framework code where we don't have access to a construct tree.
-      ...settings.get(["debug"]) ? { CDK_DEBUG: "true" } : {}
-    }
-  };
-}
-function spaceAvailableForContext(env, limit) {
-  const size = /* @__PURE__ */ __name((value) => value != null ? Buffer.byteLength(value) : 0, "size");
-  const usedSpace = Object.entries(env).map(([k16, v17]) => k16 === cxapi2.CONTEXT_ENV ? size(k16) : size(k16) + size(v17)).reduce((a16, b16) => a16 + b16, 0);
-  return Math.max(0, limit - usedSpace);
-}
-async function guessExecutable(commandLine, debugFn) {
-  const fullFile = await checkFile(commandLine);
-  if (fullFile) {
-    return guessInterpreter(fullFile);
-  }
-  const [first, rest] = splitFirstShellWord(commandLine);
-  const firstFile = await checkFile(first);
-  if (firstFile) {
-    return `${guessInterpreter(firstFile)} ${rest}`.trim();
-  }
-  await debugFn(`Not a file: '${commandLine}'. Using '${commandLine} as command-line`);
-  return commandLine;
-}
-function guessInterpreter(file) {
-  const isWindows2 = process.platform === "win32";
-  const handler = EXTENSION_MAP[path25.extname(file.fileName)];
-  if (handler && (!file.isExecutable || isWindows2)) {
-    return handler(file.fileName);
-  }
-  return quoteSpaces(file.fileName);
-}
-function executeNode(scriptFile) {
-  return `${quoteSpaces(process.execPath)} ${quoteSpaces(scriptFile)}`;
-}
-function splitFirstShellWord(commandLine) {
-  commandLine = commandLine.trim();
-  if (commandLine[0] === '"') {
-    const endQuote = commandLine.indexOf('"', 1);
-    return endQuote > -1 ? [commandLine.slice(1, endQuote), commandLine.slice(endQuote + 1).trim()] : [commandLine, ""];
-  } else {
-    const space = commandLine.indexOf(" ");
-    return space > -1 ? [commandLine.slice(0, space), commandLine.slice(space + 1)] : [commandLine, ""];
-  }
-}
-async function checkFile(fileName) {
-  try {
-    const fstat = await fs25.stat(fileName);
-    return {
-      fileName,
-      // eslint-disable-next-line no-bitwise
-      isExecutable: (fstat.mode & fs25.constants.X_OK) !== 0
-    };
-  } catch {
-    return void 0;
-  }
-}
-function quoteSpaces(part) {
-  if (part.includes(" ")) {
-    return `"${part}"`;
-  }
-  return part;
-}
-var path25, cxapi2, fs25, EXTENSION_MAP;
-var init_environment3 = __esm({
-  "../toolkit-lib/lib/api/cloud-assembly/environment.ts"() {
-    "use strict";
-    path25 = __toESM(require("path"));
-    cxapi2 = __toESM(require_lib4());
-    fs25 = __toESM(require_lib6());
-    __name(prepareDefaultEnvironment, "prepareDefaultEnvironment");
-    __name(contextFromSettings, "contextFromSettings");
-    __name(synthParametersFromSettings, "synthParametersFromSettings");
-    __name(spaceAvailableForContext, "spaceAvailableForContext");
-    __name(guessExecutable, "guessExecutable");
-    __name(guessInterpreter, "guessInterpreter");
-    EXTENSION_MAP = {
-      ".js": executeNode
-    };
-    __name(executeNode, "executeNode");
-    __name(splitFirstShellWord, "splitFirstShellWord");
-    __name(checkFile, "checkFile");
-    __name(quoteSpaces, "quoteSpaces");
-  }
-});
-
-// ../toolkit-lib/lib/api/cloud-assembly/private/prepare-source.ts
-function writeContextToEnv(env, context, completeness) {
-  let contextOverflowLocation = null;
-  const envVariableSizeLimit = os8.platform() === "win32" ? 32760 : 131072;
-  const completeEnv = { ...completeness === "add-process-env-later" ? process.env : {}, ...env };
-  const [smallContext, overflow] = splitBySize(context, spaceAvailableForContext(completeEnv, envVariableSizeLimit));
-  env[cxapi3.CONTEXT_ENV] = JSON.stringify(smallContext);
-  if (Object.keys(overflow ?? {}).length > 0) {
-    const contextDir = fs26.mkdtempSync(path26.join(os8.tmpdir(), "cdk-context"));
-    contextOverflowLocation = path26.join(contextDir, "context-overflow.json");
-    fs26.writeJSONSync(contextOverflowLocation, overflow);
-    env[cxapi3.CONTEXT_OVERFLOW_LOCATION_ENV] = contextOverflowLocation;
-  }
-  return async () => {
-    if (contextOverflowLocation) {
-      await fs26.promises.rm(path26.dirname(contextOverflowLocation), { recursive: true, force: true });
-    }
-  };
-}
-async function checkContextOverflowSupport(assembly, ioHelper) {
-  const traceFn = /* @__PURE__ */ __name((msg) => ioHelper.defaults.trace(msg), "traceFn");
-  const tree = await loadTree(assembly, traceFn);
-  if (!frameworkSupportsContextOverflow(tree)) {
-    await ioHelper.notify(IO.CDK_ASSEMBLY_W0010.msg("Part of the context could not be sent to the application. Please update the AWS CDK library to the latest version."));
-  }
-}
-function frameworkSupportsContextOverflow(tree) {
-  return !some(tree, (node) => {
-    const fqn = node.constructInfo?.fqn;
-    const version = node.constructInfo?.version;
-    return fqn === "aws-cdk-lib.App" && version !== "0.0.0" && version != null && (0, import_semver2.lte)(version, "2.38.0") || fqn === "@aws-cdk/core.App";
-  });
-}
-async function assemblyFromDirectory(assemblyDir, ioHelper, loadOptions = {}) {
-  try {
-    const assembly = new import_cloud_assembly_api10.CloudAssembly(assemblyDir, {
-      skipVersionCheck: !(loadOptions.checkVersion ?? true),
-      skipEnumCheck: !(loadOptions.checkEnums ?? true),
-      // We sort as we deploy
-      topoSort: false
-    });
-    await checkContextOverflowSupport(assembly, ioHelper);
-    return assembly;
-  } catch (err) {
-    if (err.message.includes(cxschema7.VERSION_MISMATCH)) {
-      const message2 = "This AWS CDK Toolkit is not compatible with the AWS CDK library used by your application. Please upgrade to the latest version.";
-      await ioHelper.notify(IO.CDK_ASSEMBLY_E1111.msg(message2, { error: err }));
-      throw new ToolkitError(`${message2}
-(${err.message}`);
-    }
-    throw err;
-  }
-}
-function settingsFromSynthOptions(synthOpts = {}) {
-  return new Settings({
-    debug: false,
-    pathMetadata: true,
-    versionReporting: true,
-    assetMetadata: true,
-    assetStaging: true,
-    ...synthOpts
-  }, true);
-}
-function parametersFromSynthOptions(synthOptions) {
-  return synthParametersFromSettings(settingsFromSynthOptions(synthOptions ?? {}));
-}
-var import_dispose_polyfill2, os8, path26, import_node_util2, import_cloud_assembly_api10, cxschema7, cxapi3, fs26, import_semver2, ExecutionEnvironment;
-var init_prepare_source = __esm({
-  "../toolkit-lib/lib/api/cloud-assembly/private/prepare-source.ts"() {
-    "use strict";
-    import_dispose_polyfill2 = __toESM(require_dispose_polyfill());
-    os8 = __toESM(require("node:os"));
-    path26 = __toESM(require("node:path"));
-    import_node_util2 = require("node:util");
-    import_cloud_assembly_api10 = __toESM(require_lib3());
-    cxschema7 = __toESM(require_lib2());
-    cxapi3 = __toESM(require_lib4());
-    fs26 = __toESM(require_lib6());
-    import_semver2 = __toESM(require_semver4());
-    init_toolkit_error();
-    init_util();
-    init_private();
-    init_rwlock();
-    init_settings();
-    init_tree();
-    init_environment3();
-    ExecutionEnvironment = class _ExecutionEnvironment {
-      static {
-        __name(this, "ExecutionEnvironment");
-      }
-      /**
-       * Create an ExecutionEnvironment
-       *
-       * An ExecutionEnvironment holds a writer lock on the given directory which will
-       * be cleaned up when the object is disposed.
-       *
-       * A temporary directory will be created if none is supplied, which will be cleaned
-       * up when this object is disposed.
-       *
-       * If `markSuccessful()` is called, the writer lock is converted to a reader lock
-       * and temporary directories will not be cleaned up anymore.
-       */
-      static async create(services, options) {
-        let outDirIsTemporary = false;
-        let dir = options.outdir;
-        if (!dir) {
-          outDirIsTemporary = true;
-          dir = fs26.mkdtempSync(path26.join(fs26.realpathSync(os8.tmpdir()), "cdk.out"));
-        }
-        const lock = await new RWLock(dir).acquireWrite();
-        const opts = {
-          outdir: dir,
-          resolveDefaultAppEnv: options.resolveDefaultAppEnv
-        };
-        return new _ExecutionEnvironment(services, opts, {
-          lock,
-          outDirIsTemporary
-        });
-      }
-      /**
-       * Should the outdir be disposed of.
-       */
-      get shouldDisposeOutDir() {
-        return this.shouldClean;
-      }
-      /**
-       * The directory the cloud assembly will be written to.
-       */
-      outdir;
-      options;
-      ioHelper;
-      sdkProvider;
-      debugFn;
-      lock;
-      shouldClean;
-      constructor(services, options, { lock, outDirIsTemporary }) {
-        this.ioHelper = services.ioHelper;
-        this.sdkProvider = services.sdkProvider;
-        this.debugFn = (msg) => this.ioHelper.defaults.debug(msg);
-        this.lock = lock;
-        this.shouldClean = outDirIsTemporary;
-        this.outdir = options.outdir;
-        this.options = options;
-      }
-      async [Symbol.asyncDispose]() {
-        await this.lock?.release();
-        if (this.shouldDisposeOutDir) {
-          await fs26.rm(this.outdir, { recursive: true, force: true });
-        }
-      }
-      /**
-       * Mark the execution as successful, which stops the writer lock from being released upon disposal
-       */
-      async markSuccessful() {
-        if (!this.lock) {
-          throw new TypeError("Cannot mark successful more than once");
-        }
-        const readLock = await this.lock.convertToReaderLock();
-        this.lock = void 0;
-        this.shouldClean = false;
-        return { readLock };
-      }
-      /**
-       * Begin an execution in this environment
-       *
-       * This will acquire a write lock on the given environment. The write lock
-       * will be released automatically when the return object is disposed, unless it
-       * is converted to a reader lock.
-       */
-      async beginExecution() {
-        const lock = await new RWLock(this.outdir).acquireWrite();
-        let converted = false;
-        return {
-          async writeToReadLock() {
-            converted = true;
-            return lock.convertToReaderLock();
-          },
-          [Symbol.asyncDispose]: async () => {
-            if (!converted) {
-              await lock.release();
-            }
-          }
-        };
-      }
-      /**
-       * Guess the executable from the command-line argument
-       *
-       * Only do this if the file is NOT marked as executable. If it is,
-       * we'll defer to the shebang inside the file itself.
-       *
-       * If we're on Windows, we ALWAYS take the handler, since it's hard to
-       * verify if registry associations have or have not been set up for this
-       * file type, so we'll assume the worst and take control.
-       */
-      guessExecutable(app) {
-        return guessExecutable(app, this.debugFn);
-      }
-      /**
-       * If we don't have region/account defined in context, we fall back to the default SDK behavior
-       * where region is retrieved from ~/.aws/config and account is based on default credentials provider
-       * chain and then STS is queried.
-       *
-       * This is done opportunistically: for example, if we can't access STS for some reason or the region
-       * is not configured, the context value will be 'null' and there could failures down the line. In
-       * some cases, synthesis does not require region/account information at all, so that might be perfectly
-       * fine in certain scenarios.
-       */
-      async defaultEnvVars() {
-        const debugFn = /* @__PURE__ */ __name((msg) => this.ioHelper.notify(IO.CDK_ASSEMBLY_I0010.msg(msg)), "debugFn");
-        const env = this.options.resolveDefaultAppEnv ? await prepareDefaultEnvironment(this.sdkProvider, debugFn) : {};
-        env[cxapi3.OUTDIR_ENV] = this.outdir;
-        await debugFn((0, import_node_util2.format)("outdir:", this.outdir));
-        env[cxapi3.CLI_ASM_VERSION_ENV] = cxschema7.Manifest.version();
-        env[cxapi3.CLI_VERSION_ENV] = versionNumber();
-        await debugFn((0, import_node_util2.format)("env:", env));
-        return env;
-      }
-      /**
-       * Run code from a different working directory
-       */
-      async changeDir(block, workingDir) {
-        const originalWorkingDir = process.cwd();
-        try {
-          if (workingDir) {
-            process.chdir(workingDir);
-          }
-          return await block();
-        } finally {
-          if (workingDir) {
-            process.chdir(originalWorkingDir);
-          }
-        }
-      }
-    };
-    __name(writeContextToEnv, "writeContextToEnv");
-    __name(checkContextOverflowSupport, "checkContextOverflowSupport");
-    __name(frameworkSupportsContextOverflow, "frameworkSupportsContextOverflow");
-    __name(assemblyFromDirectory, "assemblyFromDirectory");
-    __name(settingsFromSynthOptions, "settingsFromSynthOptions");
-    __name(parametersFromSynthOptions, "parametersFromSynthOptions");
-  }
-});
-
 // ../toolkit-lib/lib/api/cloud-assembly/private/stack-selectors.ts
 var ALL_STACKS;
 var init_stack_selectors = __esm({
@@ -329881,14 +330411,14 @@ async function assemblyFromSource(ioHelper, assemblySource, cache16 = true) {
     return assemblySource;
   }
   if (cache16) {
-    const ret = new StackAssembly(await assemblySource.produce(), ioHelper);
-    return ret;
+    return new StackAssembly(new CachedCloudAssembly(await assemblySource.produce()), ioHelper);
   }
   return new StackAssembly(await assemblySource.produce(), ioHelper);
 }
 var init_private4 = __esm({
   "../toolkit-lib/lib/toolkit/private/index.ts"() {
     "use strict";
+    init_cloud_assembly3();
     init_private3();
     __name(assemblyFromSource, "assemblyFromSource");
   }
@@ -329927,11 +330457,11 @@ var init_private5 = __esm({
 });
 
 // ../toolkit-lib/lib/actions/bootstrap/index.ts
-var path27, BootstrapEnvironments, BootstrapStackParameters, BootstrapSource, BootstrapTemplate;
+var path29, BootstrapEnvironments, BootstrapStackParameters, BootstrapSource, BootstrapTemplate;
 var init_bootstrap2 = __esm({
   "../toolkit-lib/lib/actions/bootstrap/index.ts"() {
     "use strict";
-    path27 = __toESM(require("path"));
+    path29 = __toESM(require("path"));
     init_private5();
     init_private3();
     init_private();
@@ -330054,7 +330584,7 @@ var init_bootstrap2 = __esm({
             template = await loadStructuredFile(source.templateFile);
             break;
           case "default":
-            template = await loadStructuredFile(path27.join(bundledPackageRootDir(__dirname), "lib", "api", "bootstrap", "bootstrap-template.yaml"));
+            template = await loadStructuredFile(path29.join(bundledPackageRootDir(__dirname), "lib", "api", "bootstrap", "bootstrap-template.yaml"));
             break;
         }
         return new _BootstrapTemplate(template);
@@ -332579,7 +333109,7 @@ function onlyChanges(xs) {
   return ret;
 }
 var import_assert, import_service_spec_types2, TemplateDiff, Difference, PropertyDifference, DifferenceCollection, ConditionDifference, MappingDifference, MetadataDifference, OutputDifference, ParameterDifference, ResourceImpact, ResourceDifference;
-var init_types4 = __esm({
+var init_types5 = __esm({
   "../cloudformation-diff/lib/diff/types.ts"() {
     "use strict";
     import_assert = require("assert");
@@ -333109,7 +333639,7 @@ function _asString(value) {
 var init_diff2 = __esm({
   "../cloudformation-diff/lib/diff/index.ts"() {
     "use strict";
-    init_types4();
+    init_types5();
     init_util4();
     __name(diffAttribute, "diffAttribute");
     __name(diffCondition, "diffCondition");
@@ -333128,7 +333658,7 @@ var TemplateAndChangeSetDiffMerger;
 var init_template_and_changeset_diff_merger = __esm({
   "../cloudformation-diff/lib/diff/template-and-changeset-diff-merger.ts"() {
     "use strict";
-    init_types4();
+    init_types5();
     TemplateAndChangeSetDiffMerger = class _TemplateAndChangeSetDiffMerger {
       static {
         __name(this, "TemplateAndChangeSetDiffMerger");
@@ -333416,9 +333946,9 @@ var init_diff_template = __esm({
     "use strict";
     init_diff2();
     init_template_and_changeset_diff_merger();
-    init_types4();
+    init_types5();
     init_util4();
-    init_types4();
+    init_types5();
     DIFF_HANDLERS = {
       AWSTemplateFormatVersion: /* @__PURE__ */ __name((diff, oldValue, newValue) => diff.awsTemplateFormatVersion = diffAttribute(oldValue, newValue), "AWSTemplateFormatVersion"),
       Description: /* @__PURE__ */ __name((diff, oldValue, newValue) => diff.description = diffAttribute(oldValue, newValue), "Description"),
@@ -340020,11 +340550,11 @@ function _diffStrings(oldStr, newStr, context) {
   }
   __name(_findIndent, "_findIndent");
 }
-var import_util40, chalk10, PATH_METADATA_KEY2, structuredPatch, ADDITION, CONTEXT, UPDATE, REMOVAL, IMPORT, Formatter;
+var import_util42, chalk10, PATH_METADATA_KEY2, structuredPatch, ADDITION, CONTEXT, UPDATE, REMOVAL, IMPORT, Formatter;
 var init_format = __esm({
   "../cloudformation-diff/lib/format.ts"() {
     "use strict";
-    import_util40 = require("util");
+    import_util42 = require("util");
     chalk10 = __toESM(require_source());
     init_util4();
     init_diff_template();
@@ -340052,10 +340582,10 @@ var init_format = __esm({
         __name(this, "Formatter");
       }
       print(fmt, ...args) {
-        this.stream.write(chalk10.reset((0, import_util40.format)(fmt, ...args)) + "\n");
+        this.stream.write(chalk10.reset((0, import_util42.format)(fmt, ...args)) + "\n");
       }
       warning(fmt, ...args) {
-        this.stream.write(chalk10.yellow((0, import_util40.format)(fmt, ...args)) + "\n");
+        this.stream.write(chalk10.yellow((0, import_util42.format)(fmt, ...args)) + "\n");
       }
       formatSection(title, entryType, collection, formatter = this.formatDifference.bind(this)) {
         if (collection.differenceCount === 0) {
@@ -340692,7 +341222,7 @@ async function prepareAsset(ioHelper, asset, assetManifest, envResources, toolki
   }
 }
 async function prepareFileAsset(ioHelper, asset, assetManifest, toolkitInfo, packaging) {
-  const extension = packaging === cxschema8.FileAssetPackaging.ZIP_DIRECTORY ? ".zip" : path28.extname(asset.path);
+  const extension = packaging === cxschema8.FileAssetPackaging.ZIP_DIRECTORY ? ".zip" : path30.extname(asset.path);
   const baseName = `${asset.sourceHash}${extension}`;
   const s3Prefix = asset.id === asset.sourceHash ? "assets/" : `assets/${asset.id}/`;
   const key = `${s3Prefix}${baseName}`;
@@ -340707,7 +341237,7 @@ async function prepareFileAsset(ioHelper, asset, assetManifest, toolkitInfo, pac
   });
   return {
     [asset.s3BucketParameter]: toolkitInfo.bucketName,
-    [asset.s3KeyParameter]: `${s3Prefix}${cxapi4.ASSET_PREFIX_SEPARATOR}${baseName}`,
+    [asset.s3KeyParameter]: `${s3Prefix}${cxapi5.ASSET_PREFIX_SEPARATOR}${baseName}`,
     [asset.artifactHashParameter]: asset.sourceHash
   };
 }
@@ -340736,12 +341266,12 @@ async function prepareDockerImageAsset(asset, assetManifest, envResources) {
   }
   return { [asset.imageNameParameter]: `${repositoryUri2}:${imageTag}` };
 }
-var path28, cxapi4, cxschema8, chalk12;
+var path30, cxapi5, cxschema8, chalk12;
 var init_assets3 = __esm({
   "../toolkit-lib/lib/api/deployments/assets.ts"() {
     "use strict";
-    path28 = __toESM(require("path"));
-    cxapi4 = __toESM(require_lib3());
+    path30 = __toESM(require("path"));
+    cxapi5 = __toESM(require_lib3());
     cxschema8 = __toESM(require_lib2());
     chalk12 = __toESM(require_source());
     init_toolkit_error();
@@ -340983,7 +341513,7 @@ var init_synth = __esm({
 });
 
 // ../toolkit-lib/lib/payloads/types.ts
-var init_types5 = __esm({
+var init_types6 = __esm({
   "../toolkit-lib/lib/payloads/types.ts"() {
     "use strict";
   }
@@ -341071,7 +341601,7 @@ var init_payloads = __esm({
     init_rollback();
     init_stack_activity();
     init_synth();
-    init_types5();
+    init_types6();
     init_progress2();
     init_refactor();
     init_watch();
@@ -342464,7 +342994,7 @@ async function applyHotswapOperation(sdk, ioSpan, hotswapOperation) {
   sdk.appendCustomUserAgent(customUserAgent);
   const resourceText = /* @__PURE__ */ __name((r16) => r16.description ?? `${r16.resourceType} '${r16.physicalName ?? r16.logicalId}'`, "resourceText");
   await ioSpan.notify(IO.CDK_TOOLKIT_I5402.msg(
-    hotswapOperation.change.resources.map((r16) => (0, import_util46.format)(`   ${ICON} %s`, chalk13.bold(resourceText(r16)))).join("\n"),
+    hotswapOperation.change.resources.map((r16) => (0, import_util48.format)(`   ${ICON} %s`, chalk13.bold(resourceText(r16)))).join("\n"),
     hotswapOperation.change
   ));
   try {
@@ -342479,7 +343009,7 @@ async function applyHotswapOperation(sdk, ioSpan, hotswapOperation) {
     throw e16;
   }
   await ioSpan.notify(IO.CDK_TOOLKIT_I5403.msg(
-    hotswapOperation.change.resources.map((r16) => (0, import_util46.format)(`   ${ICON} %s %s`, chalk13.bold(resourceText(r16)), chalk13.green("hotswapped!"))).join("\n"),
+    hotswapOperation.change.resources.map((r16) => (0, import_util48.format)(`   ${ICON} %s %s`, chalk13.bold(resourceText(r16)), chalk13.green("hotswapped!"))).join("\n"),
     hotswapOperation.change
   ));
   sdk.removeCustomUserAgent(customUserAgent);
@@ -342508,9 +343038,9 @@ async function logRejectedChanges(ioSpan, rejectedChanges, hotswapMode) {
   }
   const messages = [""];
   if (hotswapMode === "hotswap-only") {
-    messages.push((0, import_util46.format)("%s %s", chalk13.red("\u26A0\uFE0F"), chalk13.red("The following non-hotswappable changes were found. To reconcile these using CloudFormation, specify --hotswap-fallback")));
+    messages.push((0, import_util48.format)("%s %s", chalk13.red("\u26A0\uFE0F"), chalk13.red("The following non-hotswappable changes were found. To reconcile these using CloudFormation, specify --hotswap-fallback")));
   } else {
-    messages.push((0, import_util46.format)("%s %s", chalk13.red("\u26A0\uFE0F"), chalk13.red("The following non-hotswappable changes were found:")));
+    messages.push((0, import_util48.format)("%s %s", chalk13.red("\u26A0\uFE0F"), chalk13.red("The following non-hotswappable changes were found:")));
   }
   for (const { change } of rejectedChanges) {
     messages.push("    " + nonHotswappableChangeMessage(change));
@@ -342523,7 +343053,7 @@ function nonHotswappableChangeMessage(change) {
   const reason = change.description ?? change.reason;
   switch (subject.type) {
     case "Output":
-      return (0, import_util46.format)(
+      return (0, import_util48.format)(
         "output: %s, reason: %s",
         chalk13.bold(subject.logicalId),
         chalk13.red(reason)
@@ -342534,7 +343064,7 @@ function nonHotswappableChangeMessage(change) {
 }
 function nonHotswappableResourceMessage(subject, reason) {
   if (subject.rejectedProperties?.length) {
-    return (0, import_util46.format)(
+    return (0, import_util48.format)(
       "resource: %s, type: %s, rejected changes: %s, reason: %s",
       chalk13.bold(subject.logicalId),
       chalk13.bold(subject.resourceType),
@@ -342542,18 +343072,18 @@ function nonHotswappableResourceMessage(subject, reason) {
       chalk13.red(reason)
     );
   }
-  return (0, import_util46.format)(
+  return (0, import_util48.format)(
     "resource: %s, type: %s, reason: %s",
     chalk13.bold(subject.logicalId),
     chalk13.bold(subject.resourceType),
     chalk13.red(reason)
   );
 }
-var import_util46, cfn_diff, chalk13, pLimit2, RESOURCE_DETECTORS;
+var import_util48, cfn_diff, chalk13, pLimit2, RESOURCE_DETECTORS;
 var init_hotswap_deployments = __esm({
   "../toolkit-lib/lib/api/hotswap/hotswap-deployments.ts"() {
     "use strict";
-    import_util46 = require("util");
+    import_util48 = require("util");
     cfn_diff = __toESM(require_lib11());
     chalk13 = __toESM(require_source());
     init_payloads();
@@ -342718,7 +343248,7 @@ async function deployStack(options, ioHelper) {
     await ioHelper.defaults.debug(`${deployName}: skipping deployment (use --force to override)`);
     if (deploymentMethod?.method === "hotswap") {
       await ioHelper.defaults.info(
-        (0, import_util48.format)(
+        (0, import_util50.format)(
           `
  ${ICON} %s
 `,
@@ -342769,7 +343299,7 @@ async function deployStack(options, ioHelper) {
       if (hotswapDeploymentResult) {
         return hotswapDeploymentResult;
       }
-      await ioHelper.defaults.info((0, import_util48.format)(
+      await ioHelper.defaults.info((0, import_util50.format)(
         "Could not perform a hotswap deployment, as the stack %s contains non-Asset changes",
         stackArtifact.displayName
       ));
@@ -342777,7 +343307,7 @@ async function deployStack(options, ioHelper) {
       if (!(e16 instanceof CfnEvaluationException)) {
         throw e16;
       }
-      await ioHelper.defaults.info((0, import_util48.format)(
+      await ioHelper.defaults.info((0, import_util50.format)(
         "Could not perform a hotswap deployment, because the CloudFormation template could not be resolved: %s",
         formatErrorMessage(e16)
       ));
@@ -342904,11 +343434,11 @@ function hasReplacement(cs) {
     return a16 === "ReplaceAndDelete" || a16 === "ReplaceAndRetain" || a16 === "ReplaceAndSnapshot";
   });
 }
-var import_util48, chalk14, FullCloudFormationDeployment;
+var import_util50, chalk14, FullCloudFormationDeployment;
 var init_deploy_stack = __esm({
   "../toolkit-lib/lib/api/deployments/deploy-stack.ts"() {
     "use strict";
-    import_util48 = require("util");
+    import_util50 = require("util");
     chalk14 = __toESM(require_source());
     init_esm3();
     init_asset_manifest_builder();
@@ -342967,9 +343497,9 @@ var init_deploy_stack = __esm({
         const changeSetDescription = await this.createChangeSet(changeSetName, execute, importExistingResources);
         await this.updateTerminationProtection();
         if (changeSetHasNoChanges(changeSetDescription)) {
-          await this.ioHelper.defaults.debug((0, import_util48.format)("No changes are to be performed on %s.", this.stackName));
+          await this.ioHelper.defaults.debug((0, import_util50.format)("No changes are to be performed on %s.", this.stackName));
           if (execute) {
-            await this.ioHelper.defaults.debug((0, import_util48.format)("Deleting empty change set %s", changeSetDescription.ChangeSetId));
+            await this.ioHelper.defaults.debug((0, import_util50.format)("Deleting empty change set %s", changeSetDescription.ChangeSetId));
             await this.cfn.deleteChangeSet({
               StackName: this.stackName,
               ChangeSetName: changeSetName
@@ -342994,7 +343524,7 @@ var init_deploy_stack = __esm({
           };
         }
         if (!execute) {
-          await this.ioHelper.defaults.info((0, import_util48.format)(
+          await this.ioHelper.defaults.info((0, import_util50.format)(
             "Changeset %s created and waiting in review for manual execution (--no-execute)",
             changeSetDescription.ChangeSetId
           ));
@@ -343022,7 +343552,7 @@ var init_deploy_stack = __esm({
       async createChangeSet(changeSetName, willExecute, importExistingResources) {
         await this.cleanupOldChangeset(changeSetName);
         await this.ioHelper.defaults.debug(`Attempting to create ChangeSet with name ${changeSetName} to ${this.verb} stack ${this.stackName}`);
-        await this.ioHelper.defaults.info((0, import_util48.format)("%s: creating CloudFormation changeset...", chalk14.bold(this.stackName)));
+        await this.ioHelper.defaults.info((0, import_util50.format)("%s: creating CloudFormation changeset...", chalk14.bold(this.stackName)));
         const changeSet = await this.cfn.createChangeSet({
           StackName: this.stackName,
           ChangeSetName: changeSetName,
@@ -343033,7 +343563,7 @@ var init_deploy_stack = __esm({
           ImportExistingResources: importExistingResources,
           ...this.commonPrepareOptions()
         });
-        await this.ioHelper.defaults.debug((0, import_util48.format)("Initiated creation of changeset: %s; waiting for it to finish creating...", changeSet.Id));
+        await this.ioHelper.defaults.debug((0, import_util50.format)("Initiated creation of changeset: %s; waiting for it to finish creating...", changeSet.Id));
         const environmentResourcesRegistry = new EnvironmentResourcesRegistry();
         const envResources = environmentResourcesRegistry.for(this.options.resolvedEnvironment, this.options.sdk, this.ioHelper);
         const validationReporter = new EarlyValidationReporter(this.options.sdk, envResources);
@@ -343043,7 +343573,7 @@ var init_deploy_stack = __esm({
         });
       }
       async executeChangeSet(changeSet) {
-        await this.ioHelper.defaults.debug((0, import_util48.format)("Initiating execution of changeset %s on stack %s", changeSet.ChangeSetId, this.stackName));
+        await this.ioHelper.defaults.debug((0, import_util50.format)("Initiating execution of changeset %s on stack %s", changeSet.ChangeSetId, this.stackName));
         await this.cfn.executeChangeSet({
           StackName: this.stackName,
           ChangeSetName: changeSet.ChangeSetName,
@@ -343051,7 +343581,7 @@ var init_deploy_stack = __esm({
           ...this.commonExecuteOptions()
         });
         await this.ioHelper.defaults.debug(
-          (0, import_util48.format)(
+          (0, import_util50.format)(
             "Execution of changeset %s on stack %s has started; waiting for the update to complete...",
             changeSet.ChangeSetId,
             this.stackName
@@ -343073,7 +343603,7 @@ var init_deploy_stack = __esm({
         const terminationProtection = this.stackArtifact.terminationProtection ?? false;
         if (!!this.cloudFormationStack.terminationProtection !== terminationProtection) {
           await this.ioHelper.defaults.debug(
-            (0, import_util48.format)(
+            (0, import_util50.format)(
               "Updating termination protection from %s to %s for stack %s",
               this.cloudFormationStack.terminationProtection,
               terminationProtection,
@@ -343084,11 +343614,11 @@ var init_deploy_stack = __esm({
             StackName: this.stackName,
             EnableTerminationProtection: terminationProtection
           });
-          await this.ioHelper.defaults.debug((0, import_util48.format)("Termination protection updated to %s for stack %s", terminationProtection, this.stackName));
+          await this.ioHelper.defaults.debug((0, import_util50.format)("Termination protection updated to %s for stack %s", terminationProtection, this.stackName));
         }
       }
       async directDeployment() {
-        await this.ioHelper.defaults.info((0, import_util48.format)("%s: %s stack...", chalk14.bold(this.stackName), this.update ? "updating" : "creating"));
+        await this.ioHelper.defaults.info((0, import_util50.format)("%s: %s stack...", chalk14.bold(this.stackName), this.update ? "updating" : "creating"));
         const startTime = /* @__PURE__ */ new Date();
         if (this.update) {
           await this.updateTerminationProtection();
@@ -343101,7 +343631,7 @@ var init_deploy_stack = __esm({
             });
           } catch (err) {
             if (err.message === "No updates are to be performed.") {
-              await this.ioHelper.defaults.debug((0, import_util48.format)("No updates are to be performed for stack %s", this.stackName));
+              await this.ioHelper.defaults.debug((0, import_util50.format)("No updates are to be performed for stack %s", this.stackName));
               return {
                 type: "did-deploy-stack",
                 noOp: true,
@@ -343146,7 +343676,7 @@ var init_deploy_stack = __esm({
         } finally {
           await monitor.stop();
         }
-        await this.ioHelper.defaults.debug((0, import_util48.format)("Stack %s has completed updating", this.stackName));
+        await this.ioHelper.defaults.debug((0, import_util50.format)("Stack %s has completed updating", this.stackName));
         return {
           type: "did-deploy-stack",
           noOp: false,
@@ -343603,14 +344133,14 @@ function removeNonImportResources(stack) {
   delete template.Outputs;
   return template;
 }
-var import_util51, cfnDiff, chalk16, fs27, ResourceImporter;
+var import_util53, cfnDiff, chalk16, fs30, ResourceImporter;
 var init_importer = __esm({
   "../toolkit-lib/lib/api/resource-import/importer.ts"() {
     "use strict";
-    import_util51 = require("util");
+    import_util53 = require("util");
     cfnDiff = __toESM(require_lib11());
     chalk16 = __toESM(require_source());
-    fs27 = __toESM(require_lib6());
+    fs30 = __toESM(require_lib6());
     init_toolkit_error();
     init_deployments2();
     init_private();
@@ -343647,18 +344177,18 @@ var init_importer = __esm({
        * Load the resources to import from a file
        */
       async loadResourceIdentifiers(available, filename) {
-        const contents = await fs27.readJson(filename);
+        const contents = await fs30.readJson(filename);
         const ret = { importResources: [], resourceMap: {} };
         for (const resource of available) {
           const descr = this.describeResource(resource.logicalId);
           const idProps = contents[resource.logicalId];
           if (idProps) {
-            await this.ioHelper.defaults.info((0, import_util51.format)("%s: importing using %s", chalk16.blue(descr), chalk16.blue(fmtdict(idProps))));
+            await this.ioHelper.defaults.info((0, import_util53.format)("%s: importing using %s", chalk16.blue(descr), chalk16.blue(fmtdict(idProps))));
             ret.importResources.push(resource);
             ret.resourceMap[resource.logicalId] = idProps;
             delete contents[resource.logicalId];
           } else {
-            await this.ioHelper.defaults.info((0, import_util51.format)("%s: skipping", chalk16.blue(descr)));
+            await this.ioHelper.defaults.info((0, import_util53.format)("%s: skipping", chalk16.blue(descr)));
           }
         }
         const unknown = Object.keys(contents);
@@ -343702,9 +344232,9 @@ var init_importer = __esm({
           });
           assertIsSuccessfulDeployStackResult(result2);
           const message2 = result2.noOp ? " \u2705  %s (no changes)" : " \u2705  %s";
-          await this.ioHelper.defaults.info("\n" + chalk16.green((0, import_util51.format)(message2, this.stack.displayName)));
+          await this.ioHelper.defaults.info("\n" + chalk16.green((0, import_util53.format)(message2, this.stack.displayName)));
         } catch (e16) {
-          await this.ioHelper.notify(IO.CDK_TOOLKIT_E3900.msg((0, import_util51.format)("\n \u274C  %s failed: %s", chalk16.bold(this.stack.displayName), e16), { error: e16 }));
+          await this.ioHelper.notify(IO.CDK_TOOLKIT_E3900.msg((0, import_util53.format)("\n \u274C  %s failed: %s", chalk16.bold(this.stack.displayName), e16), { error: e16 }));
           throw e16;
         }
       }
@@ -343831,7 +344361,7 @@ var init_importer = __esm({
           for (const idProp of idProps) {
             const defaultValue = resourceProps[idProp] ?? "";
             const response = await this.ioHelper.requestResponse(IO.CDK_TOOLKIT_I3110.req(
-              (0, import_util51.format)(promptPattern, chalk16.blue(idProp)),
+              (0, import_util53.format)(promptPattern, chalk16.blue(idProp)),
               {
                 resource: {
                   name: resourceName,
@@ -343889,12 +344419,12 @@ var init_importer = __esm({
 });
 
 // ../toolkit-lib/lib/api/resource-import/migrator.ts
-var chalk17, fs28, ResourceMigrator;
+var chalk17, fs31, ResourceMigrator;
 var init_migrator = __esm({
   "../toolkit-lib/lib/api/resource-import/migrator.ts"() {
     "use strict";
     chalk17 = __toESM(require_source());
-    fs28 = __toESM(require_lib6());
+    fs31 = __toESM(require_lib6());
     init_importer();
     init_util();
     init_private();
@@ -343925,7 +344455,7 @@ var init_migrator = __esm({
           await this.ioHelper.defaults.info(`${chalk17.bold(stack.displayName)}: creating stack for resource migration...`);
           await this.ioHelper.defaults.info(`${chalk17.bold(stack.displayName)}: importing resources into stack...`);
           await this.performResourceMigration(migrateDeployment, resourcesToImport, options);
-          fs28.rmSync("migrate.json");
+          fs31.rmSync("migrate.json");
           await this.ioHelper.defaults.info(`${chalk17.bold(stack.displayName)}: applying CDKMetadata and Outputs to stack (if applicable)...`);
         }
       }
@@ -343950,7 +344480,7 @@ var init_migrator = __esm({
       }
       async tryGetResources(environment) {
         try {
-          const migrateFile = fs28.readJsonSync("migrate.json", {
+          const migrateFile = fs31.readJsonSync("migrate.json", {
             encoding: "utf-8"
           });
           const sourceEnv = migrateFile.Source.split(":");
@@ -344121,12 +344651,14 @@ var init_graph = __esm({
             const exp = exports2[value["Fn::ImportValue"]];
             if (exp != null) {
               const v17 = exp.value;
-              if ("Fn::GetAtt" in v17) {
-                const id = Array.isArray(v17["Fn::GetAtt"]) ? v17["Fn::GetAtt"][0] : v17["Fn::GetAtt"].split(".")[0];
-                return [`${exp.stackName}.${id}`];
-              }
-              if ("Ref" in v17) {
-                return [`${exp.stackName}.${v17.Ref}`];
+              if (v17 != null && typeof v17 === "object") {
+                if ("Fn::GetAtt" in v17) {
+                  const id = Array.isArray(v17["Fn::GetAtt"]) ? v17["Fn::GetAtt"][0] : v17["Fn::GetAtt"].split(".")[0];
+                  return [`${exp.stackName}.${id}`];
+                }
+                if ("Ref" in v17) {
+                  return [`${exp.stackName}.${v17.Ref}`];
+                }
               }
               return [`${exp.stackName}.${v17}`];
             }
@@ -344273,10 +344805,14 @@ function stripReferences(value, exports2) {
     const exp = exports2[value["Fn::ImportValue"]];
     if (exp != null) {
       const v17 = exp.value;
-      if ("Ref" in v17) {
-        return { __cloud_ref__: "Ref" };
-      } else if ("Fn::GetAtt" in v17) {
-        return { __cloud_ref__: "Fn::GetAtt" };
+      if (v17 != null && typeof v17 === "object") {
+        if ("Ref" in v17) {
+          return { __cloud_ref__: "Ref" };
+        } else if ("Fn::GetAtt" in v17) {
+          return { __cloud_ref__: "Fn::GetAtt" };
+        }
+      } else {
+        return v17;
       }
     }
   }
@@ -344735,10 +345271,10 @@ async function localFileDiff(stacks, options) {
       "Can only select one stack when comparing to fixed template. Use --exclusively to avoid selecting multiple stacks."
     );
   }
-  if (!await fs29.pathExists(methodOptions.path)) {
+  if (!await fs32.pathExists(methodOptions.path)) {
     throw new ToolkitError(`There is no file at ${methodOptions.path}`);
   }
-  const file = fs29.readFileSync(methodOptions.path).toString();
+  const file = fs32.readFileSync(methodOptions.path).toString();
   const template = deserializeStructure(file);
   return [{
     oldTemplate: template,
@@ -344828,11 +345364,11 @@ function appendObject(obj1, obj2) {
   }
   return obj1;
 }
-var fs29;
+var fs32;
 var init_helpers4 = __esm({
   "../toolkit-lib/lib/actions/diff/private/helpers.ts"() {
     "use strict";
-    fs29 = __toESM(require_lib6());
+    fs32 = __toESM(require_lib6());
     init_esm3();
     init_diff();
     init_cfn_api();
@@ -344903,7 +345439,7 @@ var init_private8 = __esm({
 });
 
 // ../toolkit-lib/lib/api/aws-auth/types.ts
-var init_types6 = __esm({
+var init_types7 = __esm({
   "../toolkit-lib/lib/api/aws-auth/types.ts"() {
     "use strict";
   }
@@ -345003,7 +345539,7 @@ __export(aws_auth_exports, {
 var init_aws_auth = __esm({
   "../toolkit-lib/lib/api/aws-auth/index.ts"() {
     "use strict";
-    init_types6();
+    init_types7();
     init_base_credentials();
   }
 });
@@ -345027,15 +345563,15 @@ function bootstrapVersionFromTemplate(template) {
 function bootstrapVariantFromTemplate(template) {
   return template.Parameters?.[BOOTSTRAP_VARIANT_PARAMETER]?.Default ?? DEFAULT_BOOTSTRAP_VARIANT;
 }
-var os9, path29, import_cloud_assembly_api13, import_cloud_assembly_schema6, fs30, BootstrapStack;
+var os10, path31, import_cloud_assembly_api13, import_cloud_assembly_schema6, fs33, BootstrapStack;
 var init_deploy_bootstrap = __esm({
   "../toolkit-lib/lib/api/bootstrap/deploy-bootstrap.ts"() {
     "use strict";
-    os9 = __toESM(require("os"));
-    path29 = __toESM(require("path"));
+    os10 = __toESM(require("os"));
+    path31 = __toESM(require("path"));
     import_cloud_assembly_api13 = __toESM(require_lib3());
     import_cloud_assembly_schema6 = __toESM(require_lib2());
-    fs30 = __toESM(require_lib6());
+    fs33 = __toESM(require_lib6());
     init_bootstrap_props();
     init_deployments2();
     init_deploy_stack();
@@ -345103,11 +345639,11 @@ var init_deploy_bootstrap = __esm({
             return abortResponse;
           }
         }
-        const outdir = await fs30.mkdtemp(path29.join(os9.tmpdir(), "cdk-bootstrap"));
+        const outdir = await fs33.mkdtemp(path31.join(os10.tmpdir(), "cdk-bootstrap"));
         try {
           const builder = new import_cloud_assembly_api13.CloudAssemblyBuilder(outdir);
           const templateFile = `${this.toolkitStackName}.template.json`;
-          await fs30.writeJson(path29.join(builder.outdir, templateFile), template, {
+          await fs33.writeJson(path31.join(builder.outdir, templateFile), template, {
             spaces: 2
           });
           builder.addArtifact(this.toolkitStackName, {
@@ -345136,7 +345672,7 @@ var init_deploy_bootstrap = __esm({
           assertIsSuccessfulDeployStackResult(ret);
           return ret;
         } finally {
-          await fs30.rm(outdir, { recursive: true, force: true });
+          await fs33.rm(outdir, { recursive: true, force: true });
         }
       }
     };
@@ -345241,11 +345777,11 @@ function splitCfnArray(xs) {
 function intersection(xs, ys) {
   return new Set(Array.from(xs).filter((x16) => ys.has(x16)));
 }
-var path30, Bootstrapper, USE_AWS_MANAGED_KEY, CREATE_NEW_KEY, CDK_BOOTSTRAP_PERMISSIONS_BOUNDARY;
+var path32, Bootstrapper, USE_AWS_MANAGED_KEY, CREATE_NEW_KEY, CDK_BOOTSTRAP_PERMISSIONS_BOUNDARY;
 var init_bootstrap_environment = __esm({
   "../toolkit-lib/lib/api/bootstrap/bootstrap-environment.ts"() {
     "use strict";
-    path30 = __toESM(require("path"));
+    path32 = __toESM(require("path"));
     init_deploy_bootstrap();
     init_legacy_template();
     init_toolkit_error();
@@ -345513,7 +346049,7 @@ var init_bootstrap_environment = __esm({
           case "custom":
             return loadStructuredFile(this.source.templateFile);
           case "default":
-            return loadStructuredFile(path30.join(bundledPackageRootDir(__dirname), "lib", "api", "bootstrap", "bootstrap-template.yaml"));
+            return loadStructuredFile(path32.join(bundledPackageRootDir(__dirname), "lib", "api", "bootstrap", "bootstrap-template.yaml"));
           case "legacy":
             return legacyBootstrapTemplate(legacyParams);
         }
@@ -345537,529 +346073,6 @@ var init_bootstrap3 = __esm({
   }
 });
 
-// ../toolkit-lib/lib/api/cloud-assembly/private/borrowed-assembly.ts
-var import_dispose_polyfill3, BorrowedAssembly;
-var init_borrowed_assembly = __esm({
-  "../toolkit-lib/lib/api/cloud-assembly/private/borrowed-assembly.ts"() {
-    "use strict";
-    import_dispose_polyfill3 = __toESM(require_dispose_polyfill());
-    BorrowedAssembly = class {
-      constructor(cloudAssembly) {
-        this.cloudAssembly = cloudAssembly;
-      }
-      static {
-        __name(this, "BorrowedAssembly");
-      }
-      async _unlock() {
-      }
-      async dispose() {
-      }
-      async [Symbol.asyncDispose]() {
-      }
-    };
-  }
-});
-
-// ../toolkit-lib/lib/api/cloud-assembly/cached-source.ts
-var import_dispose_polyfill4, CachedCloudAssembly;
-var init_cached_source = __esm({
-  "../toolkit-lib/lib/api/cloud-assembly/cached-source.ts"() {
-    "use strict";
-    import_dispose_polyfill4 = __toESM(require_dispose_polyfill());
-    init_borrowed_assembly();
-    CachedCloudAssembly = class {
-      static {
-        __name(this, "CachedCloudAssembly");
-      }
-      asm;
-      constructor(asm) {
-        this.asm = asm;
-      }
-      get cloudAssembly() {
-        return this.asm.cloudAssembly;
-      }
-      async produce() {
-        return new BorrowedAssembly(this.asm.cloudAssembly);
-      }
-      _unlock() {
-        return this.asm._unlock();
-      }
-      dispose() {
-        return this.asm.dispose();
-      }
-      [Symbol.asyncDispose]() {
-        return this.dispose();
-      }
-    };
-  }
-});
-
-// ../toolkit-lib/lib/api/cloud-assembly/context-store.ts
-function persistableContext(context) {
-  return Object.fromEntries(Object.entries(context).filter(([_2, value]) => !isTransientValue2(value)));
-}
-function isTransientValue2(x16) {
-  return x16 && typeof x16 === "object" && x16[TRANSIENT_CONTEXT_KEY];
-}
-async function settingsFromFile(filename) {
-  try {
-    const data2 = JSON.parse(await import_fs7.promises.readFile(filename, "utf-8"));
-    return new Settings(data2);
-  } catch (e16) {
-    if (e16.code === "ENOENT") {
-      return new Settings();
-    }
-    throw e16;
-  }
-}
-var import_fs7, os10, path31, CdkAppMultiContext, FileContext, MemoryContext;
-var init_context_store = __esm({
-  "../toolkit-lib/lib/api/cloud-assembly/context-store.ts"() {
-    "use strict";
-    import_fs7 = require("fs");
-    os10 = __toESM(require("os"));
-    path31 = __toESM(require("path"));
-    init_toolkit_error();
-    init_context();
-    init_settings();
-    CdkAppMultiContext = class {
-      constructor(appDirectory, commandlineContext) {
-        this.commandlineContext = commandlineContext;
-        this.configContextFile = path31.join(appDirectory, "cdk.json");
-        this.projectContextFile = path31.join(appDirectory, "cdk.context.json");
-        this.userConfigFile = path31.join(os10.homedir() ?? "/tmp", ".cdk.json");
-      }
-      static {
-        __name(this, "CdkAppMultiContext");
-      }
-      _context;
-      configContextFile;
-      projectContextFile;
-      userConfigFile;
-      async read() {
-        const context = await this.asyncInitialize();
-        return context.all;
-      }
-      async update(updates) {
-        const context = await this.asyncInitialize();
-        for (const [key, value] of Object.entries(updates)) {
-          context.set(key, value);
-        }
-        await context.save(this.projectContextFile);
-      }
-      /**
-       * Initialize the `Context` object
-       *
-       * This code all exists to reuse code that's already there, to minimize
-       * the chances of the new code behaving subtly differently than the
-       * old code.
-       *
-       * It might be most of this is unnecessary now...
-       */
-      async asyncInitialize() {
-        if (this._context) {
-          return this._context;
-        }
-        const contextSources = [
-          { bag: new Settings(this.commandlineContext, true) },
-          {
-            fileName: this.configContextFile,
-            bag: (await settingsFromFile(this.configContextFile)).subSettings(["context"]).makeReadOnly()
-          },
-          {
-            fileName: this.projectContextFile,
-            bag: await settingsFromFile(this.projectContextFile)
-          },
-          {
-            fileName: this.userConfigFile,
-            bag: (await settingsFromFile(this.userConfigFile)).subSettings(["context"]).makeReadOnly()
-          }
-        ];
-        this._context = new Context(...contextSources);
-        return this._context;
-      }
-    };
-    FileContext = class {
-      constructor(fileName) {
-        this.fileName = fileName;
-      }
-      static {
-        __name(this, "FileContext");
-      }
-      _cache;
-      async read() {
-        if (!this._cache) {
-          try {
-            this._cache = JSON.parse(await import_fs7.promises.readFile(this.fileName, "utf-8"));
-          } catch (e16) {
-            if (e16.code === "ENOENT") {
-              this._cache = {};
-            } else {
-              throw e16;
-            }
-          }
-        }
-        if (!this._cache || typeof this._cache !== "object") {
-          throw new ToolkitError(`${this.fileName} must contain an object, got: ${JSON.stringify(this._cache)}`);
-        }
-        return this._cache;
-      }
-      async update(updates) {
-        this._cache = {
-          ...await this.read(),
-          ...updates
-        };
-        const persistable = persistableContext(this._cache);
-        await import_fs7.promises.writeFile(this.fileName, JSON.stringify(persistable, void 0, 2), "utf-8");
-      }
-    };
-    MemoryContext = class {
-      static {
-        __name(this, "MemoryContext");
-      }
-      context = {};
-      constructor(initialContext) {
-        this.context = { ...initialContext };
-      }
-      read() {
-        return Promise.resolve(this.context);
-      }
-      update(updates) {
-        this.context = {
-          ...this.context,
-          ...updates
-        };
-        return Promise.resolve();
-      }
-    };
-    __name(persistableContext, "persistableContext");
-    __name(isTransientValue2, "isTransientValue");
-    __name(settingsFromFile, "settingsFromFile");
-  }
-});
-
-// ../toolkit-lib/lib/api/cloud-assembly/private/readable-assembly.ts
-var import_node_fs, ReadableCloudAssembly;
-var init_readable_assembly = __esm({
-  "../toolkit-lib/lib/api/cloud-assembly/private/readable-assembly.ts"() {
-    "use strict";
-    import_node_fs = require("node:fs");
-    ReadableCloudAssembly = class {
-      constructor(cloudAssembly, lock, options) {
-        this.cloudAssembly = cloudAssembly;
-        this.lock = lock;
-        this.options = options;
-      }
-      static {
-        __name(this, "ReadableCloudAssembly");
-      }
-      async _unlock() {
-        return this.lock.release();
-      }
-      async dispose() {
-        await this.lock.release();
-        if (this.options?.deleteOnDispose) {
-          await import_node_fs.promises.rm(this.cloudAssembly.directory, { recursive: true, force: true });
-        }
-      }
-      [Symbol.asyncDispose]() {
-        return this.dispose();
-      }
-    };
-  }
-});
-
-// ../toolkit-lib/lib/api/cloud-assembly/source-builder.ts
-var path32, import_util56, cxapi5, fs33, CloudAssemblySourceBuilder;
-var init_source_builder = __esm({
-  "../toolkit-lib/lib/api/cloud-assembly/source-builder.ts"() {
-    "use strict";
-    path32 = __toESM(require("path"));
-    import_util56 = require("util");
-    cxapi5 = __toESM(require_lib3());
-    fs33 = __toESM(require_lib6());
-    init_context_store();
-    init_rwlock();
-    init_cached_source();
-    init_context_aware_source();
-    init_exec();
-    init_prepare_source();
-    init_readable_assembly();
-    init_toolkit_error();
-    init_util();
-    init_private();
-    init_helpers();
-    CloudAssemblySourceBuilder = class {
-      static {
-        __name(this, "CloudAssemblySourceBuilder");
-      }
-      /**
-       * Create a Cloud Assembly from a Cloud Assembly builder function.
-       *
-       * ## Outdir
-       *
-       * If no output directory is given, it will synthesize into a temporary system
-       * directory. The temporary directory will be cleaned up, unless
-       * `disposeOutdir: false`.
-       *
-       * A write lock will be acquired on the output directory for the duration of
-       * the CDK app synthesis (which means that no two apps can synthesize at the
-       * same time), and after synthesis a read lock will be acquired on the
-       * directory. This means that while the CloudAssembly is being used, no CDK
-       * app synthesis can take place into that directory.
-       *
-       * ## Context
-       *
-       * If no `contextStore` is given, a `MemoryContext` will be used. This means
-       * no provider lookups will be persisted anywhere by default. Use a different
-       * type of context store if you want persistence between synth operations.
-       *
-       * @param builder - the builder function
-       * @param props - additional configuration properties
-       * @returns the CloudAssembly source
-       */
-      async fromAssemblyBuilder(builder, props = {}) {
-        const services = await this.sourceBuilderServices();
-        const contextStore = props.contextStore ?? new MemoryContext();
-        const contextAssemblyProps = {
-          services,
-          contextStore,
-          lookups: props.lookups
-        };
-        const outdir = props.outdir ? path32.resolve(props.outdir) : void 0;
-        return new ContextAwareCloudAssemblySource(
-          {
-            produce: /* @__PURE__ */ __name(async () => {
-              var _stack = [];
-              try {
-                const execution = __using(_stack, await ExecutionEnvironment.create(services, {
-                  outdir,
-                  resolveDefaultAppEnv: props.resolveDefaultEnvironment ?? true
-                }), true);
-                const synthParams = parametersFromSynthOptions(props.synthOptions);
-                const fullContext = {
-                  ...await contextStore.read(),
-                  ...synthParams.context
-                };
-                await services.ioHelper.defaults.debug((0, import_util56.format)("context:", fullContext));
-                const env = noUndefined({
-                  // Versioning, outdir, default account and region
-                  ...await execution.defaultEnvVars(),
-                  // Environment variables derived from settings
-                  ...synthParams.env
-                });
-                const cleanupContextTemp = writeContextToEnv(env, fullContext, "env-is-complete");
-                const _cleanupEnv = __using(_stack, props.clobberEnv ?? true ? temporarilyWriteEnv(env) : void 0);
-                let assembly;
-                try {
-                  assembly = await builder({
-                    outdir: execution.outdir,
-                    context: fullContext,
-                    env
-                  });
-                } catch (error4) {
-                  if (ToolkitError.isToolkitError(error4)) {
-                    throw error4;
-                  }
-                  throw AssemblyError.withCause("Assembly builder failed", error4);
-                } finally {
-                  await cleanupContextTemp();
-                }
-                const asm = cxapi5.CloudAssembly.isCloudAssembly(assembly) ? assembly : await assemblyFromDirectory(assembly.directory, services.ioHelper, props.loadAssemblyOptions);
-                const success2 = await execution.markSuccessful();
-                const deleteOnDispose = props.disposeOutdir ?? execution.shouldDisposeOutDir;
-                return new ReadableCloudAssembly(asm, success2.readLock, { deleteOnDispose });
-              } catch (_2) {
-                var _error = _2, _hasError = true;
-              } finally {
-                var _promise = __callDispose(_stack, _error, _hasError);
-                _promise && await _promise;
-              }
-            }, "produce")
-          },
-          contextAssemblyProps
-        );
-      }
-      /**
-       * Creates a Cloud Assembly from an existing assembly directory.
-       *
-       * A read lock will be acquired for the directory. This means that while
-       * the CloudAssembly is being used, no CDK app synthesis can take place into
-       * that directory.
-       *
-       * @param directory - directory the directory of a already produced Cloud Assembly.
-       * @returns the CloudAssembly source
-       */
-      async fromAssemblyDirectory(directory, props = {}) {
-        const services = await this.sourceBuilderServices();
-        return {
-          async produce() {
-            await services.ioHelper.notify(IO.CDK_ASSEMBLY_I0150.msg("--app points to a cloud assembly, so we bypass synth"));
-            const readLock = await new RWLock(directory).acquireRead();
-            try {
-              const asm = await assemblyFromDirectory(directory, services.ioHelper, props.loadAssemblyOptions);
-              const assembly = new ReadableCloudAssembly(asm, readLock, { deleteOnDispose: false });
-              if (assembly.cloudAssembly.manifest.missing && assembly.cloudAssembly.manifest.missing.length > 0) {
-                if (props.failOnMissingContext ?? true) {
-                  const missingKeysSet = missingContextKeys(assembly.cloudAssembly.manifest.missing);
-                  const missingKeys = Array.from(missingKeysSet);
-                  throw AssemblyError.withCause(
-                    `Assembly contains missing context. Make sure all necessary context is already in 'cdk.context.json' by running 'cdk synth' on a machine with sufficient AWS credentials and committing the result. Missing context keys: '${missingKeys.join(", ")}'`,
-                    "Error producing assembly"
-                  );
-                }
-              }
-              return new CachedCloudAssembly(assembly);
-            } catch (e16) {
-              await readLock.release();
-              throw e16;
-            }
-          }
-        };
-      }
-      /**
-       * Use an AWS CDK app exectuable as source.
-       *
-       * `app` is a command line that will be executed to produce a Cloud Assembly.
-       * The command will be executed in a shell, so it must come from a trusted source.
-       *
-       * The subprocess will execute in `workingDirectory`, which defaults to
-       * the current process' working directory if not given.
-       *
-       * ## Outdir
-       *
-       * If an output directory is supplied, relative paths are evaluated with
-       * respect to the current process' working directory. If an output directory
-       * is not supplied, the default is a `cdk.out` directory underneath
-       * `workingDirectory`. The output directory will not be cleaned up unless
-       * `disposeOutdir: true`.
-       *
-       * A write lock will be acquired on the output directory for the duration of
-       * the CDK app synthesis (which means that no two apps can synthesize at the
-       * same time), and after synthesis a read lock will be acquired on the
-       * directory.  This means that while the CloudAssembly is being used, no CDK
-       * app synthesis can take place into that directory.
-       *
-       * ## Context
-       *
-       * If no `contextStore` is given, a `CdkAppMultiContext` will be used, initialized
-       * to the app's `workingDirectory`. This means that context will be loaded from
-       * all the CDK's default context sources, and updates will be written to
-       * `cdk.context.json`.
-       *
-       * @param props - additional configuration properties
-       * @returns the CloudAssembly source
-       */
-      async fromCdkApp(app, props = {}) {
-        const services = await this.sourceBuilderServices();
-        const workingDirectory = props.workingDirectory ?? process.cwd();
-        const outdir = props.outdir ? path32.resolve(props.outdir) : path32.resolve(workingDirectory, "cdk.out");
-        const contextStore = props.contextStore ?? new CdkAppMultiContext(workingDirectory);
-        const contextAssemblyProps = {
-          services,
-          contextStore,
-          lookups: props.lookups
-        };
-        return new ContextAwareCloudAssemblySource(
-          {
-            produce: /* @__PURE__ */ __name(async () => {
-              var _stack = [];
-              try {
-                try {
-                  fs33.mkdirpSync(outdir);
-                } catch (e16) {
-                  throw new ToolkitError(`Could not create output directory at '${outdir}' (${e16.message}).`);
-                }
-                const execution = __using(_stack, await ExecutionEnvironment.create(services, {
-                  outdir,
-                  resolveDefaultAppEnv: props.resolveDefaultEnvironment ?? true
-                }), true);
-                const commandLine = await execution.guessExecutable(app);
-                const synthParams = parametersFromSynthOptions(props.synthOptions);
-                const fullContext = {
-                  ...await contextStore.read(),
-                  ...synthParams.context
-                };
-                await services.ioHelper.defaults.debug((0, import_util56.format)("context:", fullContext));
-                const env = noUndefined({
-                  // Need to start with full env of `writeContextToEnv` will not be able to do the size
-                  // calculation correctly.
-                  ...process.env,
-                  // User gave us something
-                  ...props.env,
-                  // Versioning, outdir, default account and region
-                  ...await execution.defaultEnvVars(),
-                  // Environment variables derived from settings
-                  ...synthParams.env
-                });
-                const cleanupTemp = writeContextToEnv(env, fullContext, "env-is-complete");
-                try {
-                  await execInChildProcess(commandLine, {
-                    eventPublisher: /* @__PURE__ */ __name(async (type, line) => {
-                      switch (type) {
-                        case "data_stdout":
-                          await services.ioHelper.notify(IO.CDK_ASSEMBLY_I1001.msg(line));
-                          break;
-                        case "data_stderr":
-                          await services.ioHelper.notify(IO.CDK_ASSEMBLY_E1002.msg(line));
-                          break;
-                      }
-                    }, "eventPublisher"),
-                    env,
-                    cwd: workingDirectory
-                  });
-                } finally {
-                  await cleanupTemp();
-                }
-                const asm = await assemblyFromDirectory(outdir, services.ioHelper, props.loadAssemblyOptions);
-                const success2 = await execution.markSuccessful();
-                const deleteOnDispose = props.disposeOutdir ?? execution.shouldDisposeOutDir;
-                return new ReadableCloudAssembly(asm, success2.readLock, { deleteOnDispose });
-              } catch (_2) {
-                var _error = _2, _hasError = true;
-              } finally {
-                var _promise = __callDispose(_stack, _error, _hasError);
-                _promise && await _promise;
-              }
-            }, "produce")
-          },
-          contextAssemblyProps
-        );
-      }
-    };
-  }
-});
-
-// ../toolkit-lib/lib/api/cloud-assembly/types.ts
-var init_types7 = __esm({
-  "../toolkit-lib/lib/api/cloud-assembly/types.ts"() {
-    "use strict";
-  }
-});
-
-// ../toolkit-lib/lib/api/cloud-assembly/index.ts
-var cloud_assembly_exports3 = {};
-__export(cloud_assembly_exports3, {
-  CachedCloudAssembly: () => CachedCloudAssembly,
-  CdkAppMultiContext: () => CdkAppMultiContext,
-  CloudAssemblySourceBuilder: () => CloudAssemblySourceBuilder,
-  ExpandStackSelection: () => ExpandStackSelection,
-  FileContext: () => FileContext,
-  MemoryContext: () => MemoryContext,
-  StackSelectionStrategy: () => StackSelectionStrategy,
-  persistableContext: () => persistableContext
-});
-var init_cloud_assembly3 = __esm({
-  "../toolkit-lib/lib/api/cloud-assembly/index.ts"() {
-    "use strict";
-    init_stack_selector();
-    init_cached_source();
-    init_source_builder();
-    init_types7();
-    init_context_store();
-  }
-});
-
 // ../toolkit-lib/lib/api/diff/diff-formatter.ts
 function buildLogicalToPathMap(stack) {
   const map2 = {};
@@ -348861,6 +348874,10 @@ var init_toolkit_lib = __esm({
       static {
         __name(this, "ToolkitLibRunnerEngine");
       }
+      toolkit;
+      options;
+      showOutput;
+      ioHost;
       constructor(options) {
         this.options = options;
         this.showOutput = options.showOutput ?? false;
@@ -348882,47 +348899,42 @@ var init_toolkit_lib = __esm({
           // Logging
           //  - options.color
           // SDK
-          //  - options.profile
           //  - options.proxy
           //  - options.caBundlePath
         });
       }
       /**
-       * Synthesizes the CDK app through the Toolkit
+       * Synthesizes the CDK app
        */
       async synth(options) {
-        const cx = await this.cx(options);
-        const lock = await this.toolkit.synth(cx, {
-          stacks: this.stackSelector(options),
-          validateStacks: options.validation
-        });
-        await this.validateRegion(lock);
-        await lock.dispose();
-      }
-      /**
-       * Synthesizes the CDK app quickly, by bypassing the Toolkit and just invoking the app command
-       */
-      async synthFast(options) {
-        const cx = await this.toolkit.fromCdkApp(options.execCmd.join(" "), {
-          workingDirectory: this.options.workingDirectory,
-          outdir: options.output ? path34.join(this.options.workingDirectory, options.output) : void 0,
-          contextStore: new import_toolkit_lib.MemoryContext(options.context),
+        const cx = await this.cx({
+          app: options.app,
+          output: options.output,
+          context: options.context,
           lookups: false,
           resolveDefaultEnvironment: false,
-          env: {
-            ...this.options.env,
-            ...options.env
-          },
-          synthOptions: {
-            versionReporting: false,
-            pathMetadata: false,
-            assetMetadata: false
-          }
+          env: options.env,
+          versionReporting: false,
+          pathMetadata: false,
+          assetMetadata: false
         });
         try {
-          const lock = await cx.produce();
-          await this.validateRegion(lock);
-          await lock.dispose();
+          var _stack = [];
+          try {
+            const lock = __using(_stack, await this.toolkit.synth(cx, {
+              validateStacks: false,
+              stacks: {
+                strategy: import_toolkit_lib.StackSelectionStrategy.ALL_STACKS,
+                failOnEmpty: false
+              }
+            }), true);
+            await this.validateRegion(lock);
+          } catch (_2) {
+            var _error = _2, _hasError = true;
+          } finally {
+            var _promise = __callDispose(_stack, _error, _hasError);
+            _promise && await _promise;
+          }
         } catch (e16) {
           if (e16.message.includes("Missing context keys")) {
             return;
@@ -348944,15 +348956,14 @@ var init_toolkit_lib = __esm({
        * Deploys the CDK app
        */
       async deploy(options) {
-        if (options.watch) {
-          return this.watch(options);
-        }
         const cx = await this.cx(options);
         await this.toolkit.deploy(cx, {
           roleArn: options.roleArn,
           traceLogs: options.traceLogs,
           stacks: this.stackSelector(options),
-          deploymentMethod: this.deploymentMethod(options),
+          deploymentMethod: {
+            method: "change-set"
+          },
           outputsFile: options.outputsFile ? path34.join(this.options.workingDirectory, options.outputsFile) : void 0
         });
       }
@@ -348966,7 +348977,7 @@ var init_toolkit_lib = __esm({
             roleArn: options.roleArn,
             traceLogs: options.traceLogs,
             stacks: this.stackSelector(options),
-            deploymentMethod: this.deploymentMethod(options)
+            deploymentMethod: options.deploymentMethod
           });
           await watcher.waitForEnd();
         } catch (e16) {
@@ -349012,7 +349023,11 @@ var init_toolkit_lib = __esm({
           outdir,
           lookups: options.lookups,
           contextStore: new import_toolkit_lib.MemoryContext(options.context),
-          env: this.options.env,
+          resolveDefaultEnvironment: options.resolveDefaultEnvironment,
+          env: {
+            ...this.options.env,
+            ...options.env
+          },
           synthOptions: {
             debug: options.debug,
             versionReporting: options.versionReporting ?? false,
@@ -349032,20 +349047,6 @@ var init_toolkit_lib = __esm({
           expand: options.exclusively ? import_toolkit_lib.ExpandStackSelection.NONE : import_toolkit_lib.ExpandStackSelection.UPSTREAM
         };
       }
-      /**
-       * Creates a DeploymentMethod from the provided options.
-       */
-      deploymentMethod(options) {
-        if (options.hotswap && options.hotswap !== "full-deployment") {
-          return {
-            method: "hotswap",
-            fallback: options.hotswap === "fall-back" ? { method: "change-set" } : void 0
-          };
-        }
-        return {
-          method: options.deploymentMethod ?? "change-set"
-        };
-      }
       /**
        * Check that the regions for the stacks in the CloudAssembly match the regions requested on the engine
        *
@@ -349070,6 +349071,9 @@ var init_toolkit_lib = __esm({
        * This catches that misconfiguration.
        */
       async validateRegion(asm) {
+        if (this.options.region === import_cloud_assembly_api14.UNKNOWN_REGION) {
+          return;
+        }
         for (const stack of asm.cloudAssembly.stacksRecursively) {
           if (stack.environment.region !== this.options.region && stack.environment.region !== import_cloud_assembly_api14.UNKNOWN_REGION) {
             this.ioHost.notify({
@@ -349194,9 +349198,7 @@ var init_cloud_assembly4 = __esm({
       static {
         __name(this, "AssemblyManifestReader");
       }
-      static {
-        this.DEFAULT_FILENAME = "manifest.json";
-      }
+      static DEFAULT_FILENAME = "manifest.json";
       /**
        * Reads a Cloud Assembly manifest from a file
        */
@@ -349225,6 +349227,10 @@ var init_cloud_assembly4 = __esm({
         }
         return _AssemblyManifestReader.fromFile(filePath);
       }
+      /**
+       * The directory where the manifest was found
+       */
+      directory;
       /**
        * Get the stacks from the manifest
        * returns a map of artifactId to CloudFormation template
@@ -349432,15 +349438,68 @@ var init_runner_base = __esm({
     init_integ_manifest();
     DESTRUCTIVE_CHANGES = "!!DESTRUCTIVE_CHANGES:";
     IntegRunner = class {
+      static {
+        __name(this, "IntegRunner");
+      }
+      /**
+       * The directory where the snapshot will be stored
+       */
+      snapshotDir;
+      /**
+       * An instance of the CDK  CLI
+       */
+      cdk;
+      /**
+       * Pretty name of the test
+       */
+      testName;
+      /**
+       * The value used in the '--app' CLI parameter
+       *
+       * Path to the integ test source file, relative to `this.directory`.
+       */
+      cdkApp;
+      /**
+       * The path where the `cdk.context.json` file
+       * will be created
+       */
+      cdkContextPath;
+      /**
+       * The working directory that the integration tests will be
+       * executed from
+       */
+      directory;
+      /**
+       * The test to run
+       */
+      test;
+      /**
+       * Default options to pass to the CDK CLI
+       */
+      defaultArgs = {
+        pathMetadata: false,
+        assetMetadata: false,
+        versionReporting: false
+      };
+      /**
+       * The directory where the CDK will be synthed to
+       *
+       * Relative to cwd.
+       */
+      cdkOutDir;
+      /**
+       * The profile to use for the CDK CLI calls
+       */
+      profile;
+      /**
+       * Show output from the integ test run.
+       */
+      showOutput;
+      _destructiveChanges;
+      legacyContext;
+      _expectedTestSuite;
+      _actualTestSuite;
       constructor(options) {
-        /**
-         * Default options to pass to the CDK CLI
-         */
-        this.defaultArgs = {
-          pathMetadata: false,
-          assetMetadata: false,
-          versionReporting: false
-        };
         this.test = options.test;
         this.directory = this.test.directory;
         this.testName = this.test.testName;
@@ -349453,9 +349512,6 @@ var init_runner_base = __esm({
         const testRunCommand = this.test.appCommand;
         this.cdkApp = testRunCommand.replace("{filePath}", path36.relative(this.directory, this.test.fileName));
       }
-      static {
-        __name(this, "IntegRunner");
-      }
       /**
        * Return the list of expected (i.e. existing) test cases for this integration test
        */
@@ -349474,8 +349530,8 @@ var init_runner_base = __esm({
        * This will synth and then load the integration test manifest
        */
       async generateActualSnapshot() {
-        await this.cdk.synthFast({
-          execCmd: this.cdkApp.split(" "),
+        await this.cdk.synth({
+          app: this.cdkApp,
           // we don't know the "actual" context yet (this method is what generates it) so just
           // use the "expected" context. This is only run in order to read the manifest
           context: this.getContext((await this.expectedTestSuite())?.synthContext),
@@ -349630,8 +349686,8 @@ var init_runner_base = __esm({
           fs37.removeSync(this.snapshotDir);
         }
         const actualTestSuite = await this.actualTestSuite();
-        await this.cdk.synthFast({
-          execCmd: this.cdkApp.split(" "),
+        await this.cdk.synth({
+          app: this.cdkApp,
           context: this.getContext(actualTestSuite.enableLookups ? DEFAULT_SYNTH_OPTIONS.context : {}),
           env: DEFAULT_SYNTH_OPTIONS.env,
           output: path36.relative(this.directory, this.snapshotDir)
@@ -349724,13 +349780,6 @@ var init_runner_base = __esm({
   }
 });
 
-// lib/engines/cdk-interface.ts
-var init_cdk_interface = __esm({
-  "lib/engines/cdk-interface.ts"() {
-    "use strict";
-  }
-});
-
 // lib/workers/common.ts
 function formatAssertionResults(results) {
   return Object.entries(results).map(([id, result2]) => (0, import_util64.format)("%s%s", id, result2.status === "success" ? ` - ${result2.status}` : `
@@ -349772,7 +349821,6 @@ var init_integ_test_runner = __esm({
     fs38 = __toESM(require_lib5());
     workerpool = __toESM(require_src());
     init_runner_base();
-    init_cdk_interface();
     init_logger();
     init_utils();
     init_common8();
@@ -349869,15 +349917,17 @@ https://github.com/aws/aws-cdk/tree/main/packages/%40aws-cdk/integ-tests-alpha`
           await this.watch(
             {
               ...this.defaultArgs,
-              progress: "bar" /* BAR */,
-              hotswap: "fall-back" /* FALL_BACK */,
-              deploymentMethod: "direct",
+              deploymentMethod: {
+                method: "hotswap",
+                fallback: {
+                  method: "change-set"
+                }
+              },
               profile: this.profile,
               requireApproval: import_cloud_assembly_schema9.RequireApproval.NEVER,
               traceLogs: enableForVerbosityLevel(2) ?? false,
               verbose: enableForVerbosityLevel(3),
-              debug: enableForVerbosityLevel(4),
-              watch: true
+              debug: enableForVerbosityLevel(4)
             },
             options.testCaseName,
             options.verbosity ?? 0
@@ -349981,7 +350031,7 @@ https://github.com/aws/aws-cdk/tree/main/packages/%40aws-cdk/integ-tests-alpha`
           );
         }
       }
-      async watch(watchArgs, testCaseName, verbosity) {
+      async watch(options, testCaseName, verbosity) {
         const actualTestSuite = await this.actualTestSuite();
         const actualTestCase = actualTestSuite.testSuite[testCaseName];
         if (actualTestCase.hooks?.preDeploy) {
@@ -349991,8 +350041,8 @@ https://github.com/aws/aws-cdk/tree/main/packages/%40aws-cdk/integ-tests-alpha`
             });
           });
         }
-        const deployArgs = {
-          ...watchArgs,
+        const watchArgs = {
+          ...options,
           lookups: actualTestSuite.enableLookups,
           stacks: [
             ...actualTestCase.stacks,
@@ -350013,8 +350063,8 @@ https://github.com/aws/aws-cdk/tree/main/packages/%40aws-cdk/integ-tests-alpha`
               ...process.env.AWS_REGION ? [`AWS_REGION=${process.env.AWS_REGION}`] : [],
               "cdk destroy",
               `-a '${this.cdkApp}'`,
-              deployArgs.stacks.join(" "),
-              `--profile ${deployArgs.profile}`
+              watchArgs.stacks.join(" "),
+              `--profile ${watchArgs.profile}`
             ].join(" ")}`
           ]
         };
@@ -350028,9 +350078,9 @@ https://github.com/aws/aws-cdk/tree/main/packages/%40aws-cdk/integ-tests-alpha`
                 `-a '${this.cdkApp}'`,
                 `-o '${this.cdkOutDir}'`,
                 ...Object.entries(this.getContext()).flatMap(([k16, v17]) => typeof v17 !== "object" ? [`-c '${k16}=${v17}'`] : []),
-                deployArgs.stacks.join(" "),
-                `--outputs-file ${deployArgs.outputsFile}`,
-                `--profile ${deployArgs.profile}`,
+                watchArgs.stacks.join(" "),
+                `--outputs-file ${watchArgs.outputsFile}`,
+                `--profile ${watchArgs.profile}`,
                 "--hotswap-fallback"
               ].join(" ")}`
             ]
@@ -350084,7 +350134,7 @@ https://github.com/aws/aws-cdk/tree/main/packages/%40aws-cdk/integ-tests-alpha`
           });
         });
         const { promise: waiter, resolve: resolve13 } = promiseWithResolvers();
-        await this.cdk.watch(deployArgs, {
+        await this.cdk.watch(watchArgs, {
           // if `-v` (or above) is passed then stream the logs
           onStdout: /* @__PURE__ */ __name((message2) => {
             if (verbosity > 0) {
@@ -350233,13 +350283,14 @@ https://github.com/aws/aws-cdk/tree/main/packages/%40aws-cdk/integ-tests-alpha`
 });
 
 // lib/runner/snapshot-test-runner.ts
-var path38, import_stream2, import_string_decoder, import_cloudformation_diff4, IntegSnapshotRunner, StringWritable;
+var path38, import_stream2, import_string_decoder, import_cloud_assembly_api17, import_cloudformation_diff4, IntegSnapshotRunner, StringWritable;
 var init_snapshot_test_runner = __esm({
   "lib/runner/snapshot-test-runner.ts"() {
     "use strict";
     path38 = __toESM(require("path"));
     import_stream2 = require("stream");
     import_string_decoder = require("string_decoder");
+    import_cloud_assembly_api17 = __toESM(require_lib3());
     import_cloudformation_diff4 = __toESM(require_lib11());
     init_cloud_assembly4();
     init_runner_base();
@@ -350251,7 +350302,7 @@ var init_snapshot_test_runner = __esm({
       constructor(options) {
         super({
           ...options,
-          region: "unused"
+          region: import_cloud_assembly_api17.UNKNOWN_REGION
         });
       }
       /**
@@ -350267,8 +350318,8 @@ var init_snapshot_test_runner = __esm({
           const actualTestSuite = await this.actualTestSuite();
           const expectedSnapshotAssembly = this.getSnapshotAssembly(this.snapshotDir, expectedTestSuite?.stacks);
           const env = DEFAULT_SYNTH_OPTIONS.env;
-          await this.cdk.synthFast({
-            execCmd: this.cdkApp.split(" "),
+          await this.cdk.synth({
+            app: this.cdkApp,
             context: this.getContext(actualTestSuite.enableLookups ? DEFAULT_SYNTH_OPTIONS.context : {}),
             env,
             output: path38.relative(this.directory, this.cdkOutDir)
@@ -350512,6 +350563,8 @@ var init_snapshot_test_runner = __esm({
       static {
         __name(this, "StringWritable");
       }
+      data;
+      _decoder;
       constructor(options) {
         super(options);
         this._decoder = new import_string_decoder.StringDecoder();
@@ -350557,6 +350610,55 @@ var init_integration_tests = __esm({
       static {
         __name(this, "IntegTest");
       }
+      /**
+       * The name of the file to run
+       *
+       * Path is relative to the current working directory.
+       */
+      fileName;
+      /**
+       * Relative path to the file to run
+       *
+       * Relative from the "discovery root".
+       */
+      discoveryRelativeFileName;
+      /**
+       * The absolute path to the file
+       */
+      absoluteFileName;
+      /**
+       * The normalized name of the test. This name
+       * will be the same regardless of what directory the tool
+       * is run from.
+       */
+      normalizedTestName;
+      /**
+       * Directory the test is in
+       */
+      directory;
+      /**
+       * Display name for the test
+       *
+       * Depends on the discovery directory.
+       *
+       * Looks like `integ.mytest` or `package/test/integ.mytest`.
+       */
+      testName;
+      /**
+       * Path of the snapshot directory for this test
+       */
+      snapshotDir;
+      /**
+       * Path to the temporary output directory for this test
+       */
+      temporaryOutputDir;
+      /**
+       * The CLI command used to run this test.
+       * If it contains {filePath}, the test file names will be substituted at that place in the command for each run.
+       *
+       * @default - test run command will be `node {filePath}`
+       */
+      appCommand;
       /**
        * Whether this test matches the user-given name
        *