@aws-cdk/toolkit-lib 0.1.3 → 0.1.5

package/lib/api/aws-cdk.js

@@ -27,17 +27,18 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var __decorateClass = (decorators, target, key, kind) => {
-  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  var result2 = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
   for (var i = decorators.length - 1, decorator; i >= 0; i--)
     if (decorator = decorators[i])
-      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
-  if (kind && result) __defProp(target, key, result);
-  return result;
+      result2 = (kind ? decorator(target, key, result2) : decorator(result2)) || result2;
+  if (kind && result2) __defProp(target, key, result2);
+  return result2;
 };
 
 // lib/api/aws-cdk.ts
 var aws_cdk_exports = {};
 __export(aws_cdk_exports, {
+  Bootstrapper: () => Bootstrapper,
   CliIoHost: () => CliIoHost,
   CloudAssembly: () => CloudAssembly2,
   CloudWatchLogEventMonitor: () => CloudWatchLogEventMonitor,
@@ -57,21 +58,14 @@ __export(aws_cdk_exports, {
   WorkGraphBuilder: () => WorkGraphBuilder,
   contextproviders: () => context_providers_exports,
   findCloudWatchLogGroups: () => findCloudWatchLogGroups,
-  formatErrorMessage: () => formatErrorMessage,
-  formatSdkLoggerContent: () => formatSdkLoggerContent,
-  formatTime: () => formatTime,
   guessExecutable: () => guessExecutable,
   loadTree: () => loadTree,
-  obscureTemplate: () => obscureTemplate,
   prepareContext: () => prepareContext,
   prepareDefaultEnvironment: () => prepareDefaultEnvironment,
   sanitizePatterns: () => sanitizePatterns,
-  serializeStructure: () => serializeStructure,
   some: () => some,
   spaceAvailableForContext: () => spaceAvailableForContext,
-  splitBySize: () => splitBySize,
   tagsForStack: () => tagsForStack,
-  validateSnsTopicArn: () => validateSnsTopicArn,
   versionNumber: () => versionNumber
 });
 module.exports = __toCommonJS(aws_cdk_exports);
@@ -109,14 +103,15 @@ var chalk4 = __toESM(require("chalk"));
 
 // ../../aws-cdk/lib/toolkit/cli-io-host.ts
 var util3 = __toESM(require("node:util"));
+var import_cloud_assembly_schema = require("@aws-cdk/cloud-assembly-schema");
 var chalk3 = __toESM(require("chalk"));
 var promptly = __toESM(require("promptly"));
 
 // ../tmp-toolkit-helpers/src/api/toolkit-error.ts
-var TOOLKIT_ERROR_SYMBOL = Symbol.for("@aws-cdk/toolkit.ToolkitError");
-var AUTHENTICATION_ERROR_SYMBOL = Symbol.for("@aws-cdk/toolkit.AuthenticationError");
-var ASSEMBLY_ERROR_SYMBOL = Symbol.for("@aws-cdk/toolkit.AssemblyError");
-var CONTEXT_PROVIDER_ERROR_SYMBOL = Symbol.for("@aws-cdk/toolkit.ContextProviderError");
+var TOOLKIT_ERROR_SYMBOL = Symbol.for("@aws-cdk/toolkit-lib.ToolkitError");
+var AUTHENTICATION_ERROR_SYMBOL = Symbol.for("@aws-cdk/toolkit-lib.AuthenticationError");
+var ASSEMBLY_ERROR_SYMBOL = Symbol.for("@aws-cdk/toolkit-lib.AssemblyError");
+var CONTEXT_PROVIDER_ERROR_SYMBOL = Symbol.for("@aws-cdk/toolkit-lib.ContextProviderError");
 var ToolkitError = class _ToolkitError extends Error {
   /**
    * Determines if a given error is an instance of ToolkitError.
@@ -146,52 +141,97 @@ var ToolkitError = class _ToolkitError extends Error {
    * The type of the error, defaults to "toolkit".
    */
   type;
-  constructor(message, type = "toolkit") {
-    super(message);
+  /**
+   * Denotes the source of the error as the toolkit.
+   */
+  source;
+  constructor(message2, type = "toolkit") {
+    super(message2);
     Object.setPrototypeOf(this, _ToolkitError.prototype);
     Object.defineProperty(this, TOOLKIT_ERROR_SYMBOL, { value: true });
     this.name = new.target.name;
     this.type = type;
+    this.source = "toolkit";
   }
 };
 var AuthenticationError = class _AuthenticationError extends ToolkitError {
-  constructor(message) {
-    super(message, "authentication");
+  /**
+   * Denotes the source of the error as user.
+   */
+  source = "user";
+  constructor(message2) {
+    super(message2, "authentication");
     Object.setPrototypeOf(this, _AuthenticationError.prototype);
     Object.defineProperty(this, AUTHENTICATION_ERROR_SYMBOL, { value: true });
   }
 };
 var AssemblyError = class _AssemblyError extends ToolkitError {
-  constructor(message) {
-    super(message, "assembly");
+  /**
+   * An AssemblyError with an original error as cause
+   */
+  static withCause(message2, error4) {
+    return new _AssemblyError(message2, void 0, error4);
+  }
+  /**
+   * An AssemblyError with a list of stacks as cause
+   */
+  static withStacks(message2, stacks) {
+    return new _AssemblyError(message2, stacks);
+  }
+  /**
+   * Denotes the source of the error as user.
+   */
+  source = "user";
+  /**
+   * The stacks that caused the error, if available
+   *
+   * The `messages` property of each `cxapi.CloudFormationStackArtifact` will contain the respective errors.
+   * Absence indicates synthesis didn't fully complete.
+   */
+  stacks;
+  /**
+   * The specific original cause of the error, if available
+   */
+  cause;
+  constructor(message2, stacks, cause) {
+    super(message2, "assembly");
     Object.setPrototypeOf(this, _AssemblyError.prototype);
     Object.defineProperty(this, ASSEMBLY_ERROR_SYMBOL, { value: true });
+    this.stacks = stacks;
+    this.cause = cause;
   }
 };
 var ContextProviderError = class _ContextProviderError extends ToolkitError {
-  constructor(message) {
-    super(message, "context-provider");
+  /**
+   * Denotes the source of the error as user.
+   */
+  source = "user";
+  constructor(message2) {
+    super(message2, "context-provider");
     Object.setPrototypeOf(this, _ContextProviderError.prototype);
     Object.defineProperty(this, CONTEXT_PROVIDER_ERROR_SYMBOL, { value: true });
   }
 };
 
-// ../../aws-cdk/lib/util/archive.ts
+// ../tmp-toolkit-helpers/src/api/io/private/span.ts
+var uuid = __toESM(require("uuid"));
+
+// ../tmp-toolkit-helpers/src/util/archive.ts
 var glob = __toESM(require("glob"));
 
-// ../../aws-cdk/lib/util/format-error.ts
-function formatErrorMessage(error3) {
-  if (error3 && Array.isArray(error3.errors)) {
-    const innerMessages = error3.errors.map((innerError) => innerError?.message || innerError?.toString()).join("\n");
+// ../tmp-toolkit-helpers/src/util/format-error.ts
+function formatErrorMessage(error4) {
+  if (error4 && Array.isArray(error4.errors)) {
+    const innerMessages = error4.errors.map((innerError) => innerError?.message || innerError?.toString()).join("\n");
     return `AggregateError: ${innerMessages}`;
   }
-  return error3?.message || error3?.toString() || "Unknown error";
+  return error4?.message || error4?.toString() || "Unknown error";
 }
 
-// ../../aws-cdk/lib/util/archive.ts
+// ../tmp-toolkit-helpers/src/util/archive.ts
 var archiver = require("archiver");
 
-// ../../aws-cdk/lib/util/arrays.ts
+// ../tmp-toolkit-helpers/src/util/arrays.ts
 function flatMap(xs, fn) {
   return flatten(xs.map(fn));
 }
@@ -199,22 +239,7 @@ function flatten(xs) {
   return Array.prototype.concat.apply([], xs);
 }
 
-// ../../aws-cdk/lib/util/bytes.ts
-function formatBytes(bytes, decimals = 2) {
-  decimals = decimals < 0 ? 0 : decimals;
-  if (bytes === 0) {
-    return "0 Bytes";
-  }
-  const k = 1024;
-  const sizes = ["Bytes", "KiB", "MiB", "GiB", "TiB", "PiB", "EiB", "ZiB", "YiB"];
-  const i = Math.floor(Math.log(bytes) / Math.log(k));
-  return `${parseFloat((bytes / Math.pow(k, i)).toFixed(decimals))} ${sizes[i]}`;
-}
-
-// ../../aws-cdk/lib/util/cloudformation.ts
-function validateSnsTopicArn(arn) {
-  return /^arn:aws:sns:[a-z0-9\-]+:[0-9]+:[a-z0-9\-\_]+$/i.test(arn);
-}
+// ../tmp-toolkit-helpers/src/util/cloudformation.ts
 function stackEventHasErrorMessage(status) {
   return status.endsWith("_FAILED") || status === "ROLLBACK_IN_PROGRESS" || status === "UPDATE_ROLLBACK_IN_PROGRESS";
 }
@@ -230,7 +255,7 @@ function maxResourceTypeLength(template, startWidth = "AWS::CloudFormation::Stac
   return maxWidth;
 }
 
-// ../../aws-cdk/lib/util/content-hash.ts
+// ../tmp-toolkit-helpers/src/util/content-hash.ts
 var crypto = __toESM(require("crypto"));
 function contentHash(data) {
   return crypto.createHash("sha256").update(data).digest("hex");
@@ -267,13 +292,71 @@ function contentHashAny(value) {
   }
 }
 
-// ../../aws-cdk/lib/util/types.ts
+// ../tmp-toolkit-helpers/src/util/directories.ts
+var fs = __toESM(require("fs"));
+var os = __toESM(require("os"));
+var path = __toESM(require("path"));
+function cdkHomeDir() {
+  const tmpDir = fs.realpathSync(os.tmpdir());
+  let home;
+  try {
+    let userInfoHome = os.userInfo().homedir;
+    if (userInfoHome == "/var/empty") {
+      userInfoHome = void 0;
+    }
+    home = path.join((userInfoHome ?? os.homedir()).trim(), ".cdk");
+  } catch {
+  }
+  return process.env.CDK_HOME ? path.resolve(process.env.CDK_HOME) : home || fs.mkdtempSync(path.join(tmpDir, ".cdk")).trim();
+}
+function cdkCacheDir() {
+  return path.join(cdkHomeDir(), "cache");
+}
+function bundledPackageRootDir(start, fail) {
+  function _rootDir(dirname6) {
+    const manifestPath = path.join(dirname6, "package.json");
+    if (fs.existsSync(manifestPath)) {
+      return dirname6;
+    }
+    if (path.dirname(dirname6) === dirname6) {
+      if (fail ?? true) {
+        throw new ToolkitError("Unable to find package manifest");
+      }
+      return void 0;
+    }
+    return _rootDir(path.dirname(dirname6));
+  }
+  return _rootDir(start);
+}
+
+// ../tmp-toolkit-helpers/src/util/json.ts
+function getResultObj(jsonObject, identifier, propertiesToReturn) {
+  const propsObj = {};
+  propertiesToReturn.forEach((propName) => {
+    Object.assign(propsObj, { [propName]: findJsonValue(jsonObject, propName) });
+  });
+  Object.assign(propsObj, { ["Identifier"]: identifier });
+  return propsObj;
+}
+function findJsonValue(jsonObject, path15) {
+  const paths = path15.split(".");
+  let obj = jsonObject;
+  paths.forEach((p) => {
+    obj = obj[p];
+    if (obj === void 0) {
+      throw new TypeError(`Cannot read field ${path15}. ${p} is not found.`);
+    }
+  });
+  return obj;
+}
+
+// ../tmp-toolkit-helpers/src/util/types.ts
 function isObject(x) {
   return x !== null && typeof x === "object" && !isArray(x);
 }
 var isArray = Array.isArray;
 
-// ../../aws-cdk/lib/util/objects.ts
+// ../tmp-toolkit-helpers/src/util/objects.ts
 function deepClone(x) {
   if (typeof x === "undefined") {
     return void 0;
@@ -303,21 +386,21 @@ function makeObject(pairs) {
   }
   return ret;
 }
-function deepGet(x, path12) {
-  path12 = path12.slice();
-  while (path12.length > 0 && isObject(x)) {
-    const key = path12.shift();
+function deepGet(x, path15) {
+  path15 = path15.slice();
+  while (path15.length > 0 && isObject(x)) {
+    const key = path15.shift();
     x = x[key];
   }
-  return path12.length === 0 ? x : void 0;
+  return path15.length === 0 ? x : void 0;
 }
-function deepSet(x, path12, value) {
-  path12 = path12.slice();
-  if (path12.length === 0) {
+function deepSet(x, path15, value) {
+  path15 = path15.slice();
+  if (path15.length === 0) {
     throw new ToolkitError("Path may not be empty");
   }
-  while (path12.length > 1 && isObject(x)) {
-    const key = path12.shift();
+  while (path15.length > 1 && isObject(x)) {
+    const key = path15.shift();
     if (!(key in x)) {
       x[key] = {};
     }
@@ -327,9 +410,9 @@ function deepSet(x, path12, value) {
     throw new ToolkitError(`Expected an object, got '${x}'`);
   }
   if (value !== void 0) {
-    x[path12[0]] = value;
+    x[path15[0]] = value;
   } else {
-    delete x[path12[0]];
+    delete x[path15[0]];
   }
 }
 function deepMerge(...objects) {
@@ -357,48 +440,25 @@ function deepMerge(...objects) {
   others.forEach((other) => mergeOne(into, other));
   return into;
 }
-function splitBySize(data, maxSizeBytes) {
-  if (maxSizeBytes < 2) {
-    return [void 0, data];
-  }
-  const entries = Object.entries(data);
-  return recurse(0, 0);
-  function recurse(index, runningTotalSize) {
-    if (index >= entries.length) {
-      return [data, void 0];
-    }
-    const size = runningTotalSize + entrySize(entries[index]);
-    return size > maxSizeBytes ? cutAt(index) : recurse(index + 1, size);
-  }
-  function entrySize(entry) {
-    return Buffer.byteLength(JSON.stringify(Object.fromEntries([entry])));
-  }
-  function cutAt(index) {
-    return [
-      Object.fromEntries(entries.slice(0, index)),
-      Object.fromEntries(entries.slice(index))
-    ];
-  }
-}
 
-// ../../aws-cdk/lib/util/parallel.ts
+// ../tmp-toolkit-helpers/src/util/parallel.ts
 async function parallelPromises(n, promises) {
   const ret = new Array();
   let count = 0;
-  let error3;
+  let error4;
   const queue = [...promises];
   return new Promise((ok, ko) => {
     tick();
     function tick() {
-      if (count === 0 && error3) {
-        ko(error3);
+      if (count === 0 && error4) {
+        ko(error4);
         return;
       }
       if (count === 0 && queue.length === 0) {
         ok(ret);
         return;
       }
-      while (count < n && queue.length > 0 && !error3) {
+      while (count < n && queue.length > 0 && !error4) {
         const next = queue.shift();
         if (next !== void 0) {
           start(next);
@@ -407,10 +467,10 @@ async function parallelPromises(n, promises) {
     }
     function start(fn) {
       count += 1;
-      fn().then((result) => {
-        ret.push(result);
+      fn().then((result2) => {
+        ret.push(result2);
       }).catch((e) => {
-        error3 = e;
+        error4 = e;
       }).finally(() => {
         count -= 1;
         tick();
@@ -419,10 +479,10 @@ async function parallelPromises(n, promises) {
   });
 }
 
-// ../../aws-cdk/lib/util/serialize.ts
-var fs = __toESM(require("fs-extra"));
+// ../tmp-toolkit-helpers/src/util/serialize.ts
+var fs2 = __toESM(require("fs/promises"));
 
-// ../../aws-cdk/lib/util/yaml-cfn.ts
+// ../tmp-toolkit-helpers/src/util/yaml-cfn.ts
 var yaml = __toESM(require("yaml"));
 var yaml_types = __toESM(require("yaml/types"));
 function serialize(obj) {
@@ -479,7 +539,7 @@ function parseYamlStrWithCfnTags(text) {
   });
 }
 
-// ../../aws-cdk/lib/util/serialize.ts
+// ../tmp-toolkit-helpers/src/util/serialize.ts
 function toYAML(obj) {
   return serialize(obj);
 }
@@ -493,29 +553,12 @@ function serializeStructure(object, json) {
     return toYAML(object);
   }
 }
-function obscureTemplate(template = {}) {
-  if (template.Rules) {
-    if (template.Rules.CheckBootstrapVersion) {
-      if (Object.keys(template.Rules).length > 1) {
-        delete template.Rules.CheckBootstrapVersion;
-      } else {
-        delete template.Rules;
-      }
-    }
-  }
-  return template;
-}
-function isJsonBuffer(value) {
-  return typeof value === "object" && "type" in value && value.type === "Buffer" && "data" in value && Array.isArray(value.data);
-}
-function replacerBufferWithInfo(_key, value) {
-  if (isJsonBuffer(value)) {
-    return `<Buffer: ${formatBytes(value.data.length)}>`;
-  }
-  return value;
+async function loadStructuredFile(fileName) {
+  const contents = await fs2.readFile(fileName, { encoding: "utf-8" });
+  return deserializeStructure(contents);
 }
 
-// ../../aws-cdk/lib/util/string-manipulation.ts
+// ../tmp-toolkit-helpers/src/util/string-manipulation.ts
 function padLeft(n, x, char = " ") {
   return char.repeat(Math.max(0, n - x.length)) + x;
 }
@@ -532,9 +575,468 @@ function millisecondsToSeconds(num) {
   return num / 1e3;
 }
 
-// ../../aws-cdk/lib/util/version-range.ts
+// ../tmp-toolkit-helpers/src/util/version-range.ts
 var semver = __toESM(require("semver"));
 
+// ../tmp-toolkit-helpers/src/api/io/private/level-priority.ts
+var levels = [
+  "trace",
+  "debug",
+  "info",
+  "warn",
+  "result",
+  "error"
+];
+var orderedLevels = Object.fromEntries(Object.entries(levels).map((a) => a.reverse()));
+function compareFn(a, b) {
+  return orderedLevels[a] - orderedLevels[b];
+}
+function isMessageRelevantForLevel(msg, level) {
+  return compareFn(msg.level, level) >= 0;
+}
+
+// ../tmp-toolkit-helpers/src/api/io/private/message-maker.ts
+function message(level, details) {
+  const maker = (text, data) => ({
+    time: /* @__PURE__ */ new Date(),
+    level,
+    code: details.code,
+    message: text,
+    data
+  });
+  return {
+    ...details,
+    level,
+    msg: maker,
+    is: (m) => m.code === details.code
+  };
+}
+var trace = (details) => message("trace", details);
+var debug = (details) => message("debug", details);
+var info = (details) => message("info", details);
+var warn = (details) => message("warn", details);
+var error = (details) => message("error", details);
+var result = (details) => message("result", details);
+function request(level, details) {
+  const maker = (text, data) => ({
+    time: /* @__PURE__ */ new Date(),
+    level,
+    code: details.code,
+    message: text,
+    data,
+    defaultResponse: details.defaultResponse
+  });
+  return {
+    ...details,
+    level,
+    req: maker
+  };
+}
+var confirm = (details) => request("info", {
+  ...details,
+  defaultResponse: true
+});
+
+// ../tmp-toolkit-helpers/src/api/io/private/messages.ts
+var IO = {
+  // Defaults
+  DEFAULT_TOOLKIT_INFO: info({
+    code: "CDK_TOOLKIT_I0000",
+    description: "Default info messages emitted from the Toolkit"
+  }),
+  DEFAULT_TOOLKIT_DEBUG: debug({
+    code: "CDK_TOOLKIT_I0000",
+    description: "Default debug messages emitted from the Toolkit"
+  }),
+  DEFAULT_TOOLKIT_WARN: warn({
+    code: "CDK_TOOLKIT_W0000",
+    description: "Default warning messages emitted from the Toolkit"
+  }),
+  // 1: Synth
+  CDK_TOOLKIT_I1000: info({
+    code: "CDK_TOOLKIT_I1000",
+    description: "Provides synthesis times.",
+    interface: "Duration"
+  }),
+  CDK_TOOLKIT_I1001: trace({
+    code: "CDK_TOOLKIT_I1001",
+    description: "Cloud Assembly synthesis is starting",
+    interface: "StackSelectionDetails"
+  }),
+  CDK_TOOLKIT_I1901: result({
+    code: "CDK_TOOLKIT_I1901",
+    description: "Provides stack data",
+    interface: "StackAndAssemblyData"
+  }),
+  CDK_TOOLKIT_I1902: result({
+    code: "CDK_TOOLKIT_I1902",
+    description: "Successfully deployed stacks",
+    interface: "AssemblyData"
+  }),
+  // 2: List
+  CDK_TOOLKIT_I2901: result({
+    code: "CDK_TOOLKIT_I2901",
+    description: "Provides details on the selected stacks and their dependencies",
+    interface: "StackDetailsPayload"
+  }),
+  // 3: Import & Migrate
+  CDK_TOOLKIT_E3900: error({
+    code: "CDK_TOOLKIT_E3900",
+    description: "Resource import failed"
+  }),
+  // 4: Diff
+  // 5: Deploy & Watch
+  CDK_TOOLKIT_I5000: info({
+    code: "CDK_TOOLKIT_I5000",
+    description: "Provides deployment times",
+    interface: "Duration"
+  }),
+  CDK_TOOLKIT_I5001: info({
+    code: "CDK_TOOLKIT_I5001",
+    description: "Provides total time in deploy action, including synth and rollback",
+    interface: "Duration"
+  }),
+  CDK_TOOLKIT_I5002: info({
+    code: "CDK_TOOLKIT_I5002",
+    description: "Provides time for resource migration"
+  }),
+  CDK_TOOLKIT_W5021: warn({
+    code: "CDK_TOOLKIT_W5021",
+    description: "Empty non-existent stack, deployment is skipped"
+  }),
+  CDK_TOOLKIT_W5022: warn({
+    code: "CDK_TOOLKIT_W5022",
+    description: "Empty existing stack, stack will be destroyed"
+  }),
+  CDK_TOOLKIT_I5031: info({
+    code: "CDK_TOOLKIT_I5031",
+    description: "Informs about any log groups that are traced as part of the deployment"
+  }),
+  CDK_TOOLKIT_I5032: debug({
+    code: "CDK_TOOLKIT_I5032",
+    description: "Start monitoring log groups",
+    interface: "CloudWatchLogMonitorControlEvent"
+  }),
+  CDK_TOOLKIT_I5033: info({
+    code: "CDK_TOOLKIT_I5033",
+    description: "A log event received from Cloud Watch",
+    interface: "CloudWatchLogEvent"
+  }),
+  CDK_TOOLKIT_I5034: debug({
+    code: "CDK_TOOLKIT_I5034",
+    description: "Stop monitoring log groups",
+    interface: "CloudWatchLogMonitorControlEvent"
+  }),
+  CDK_TOOLKIT_E5035: error({
+    code: "CDK_TOOLKIT_E5035",
+    description: "A log monitoring error",
+    interface: "ErrorPayload"
+  }),
+  CDK_TOOLKIT_I5050: confirm({
+    code: "CDK_TOOLKIT_I5050",
+    description: "Confirm rollback during deployment",
+    interface: "ConfirmationRequest"
+  }),
+  CDK_TOOLKIT_I5060: confirm({
+    code: "CDK_TOOLKIT_I5060",
+    description: "Confirm deploy security sensitive changes",
+    interface: "DeployConfirmationRequest"
+  }),
+  CDK_TOOLKIT_I5100: info({
+    code: "CDK_TOOLKIT_I5100",
+    description: "Stack deploy progress",
+    interface: "StackDeployProgress"
+  }),
+  // Assets
+  CDK_TOOLKIT_I5210: trace({
+    code: "CDK_TOOLKIT_I5210",
+    description: "Started building a specific asset",
+    interface: "BuildAsset"
+  }),
+  CDK_TOOLKIT_I5211: trace({
+    code: "CDK_TOOLKIT_I5211",
+    description: "Building the asset has completed",
+    interface: "Duration"
+  }),
+  CDK_TOOLKIT_I5220: trace({
+    code: "CDK_TOOLKIT_I5220",
+    description: "Started publishing a specific asset",
+    interface: "PublishAsset"
+  }),
+  CDK_TOOLKIT_I5221: trace({
+    code: "CDK_TOOLKIT_I5221",
+    description: "Publishing the asset has completed",
+    interface: "Duration"
+  }),
+  // Watch
+  CDK_TOOLKIT_I5310: debug({
+    code: "CDK_TOOLKIT_I5310",
+    description: "The computed settings used for file watching",
+    interface: "WatchSettings"
+  }),
+  CDK_TOOLKIT_I5311: info({
+    code: "CDK_TOOLKIT_I5311",
+    description: "File watching started",
+    interface: "FileWatchEvent"
+  }),
+  CDK_TOOLKIT_I5312: info({
+    code: "CDK_TOOLKIT_I5312",
+    description: "File event detected, starting deployment",
+    interface: "FileWatchEvent"
+  }),
+  CDK_TOOLKIT_I5313: info({
+    code: "CDK_TOOLKIT_I5313",
+    description: "File event detected during active deployment, changes are queued",
+    interface: "FileWatchEvent"
+  }),
+  CDK_TOOLKIT_I5314: info({
+    code: "CDK_TOOLKIT_I5314",
+    description: "Initial watch deployment started"
+  }),
+  CDK_TOOLKIT_I5315: info({
+    code: "CDK_TOOLKIT_I5315",
+    description: "Queued watch deployment started"
+  }),
+  // Stack Monitor
+  CDK_TOOLKIT_I5501: info({
+    code: "CDK_TOOLKIT_I5501",
+    description: "Stack Monitoring: Start monitoring of a single stack",
+    interface: "StackMonitoringControlEvent"
+  }),
+  CDK_TOOLKIT_I5502: info({
+    code: "CDK_TOOLKIT_I5502",
+    description: "Stack Monitoring: Activity event for a single stack",
+    interface: "StackActivity"
+  }),
+  CDK_TOOLKIT_I5503: info({
+    code: "CDK_TOOLKIT_I5503",
+    description: "Stack Monitoring: Finished monitoring of a single stack",
+    interface: "StackMonitoringControlEvent"
+  }),
+  // Success
+  CDK_TOOLKIT_I5900: result({
+    code: "CDK_TOOLKIT_I5900",
+    description: "Deployment results on success",
+    interface: "SuccessfulDeployStackResult"
+  }),
+  CDK_TOOLKIT_I5901: info({
+    code: "CDK_TOOLKIT_I5901",
+    description: "Generic deployment success messages"
+  }),
+  CDK_TOOLKIT_W5400: warn({
+    code: "CDK_TOOLKIT_W5400",
+    description: "Hotswap disclosure message"
+  }),
+  // errors
+  CDK_TOOLKIT_E5001: error({
+    code: "CDK_TOOLKIT_E5001",
+    description: "No stacks found"
+  }),
+  CDK_TOOLKIT_E5500: error({
+    code: "CDK_TOOLKIT_E5500",
+    description: "Stack Monitoring error",
+    interface: "ErrorPayload"
+  }),
+  // 6: Rollback
+  CDK_TOOLKIT_I6000: info({
+    code: "CDK_TOOLKIT_I6000",
+    description: "Provides rollback times",
+    interface: "Duration"
+  }),
+  CDK_TOOLKIT_I6100: info({
+    code: "CDK_TOOLKIT_I6100",
+    description: "Stack rollback progress",
+    interface: "StackRollbackProgress"
+  }),
+  CDK_TOOLKIT_E6001: error({
+    code: "CDK_TOOLKIT_E6001",
+    description: "No stacks found"
+  }),
+  CDK_TOOLKIT_E6900: error({
+    code: "CDK_TOOLKIT_E6900",
+    description: "Rollback failed",
+    interface: "ErrorPayload"
+  }),
+  // 7: Destroy
+  CDK_TOOLKIT_I7000: info({
+    code: "CDK_TOOLKIT_I7000",
+    description: "Provides destroy times",
+    interface: "Duration"
+  }),
+  CDK_TOOLKIT_I7001: trace({
+    code: "CDK_TOOLKIT_I7001",
+    description: "Provides destroy time for a single stack",
+    interface: "Duration"
+  }),
+  CDK_TOOLKIT_I7010: confirm({
+    code: "CDK_TOOLKIT_I7010",
+    description: "Confirm destroy stacks",
+    interface: "ConfirmationRequest"
+  }),
+  CDK_TOOLKIT_I7100: info({
+    code: "CDK_TOOLKIT_I7100",
+    description: "Stack destroy progress",
+    interface: "StackDestroyProgress"
+  }),
+  CDK_TOOLKIT_I7101: trace({
+    code: "CDK_TOOLKIT_I7101",
+    description: "Start stack destroying",
+    interface: "StackDestroy"
+  }),
+  CDK_TOOLKIT_I7900: result({
+    code: "CDK_TOOLKIT_I7900",
+    description: "Stack deletion succeeded",
+    interface: "cxapi.CloudFormationStackArtifact"
+  }),
+  CDK_TOOLKIT_E7010: error({
+    code: "CDK_TOOLKIT_E7010",
+    description: "Action was aborted due to negative confirmation of request"
+  }),
+  CDK_TOOLKIT_E7900: error({
+    code: "CDK_TOOLKIT_E7900",
+    description: "Stack deletion failed",
+    interface: "ErrorPayload"
+  }),
+  // 9: Bootstrap
+  CDK_TOOLKIT_I9000: info({
+    code: "CDK_TOOLKIT_I9000",
+    description: "Provides bootstrap times",
+    interface: "Duration"
+  }),
+  CDK_TOOLKIT_I9100: info({
+    code: "CDK_TOOLKIT_I9100",
+    description: "Bootstrap progress",
+    interface: "BootstrapEnvironmentProgress"
+  }),
+  CDK_TOOLKIT_I9900: result({
+    code: "CDK_TOOLKIT_I9900",
+    description: "Bootstrap results on success",
+    interface: "cxapi.Environment"
+  }),
+  CDK_TOOLKIT_E9900: error({
+    code: "CDK_TOOLKIT_E9900",
+    description: "Bootstrap failed",
+    interface: "ErrorPayload"
+  }),
+  // Assembly codes
+  CDK_ASSEMBLY_I0010: debug({
+    code: "CDK_ASSEMBLY_I0010",
+    description: "Generic environment preparation debug messages"
+  }),
+  CDK_ASSEMBLY_W0010: warn({
+    code: "CDK_ASSEMBLY_W0010",
+    description: "Emitted if the found framework version does not support context overflow"
+  }),
+  CDK_ASSEMBLY_I0042: debug({
+    code: "CDK_ASSEMBLY_I0042",
+    description: "Writing updated context",
+    interface: "UpdatedContext"
+  }),
+  CDK_ASSEMBLY_I0240: debug({
+    code: "CDK_ASSEMBLY_I0240",
+    description: "Context lookup was stopped as no further progress was made. ",
+    interface: "MissingContext"
+  }),
+  CDK_ASSEMBLY_I0241: debug({
+    code: "CDK_ASSEMBLY_I0241",
+    description: "Fetching missing context. This is an iterative message that may appear multiple times with different missing keys.",
+    interface: "MissingContext"
+  }),
+  CDK_ASSEMBLY_I1000: debug({
+    code: "CDK_ASSEMBLY_I1000",
+    description: "Cloud assembly output starts"
+  }),
+  CDK_ASSEMBLY_I1001: info({
+    code: "CDK_ASSEMBLY_I1001",
+    description: "Output lines emitted by the cloud assembly to stdout"
+  }),
+  CDK_ASSEMBLY_E1002: error({
+    code: "CDK_ASSEMBLY_E1002",
+    description: "Output lines emitted by the cloud assembly to stderr"
+  }),
+  CDK_ASSEMBLY_I1003: info({
+    code: "CDK_ASSEMBLY_I1003",
+    description: "Cloud assembly output finished"
+  }),
+  CDK_ASSEMBLY_E1111: error({
+    code: "CDK_ASSEMBLY_E1111",
+    description: "Incompatible CDK CLI version. Upgrade needed.",
+    interface: "ErrorPayload"
+  }),
+  CDK_ASSEMBLY_I0150: debug({
+    code: "CDK_ASSEMBLY_I0150",
+    description: "Indicates the use of a pre-synthesized cloud assembly directory"
+  }),
+  // Assembly Annotations
+  CDK_ASSEMBLY_I9999: info({
+    code: "CDK_ASSEMBLY_I9999",
+    description: "Annotations emitted by the cloud assembly",
+    interface: "cxapi.SynthesisMessage"
+  }),
+  CDK_ASSEMBLY_W9999: warn({
+    code: "CDK_ASSEMBLY_W9999",
+    description: "Warnings emitted by the cloud assembly",
+    interface: "cxapi.SynthesisMessage"
+  }),
+  CDK_ASSEMBLY_E9999: error({
+    code: "CDK_ASSEMBLY_E9999",
+    description: "Errors emitted by the cloud assembly",
+    interface: "cxapi.SynthesisMessage"
+  }),
+  // SDK codes
+  CDK_SDK_I0000: trace({
+    code: "CDK_SDK_I0000",
+    description: "An SDK message."
+  }),
+  CDK_SDK_I0100: trace({
+    code: "CDK_SDK_I0100",
+    description: "An SDK trace. SDK traces are emitted as traces to the IoHost, but contain the original SDK logging level.",
+    interface: "SdkTrace"
+  })
+};
+var SPAN = {
+  SYNTH_ASSEMBLY: {
+    name: "Synthesis",
+    start: IO.CDK_TOOLKIT_I1001,
+    end: IO.CDK_TOOLKIT_I1000
+  },
+  DEPLOY_STACK: {
+    name: "Deployment",
+    start: IO.CDK_TOOLKIT_I5100,
+    end: IO.CDK_TOOLKIT_I5001
+  },
+  ROLLBACK_STACK: {
+    name: "Rollback",
+    start: IO.CDK_TOOLKIT_I6100,
+    end: IO.CDK_TOOLKIT_I6000
+  },
+  DESTROY_STACK: {
+    name: "Destroy",
+    start: IO.CDK_TOOLKIT_I7100,
+    end: IO.CDK_TOOLKIT_I7001
+  },
+  DESTROY_ACTION: {
+    name: "Destroy",
+    start: IO.CDK_TOOLKIT_I7101,
+    end: IO.CDK_TOOLKIT_I7000
+  },
+  BOOTSTRAP_SINGLE: {
+    name: "Bootstrap",
+    start: IO.CDK_TOOLKIT_I9100,
+    end: IO.CDK_TOOLKIT_I9000
+  },
+  BUILD_ASSET: {
+    name: "Build Asset",
+    start: IO.CDK_TOOLKIT_I5210,
+    end: IO.CDK_TOOLKIT_I5211
+  },
+  PUBLISH_ASSET: {
+    name: "Publish Asset",
+    start: IO.CDK_TOOLKIT_I5220,
+    end: IO.CDK_TOOLKIT_I5221
+  }
+};
+
 // ../../aws-cdk/lib/cli/activity-printer/base.ts
 var ActivityPrinterBase = class {
   constructor(props) {
@@ -562,14 +1064,14 @@ var ActivityPrinterBase = class {
    * Receive a stack activity message
    */
   notify(msg) {
-    switch (msg.code) {
-      case "CDK_TOOLKIT_I5501":
+    switch (true) {
+      case IO.CDK_TOOLKIT_I5501.is(msg):
         this.start(msg.data);
         break;
-      case "CDK_TOOLKIT_I5502":
+      case IO.CDK_TOOLKIT_I5502.is(msg):
         this.activity(msg.data);
         break;
-      case "CDK_TOOLKIT_I5503":
+      case IO.CDK_TOOLKIT_I5503.is(msg):
         this.stop();
         break;
       default:
@@ -865,9 +1367,9 @@ var CurrentActivityPrinter = class _CurrentActivityPrinter extends ActivityPrint
           this.failureReasonOnNextLine(failure)
         )
       );
-      const trace3 = failure.metadata?.entry?.trace;
-      if (trace3) {
-        lines.push(chalk2.red(`	${trace3.join("\n	\\_ ")}
+      const trace4 = failure.metadata?.entry?.trace;
+      if (trace4) {
+        lines.push(chalk2.red(`	${trace4.join("\n	\\_ ")}
 `));
       }
     }
@@ -925,24 +1427,17 @@ function shorten(maxWidth, p) {
 }
 
 // ../../aws-cdk/lib/toolkit/cli-io-host.ts
-var levelPriority = {
-  error: 0,
-  result: 1,
-  warn: 2,
-  info: 3,
-  debug: 4,
-  trace: 5
-};
 var CliIoHost = class _CliIoHost {
   constructor(props = {}) {
     this._progress = "bar" /* BAR */;
     // Corked Logging
     this.corkedCounter = 0;
     this.corkedLoggingBuffer = [];
-    this._currentAction = props.currentAction ?? "none";
-    this._isTTY = props.isTTY ?? process.stdout.isTTY ?? false;
-    this._logLevel = props.logLevel ?? "info";
-    this._isCI = props.isCI ?? isCI();
+    this.currentAction = props.currentAction ?? "none";
+    this.isTTY = props.isTTY ?? process.stdout.isTTY ?? false;
+    this.logLevel = props.logLevel ?? "info";
+    this.isCI = props.isCI ?? isCI();
+    this.requireDeployApproval = props.requireDeployApproval ?? import_cloud_assembly_schema.RequireApproval.BROADENING;
     this.stackProgress = props.stackProgress ?? "bar" /* BAR */;
   }
   /**
@@ -978,7 +1473,7 @@ var CliIoHost = class _CliIoHost {
     if (this._progress === "events" /* EVENTS */) {
       return this._progress;
     }
-    const verboseLogging = levelPriority[this.logLevel] > levelPriority.info;
+    const verboseLogging = isMessageRelevantForLevel({ level: "debug" }, this.logLevel);
     if (verboseLogging) {
       return "events" /* EVENTS */;
     }
@@ -992,60 +1487,6 @@ var CliIoHost = class _CliIoHost {
     }
     return this._progress;
   }
-  /**
-   * The current action being performed by the CLI.
-   */
-  get currentAction() {
-    return this._currentAction;
-  }
-  /**
-   * Sets the current action being performed by the CLI.
-   *
-   * @param action The action being performed by the CLI.
-   */
-  set currentAction(action) {
-    this._currentAction = action;
-  }
-  /**
-   * Whether the host can use interactions and message styling.
-   */
-  get isTTY() {
-    return this._isTTY;
-  }
-  /**
-   * Set TTY mode, i.e can the host use interactions and message styling.
-   *
-   * @param value set TTY mode
-   */
-  set isTTY(value) {
-    this._isTTY = value;
-  }
-  /**
-   * Whether the CliIoHost is running in CI mode. In CI mode, all non-error output goes to stdout instead of stderr.
-   */
-  get isCI() {
-    return this._isCI;
-  }
-  /**
-   * Set the CI mode. In CI mode, all non-error output goes to stdout instead of stderr.
-   * @param value set the CI mode
-   */
-  set isCI(value) {
-    this._isCI = value;
-  }
-  /**
-   * The current threshold. Messages with a lower priority level will be ignored.
-   */
-  get logLevel() {
-    return this._logLevel;
-  }
-  /**
-   * Sets the current threshold. Messages with a lower priority level will be ignored.
-   * @param level The new log level threshold
-   */
-  set logLevel(level) {
-    this._logLevel = level;
-  }
   /**
    * Executes a block of code with corked logging. All log messages during execution
    * are buffered and only written when all nested cork blocks complete (when CORK_COUNTER reaches 0).
@@ -1083,7 +1524,7 @@ var CliIoHost = class _CliIoHost {
       await this.activityPrinter.notify(msg);
       return;
     }
-    if (levelPriority[msg.level] > levelPriority[this.logLevel]) {
+    if (!isMessageRelevantForLevel(msg, this.logLevel)) {
       return;
     }
     if (this.corkedCounter > 0) {
@@ -1104,6 +1545,27 @@ var CliIoHost = class _CliIoHost {
       "CDK_TOOLKIT_I5503"
     ].includes(msg.code);
   }
+  /**
+   * Detect special messages encode information about whether or not
+   * they require approval
+   */
+  skipApprovalStep(msg) {
+    const approvalToolkitCodes = ["CDK_TOOLKIT_I5060"];
+    if (!approvalToolkitCodes.includes(msg.code)) {
+      false;
+    }
+    switch (this.requireDeployApproval) {
+      // Never require approval
+      case import_cloud_assembly_schema.RequireApproval.NEVER:
+        return true;
+      // Always require approval
+      case import_cloud_assembly_schema.RequireApproval.ANYCHANGE:
+        return false;
+      // Require approval if changes include broadening permissions
+      case import_cloud_assembly_schema.RequireApproval.BROADENING:
+        return ["none", "non-broadening"].includes(msg.data?.permissionChangeType);
+    }
+  }
   /**
    * Determines the output stream, based on message level and configuration.
    */
@@ -1141,6 +1603,9 @@ var CliIoHost = class _CliIoHost {
       if (concurrency > 1) {
         throw new ToolkitError(`${motivation}, but concurrency is greater than 1 so we are unable to get a confirmation from the user`);
       }
+      if (this.skipApprovalStep(msg)) {
+        return true;
+      }
       if (isConfirmationPrompt(msg)) {
         const confirmed = await promptly.confirm(`${chalk3.cyan(msg.message)} (y/n)`);
         if (!confirmed) {
@@ -1160,7 +1625,7 @@ var CliIoHost = class _CliIoHost {
    * Formats a message for console output with optional color support
    */
   formatMessage(msg) {
-    let message_text = this._isTTY ? styleMap[msg.level](msg.message) : msg.message;
+    let message_text = this.isTTY ? styleMap[msg.level](msg.message) : msg.message;
     return (msg.level === "debug" || msg.level === "trace" ? `[${this.formatTime(msg.time)}] ${message_text}` : message_text) + "\n";
   }
   /**
@@ -1212,8 +1677,8 @@ function isCI() {
 
 // ../../aws-cdk/lib/logging.ts
 function formatMessageAndLog(level, input, style, ...args) {
-  const { message, code = getDefaultCode(level) } = typeof input === "object" ? input : { message: input };
-  const formattedMessage = args.length > 0 ? util4.format(message, ...args) : message;
+  const { message: message2, code = getDefaultCode(level) } = typeof input === "object" ? input : { message: input };
+  const formattedMessage = args.length > 0 ? util4.format(message2, ...args) : message2;
   const finalMessage = style ? style(formattedMessage) : formattedMessage;
   const ioHost = CliIoHost.instance();
   const ioMessage = {
@@ -1221,7 +1686,8 @@ function formatMessageAndLog(level, input, style, ...args) {
     action: ioHost.currentAction,
     level,
     message: finalMessage,
-    code
+    code,
+    data: void 0
   };
   void ioHost.notify(ioMessage);
 }
@@ -1229,59 +1695,22 @@ function getDefaultCode(level, category = "TOOLKIT") {
   const levelIndicator = level === "error" ? "E" : level === "warn" ? "W" : "I";
   return `CDK_${category}_${levelIndicator}0000`;
 }
-var error = (input, ...args) => {
+var error2 = (input, ...args) => {
   return formatMessageAndLog("error", input, void 0, ...args);
 };
 var warning = (input, ...args) => {
   return formatMessageAndLog("warn", input, void 0, ...args);
 };
-var info = (input, ...args) => {
+var info2 = (input, ...args) => {
   return formatMessageAndLog("info", input, void 0, ...args);
 };
-var debug = (input, ...args) => {
+var debug2 = (input, ...args) => {
   return formatMessageAndLog("debug", input, void 0, ...args);
 };
-var trace = (input, ...args) => {
+var trace2 = (input, ...args) => {
   return formatMessageAndLog("trace", input, void 0, ...args);
 };
 
-// ../../aws-cdk/lib/util/directories.ts
-var fs2 = __toESM(require("fs"));
-var os = __toESM(require("os"));
-var path = __toESM(require("path"));
-function cdkHomeDir() {
-  const tmpDir = fs2.realpathSync(os.tmpdir());
-  let home;
-  try {
-    let userInfoHome = os.userInfo().homedir;
-    if (userInfoHome == "/var/empty") {
-      userInfoHome = void 0;
-    }
-    home = path.join((userInfoHome ?? os.homedir()).trim(), ".cdk");
-  } catch {
-  }
-  return process.env.CDK_HOME ? path.resolve(process.env.CDK_HOME) : home || fs2.mkdtempSync(path.join(tmpDir, ".cdk")).trim();
-}
-function cdkCacheDir() {
-  return path.join(cdkHomeDir(), "cache");
-}
-function rootDir(fail) {
-  function _rootDir(dirname5) {
-    const manifestPath = path.join(dirname5, "package.json");
-    if (fs2.existsSync(manifestPath)) {
-      return dirname5;
-    }
-    if (path.dirname(dirname5) === dirname5) {
-      if (fail ?? true) {
-        throw new ToolkitError("Unable to find package manifest");
-      }
-      return void 0;
-    }
-    return _rootDir(path.dirname(dirname5));
-  }
-  return _rootDir(__dirname);
-}
-
 // ../../aws-cdk/lib/api/aws-auth/account-cache.ts
 var AccountAccessKeyCache = class _AccountAccessKeyCache {
   static {
@@ -1310,7 +1739,7 @@ var AccountAccessKeyCache = class _AccountAccessKeyCache {
   async fetch(accessKeyId, resolver) {
     const cached2 = await this.get(accessKeyId);
     if (cached2) {
-      debug(`Retrieved account ID ${cached2.accountId} from disk cache`);
+      debug2(`Retrieved account ID ${cached2.accountId} from disk cache`);
       return cached2;
     }
     const account = await resolver();
@@ -1426,14 +1855,14 @@ function readIfPossible(filename) {
     }
     return fs4.readFileSync(filename, { encoding: "utf-8" });
   } catch (e) {
-    debug(e);
+    debug2(e);
     return void 0;
   }
 }
 
 // ../../aws-cdk/lib/api/aws-auth/user-agent.ts
 function defaultCliUserAgent() {
-  const root = rootDir(false);
+  const root = bundledPackageRootDir(__dirname, false);
   const pkg = JSON.parse((root ? readIfPossible(path3.join(root, "package.json")) : void 0) ?? "{}");
   const name = pkg.name ?? path3.basename(process.argv[1] ?? "cdk-cli");
   const version = pkg.version ?? "<unknown>";
@@ -1739,19 +2168,19 @@ var SDK = class {
     return cachedAsync(this, CURRENT_ACCOUNT_KEY, async () => {
       const creds = await this.credProvider();
       return SDK.accountCache.fetch(creds.accessKeyId, async () => {
-        debug("Looking up default account ID from STS");
+        debug2("Looking up default account ID from STS");
         const client = new import_client_sts.STSClient({
           ...this.config,
           retryStrategy: this.stsRetryStrategy
         });
         const command = new import_client_sts.GetCallerIdentityCommand({});
-        const result = await client.send(command);
-        const accountId = result.Account;
-        const partition = result.Arn.split(":")[1];
+        const result2 = await client.send(command);
+        const accountId = result2.Account;
+        const partition = result2.Arn.split(":")[1];
         if (!accountId) {
           throw new AuthenticationError("STS didn't return an account ID");
         }
-        debug("Default account ID:", accountId);
+        debug2("Default account ID:", accountId);
         this._credentialsValidated = true;
         return { accountId, partition };
       });
@@ -1876,7 +2305,7 @@ var AwsCliCompatible = class _AwsCliCompatible {
     const region = process.env.AWS_REGION || process.env.AMAZON_REGION || process.env.AWS_DEFAULT_REGION || process.env.AMAZON_DEFAULT_REGION || await getRegionFromIni(profile) || await regionFromMetadataService();
     if (!region) {
       const usedProfile = !profile ? "" : ` (profile: "${profile}")`;
-      debug(
+      debug2(
         `Unable to determine AWS region from environment or AWS configuration${usedProfile}, defaulting to '${defaultRegion}'`
       );
       return defaultRegion;
@@ -1892,10 +2321,10 @@ function getRegionFromIniFile(profile, data) {
   return data?.[profile]?.region;
 }
 function tryGetCACert(bundlePath) {
-  const path12 = bundlePath || caBundlePathFromEnvironment();
-  if (path12) {
-    debug("Using CA bundle path: %s", path12);
-    return readIfPossible(path12);
+  const path15 = bundlePath || caBundlePathFromEnvironment();
+  if (path15) {
+    debug2("Using CA bundle path: %s", path15);
+    return readIfPossible(path15);
   }
   return void 0;
 }
@@ -1923,7 +2352,7 @@ function shouldPrioritizeEnv() {
   return false;
 }
 async function regionFromMetadataService() {
-  debug("Looking up AWS region in the EC2 Instance Metadata Service (IMDS).");
+  debug2("Looking up AWS region in the EC2 Instance Metadata Service (IMDS).");
   try {
     const metadataService = new import_ec2_metadata_service.MetadataService({
       httpOptions: {
@@ -1934,20 +2363,20 @@ async function regionFromMetadataService() {
     const document = await metadataService.request("/latest/dynamic/instance-identity/document", {});
     return JSON.parse(document).region;
   } catch (e) {
-    debug(`Unable to retrieve AWS region from IMDS: ${e}`);
+    debug2(`Unable to retrieve AWS region from IMDS: ${e}`);
   }
 }
 async function tokenCodeFn(serialArn) {
-  debug("Require MFA token for serial ARN", serialArn);
+  debug2("Require MFA token for serial ARN", serialArn);
   try {
     const token = await promptly2.prompt(`MFA token for ${serialArn}: `, {
       trim: true,
       default: ""
     });
-    debug("Successfully got MFA token from user");
+    debug2("Successfully got MFA token from user");
     return token;
   } catch (err) {
-    debug("Failed to get MFA token", err);
+    debug2("Failed to get MFA token", err);
     const e = new AuthenticationError(`Error fetching MFA token: ${err.message ?? err}`);
     e.name = "SharedIniFileCredentialsProviderFailure";
     throw e;
@@ -1955,10 +2384,10 @@ async function tokenCodeFn(serialArn) {
 }
 
 // ../../aws-cdk/lib/api/aws-auth/credential-plugins.ts
-var import_util7 = require("util");
+var import_util11 = require("util");
 
 // ../../aws-cdk/lib/api/plugin/plugin.ts
-var import_util6 = require("util");
+var import_util10 = require("util");
 var chalk5 = __toESM(require("chalk"));
 
 // ../../aws-cdk/lib/api/plugin/context-provider-plugin.ts
@@ -1992,14 +2421,14 @@ var PluginHost = class _PluginHost {
     try {
       const plugin = require(moduleSpec);
       if (!isPlugin(plugin)) {
-        error(`Module ${chalk5.green(moduleSpec)} is not a valid plug-in, or has an unsupported version.`);
+        error2(`Module ${chalk5.green(moduleSpec)} is not a valid plug-in, or has an unsupported version.`);
         throw new ToolkitError(`Module ${moduleSpec} does not define a valid plug-in.`);
       }
       if (plugin.init) {
         plugin.init(this);
       }
     } catch (e) {
-      error(`Unable to load ${chalk5.green(moduleSpec)}: ${e.stack}`);
+      error2(`Unable to load ${chalk5.green(moduleSpec)}: ${e.stack}`);
       throw new ToolkitError(`Unable to load plug-in: ${moduleSpec}: ${e}`);
     }
     function isPlugin(x) {
@@ -2048,7 +2477,7 @@ var PluginHost = class _PluginHost {
    */
   registerContextProviderAlpha(pluginProviderName, provider) {
     if (!isContextProviderPlugin(provider)) {
-      throw new ToolkitError(`Object you gave me does not look like a ContextProviderPlugin: ${(0, import_util6.inspect)(provider)}`);
+      throw new ToolkitError(`Object you gave me does not look like a ContextProviderPlugin: ${(0, import_util10.inspect)(provider)}`);
     }
     this.contextProviderPlugins[pluginProviderName] = provider;
   }
@@ -2081,7 +2510,7 @@ var CredentialPlugins = class {
         available = false;
       }
       if (!available) {
-        debug("Credentials source %s is not available, ignoring it.", source.name);
+        debug2("Credentials source %s is not available, ignoring it.", source.name);
         continue;
       }
       triedSources.push(source);
@@ -2095,7 +2524,7 @@ var CredentialPlugins = class {
       if (!canProvide) {
         continue;
       }
-      debug(`Using ${source.name} credentials for account ${awsAccountId}`);
+      debug2(`Using ${source.name} credentials for account ${awsAccountId}`);
       return {
         credentials: await v3ProviderFromPlugin(() => source.getProvider(awsAccountId, mode, {
           supportsV3Providers: true
@@ -2117,7 +2546,7 @@ async function v3ProviderFromPlugin(producer) {
   } else if (isV2Credentials(initial)) {
     return v3ProviderFromV2Credentials(initial);
   } else {
-    throw new AuthenticationError(`Plugin returned a value that doesn't resemble AWS credentials: ${(0, import_util7.inspect)(initial)}`);
+    throw new AuthenticationError(`Plugin returned a value that doesn't resemble AWS credentials: ${(0, import_util11.inspect)(initial)}`);
   }
 }
 function v3ProviderFromV2Credentials(x) {
@@ -2136,7 +2565,7 @@ function refreshFromPluginProvider(current, producer) {
     if (credentialsAboutToExpire(current)) {
       const newCreds = await producer();
       if (!isV3Credentials(newCreds)) {
-        throw new AuthenticationError(`Plugin initially returned static V3 credentials but now returned something else: ${(0, import_util7.inspect)(newCreds)}`);
+        throw new AuthenticationError(`Plugin initially returned static V3 credentials but now returned something else: ${(0, import_util11.inspect)(newCreds)}`);
       }
       current = newCreds;
     }
@@ -2213,8 +2642,8 @@ var SdkProvider = class {
         throw err;
       }
       if (baseCreds.source === "correctDefault" || baseCreds.source === "plugin") {
-        debug(err.message);
-        const logger = quiet ? debug : warning;
+        debug2(err.message);
+        const logger = quiet ? debug2 : warning;
         logger(
           `${fmtObtainedCredentials(baseCreds)} could not be used to assume '${options.assumeRoleArn}', but are for the right account. Proceeding anyway.`
         );
@@ -2287,7 +2716,7 @@ var SdkProvider = class {
           );
           return void 0;
         }
-        debug(`Unable to determine the default AWS account (${e.name}): ${formatErrorMessage(e)}`);
+        debug2(`Unable to determine the default AWS account (${e.name}): ${formatErrorMessage(e)}`);
         return void 0;
       }
     });
@@ -2334,7 +2763,7 @@ var SdkProvider = class {
    * otherwise it will be the current credentials.
    */
   async withAssumedRole(mainCredentials, roleArn, externalId, additionalOptions, region) {
-    debug(`Assuming role '${roleArn}'.`);
+    debug2(`Assuming role '${roleArn}'.`);
     region = region ?? this.defaultRegion;
     const sourceDescription = fmtObtainedCredentials(mainCredentials);
     try {
@@ -2361,7 +2790,7 @@ var SdkProvider = class {
       if (err.name === "ExpiredToken") {
         throw err;
       }
-      debug(`Assuming role failed: ${err.message}`);
+      debug2(`Assuming role failed: ${err.message}`);
       throw new AuthenticationError(
         [
           "Could not assume role in target account",
@@ -2424,42 +2853,6 @@ async function initContextProviderSdk(aws, options) {
   return (await aws.forEnvironment(import_cx_api.EnvironmentUtils.make(account, region), 0 /* ForReading */, creds)).sdk;
 }
 
-// ../../aws-cdk/lib/api/aws-auth/sdk-logger.ts
-var import_util8 = require("util");
-function formatSdkLoggerContent(content) {
-  if (content.length === 1) {
-    const apiFmt = formatApiCall(content[0]);
-    if (apiFmt) {
-      return apiFmt;
-    }
-  }
-  return content.map((x) => typeof x === "string" ? x : (0, import_util8.inspect)(x)).join("");
-}
-function formatApiCall(content) {
-  if (!isSdkApiCallSuccess(content) && !isSdkApiCallError(content)) {
-    return void 0;
-  }
-  const service = content.clientName.replace(/Client$/, "");
-  const api = content.commandName.replace(/Command$/, "");
-  const parts = [];
-  if ((content.metadata?.attempts ?? 0) > 1) {
-    parts.push(`[${content.metadata?.attempts} attempts, ${content.metadata?.totalRetryDelay}ms retry]`);
-  }
-  parts.push(`${service}.${api}(${JSON.stringify(content.input, replacerBufferWithInfo)})`);
-  if (isSdkApiCallSuccess(content)) {
-    parts.push("-> OK");
-  } else {
-    parts.push(`-> ${content.error}`);
-  }
-  return parts.join(" ");
-}
-function isSdkApiCallSuccess(x) {
-  return x && typeof x === "object" && x.commandName && x.output;
-}
-function isSdkApiCallError(x) {
-  return x && typeof x === "object" && x.commandName && x.error;
-}
-
 // ../../aws-cdk/lib/api/settings.ts
 var os3 = __toESM(require("os"));
 var fs_path = __toESM(require("path"));
@@ -2521,22 +2914,22 @@ var Settings = class _Settings {
   get empty() {
     return Object.keys(this.settings).length === 0;
   }
-  get(path12) {
-    return deepClone(deepGet(this.settings, path12));
+  get(path15) {
+    return deepClone(deepGet(this.settings, path15));
   }
-  set(path12, value) {
+  set(path15, value) {
     if (this.readOnly) {
-      throw new ToolkitError(`Can't set ${path12}: settings object is readonly`);
+      throw new ToolkitError(`Can't set ${path15}: settings object is readonly`);
     }
-    if (path12.length === 0) {
+    if (path15.length === 0) {
       this.settings = value;
     } else {
-      deepSet(this.settings, path12, value);
+      deepSet(this.settings, path15, value);
     }
     return this;
   }
-  unset(path12) {
-    this.set(path12, void 0);
+  unset(path15) {
+    this.set(path15, void 0);
   }
   prohibitContextKey(key, fileName) {
     if (!this.settings.context) {
@@ -2648,7 +3041,7 @@ var Context = class {
 };
 
 // ../../aws-cdk/lib/api/deployments/cloudformation.ts
-var import_util10 = require("util");
+var import_util19 = require("util");
 var cxapi = __toESM(require("@aws-cdk/cx-api"));
 var import_cx_api3 = require("@aws-cdk/cx-api");
 var import_client_cloudformation3 = require("@aws-sdk/client-cloudformation");
@@ -2691,7 +3084,6 @@ function formatMessage(msg, category = "TOOLKIT") {
   return {
     time: /* @__PURE__ */ new Date(),
     level: msg.level,
-    action: msg.action,
     code: msg.code ?? defaultMessageCode(msg.level, category),
     message: msg.message,
     data: msg.data
@@ -2701,56 +3093,51 @@ function defaultMessageCode(level, category = "TOOLKIT") {
   const levelIndicator = level === "error" ? "E" : level === "warn" ? "W" : "I";
   return `CDK_${category}_${levelIndicator}0000`;
 }
-var error2 = (action, message, code, payload) => {
+var error3 = (message2, code, payload) => {
   return formatMessage({
     level: "error",
-    action,
     code,
-    message,
+    message: message2,
     data: payload
   });
 };
-var warn = (action, message, code, payload) => {
+var warn2 = (message2, code, payload) => {
   return formatMessage({
     level: "warn",
-    action,
     code,
-    message,
+    message: message2,
     data: payload
   });
 };
-var info2 = (action, message, code, payload) => {
+var info3 = (message2, code, payload) => {
   return formatMessage({
     level: "info",
-    action,
     code,
-    message,
+    message: message2,
     data: payload
   });
 };
-var debug2 = (action, message, code, payload) => {
+var debug3 = (message2, code, payload) => {
   return formatMessage({
     level: "debug",
-    action,
     code,
-    message,
+    message: message2,
     data: payload
   });
 };
-var trace2 = (action, message, code, payload) => {
+var trace3 = (message2, code, payload) => {
   return formatMessage({
     level: "trace",
-    action,
     code,
-    message,
+    message: message2,
     data: payload
   });
 };
 
 // ../../aws-cdk/lib/api/stack-events/stack-activity-monitor.ts
 var util6 = __toESM(require("util"));
-var import_cloud_assembly_schema = require("@aws-cdk/cloud-assembly-schema");
-var uuid = __toESM(require("uuid"));
+var import_cloud_assembly_schema2 = require("@aws-cdk/cloud-assembly-schema");
+var uuid2 = __toESM(require("uuid"));
 
 // ../../aws-cdk/lib/api/stack-events/stack-event-poller.ts
 var StackEventPoller = class _StackEventPoller {
@@ -2950,8 +3337,7 @@ var StackProgressMonitor = class {
 var StackActivityMonitor = class {
   constructor({
     cfn,
-    ioHost,
-    action,
+    ioHelper,
     stack,
     stackName,
     resourcesTotal,
@@ -2959,8 +3345,7 @@ var StackActivityMonitor = class {
     pollingInterval = 2e3
   }) {
     this.errors = [];
-    this.ioHost = ioHost;
-    this.action = action;
+    this.ioHelper = ioHelper;
     this.stack = stack;
     this.stackName = stackName;
     this.progressMonitor = new StackProgressMonitor(resourcesTotal);
@@ -2971,8 +3356,8 @@ var StackActivityMonitor = class {
     });
   }
   async start() {
-    this.monitorId = uuid.v4();
-    await this.ioHost.notify(debug2(this.action, `Deploying ${this.stackName}`, "CDK_TOOLKIT_I5501", {
+    this.monitorId = uuid2.v4();
+    await this.ioHelper.notify(debug3(`Deploying ${this.stackName}`, "CDK_TOOLKIT_I5501", {
       deployment: this.monitorId,
       stack: this.stack,
       stackName: this.stackName,
@@ -2988,7 +3373,7 @@ var StackActivityMonitor = class {
       clearTimeout(this.tickTimer);
     }
     await this.finalPollToEnd(oldMonitorId);
-    await this.ioHost.notify(debug2(this.action, `Completed ${this.stackName}`, "CDK_TOOLKIT_I5503", {
+    await this.ioHelper.notify(debug3(`Completed ${this.stackName}`, "CDK_TOOLKIT_I5503", {
       deployment: oldMonitorId,
       stack: this.stack,
       stackName: this.stackName,
@@ -3013,8 +3398,7 @@ var StackActivityMonitor = class {
         return;
       }
     } catch (e) {
-      await this.ioHost.notify(error2(
-        this.action,
+      await this.ioHelper.notify(error3(
         util6.format("Error occurred while monitoring stack: %s", e),
         "CDK_TOOLKIT_E5500",
         { error: e }
@@ -3027,12 +3411,12 @@ var StackActivityMonitor = class {
     if (!logicalId || !metadata) {
       return void 0;
     }
-    for (const path12 of Object.keys(metadata)) {
-      const entry = metadata[path12].filter((e) => e.type === import_cloud_assembly_schema.ArtifactMetadataEntryType.LOGICAL_ID).find((e) => e.data === logicalId);
+    for (const path15 of Object.keys(metadata)) {
+      const entry = metadata[path15].filter((e) => e.type === import_cloud_assembly_schema2.ArtifactMetadataEntryType.LOGICAL_ID).find((e) => e.data === logicalId);
       if (entry) {
         return {
           entry,
-          constructPath: this.simplifyConstructPath(path12)
+          constructPath: this.simplifyConstructPath(path15)
         };
       }
     }
@@ -3056,7 +3440,7 @@ var StackActivityMonitor = class {
         progress: this.progressMonitor.progress
       };
       this.checkForErrors(activity);
-      await this.ioHost.notify(info2(this.action, this.formatActivity(activity, true), "CDK_TOOLKIT_I5502", activity));
+      await this.ioHelper.notify(info3(this.formatActivity(activity, true), "CDK_TOOLKIT_I5502", activity));
     }
   }
   /**
@@ -3101,13 +3485,13 @@ var StackActivityMonitor = class {
       }
     }
   }
-  simplifyConstructPath(path12) {
-    path12 = path12.replace(/\/Resource$/, "");
-    path12 = path12.replace(/^\//, "");
-    if (path12.startsWith(this.stackName + "/")) {
-      path12 = path12.slice(this.stackName.length + 1);
+  simplifyConstructPath(path15) {
+    path15 = path15.replace(/\/Resource$/, "");
+    path15 = path15.replace(/^\//, "");
+    if (path15.startsWith(this.stackName + "/")) {
+      path15 = path15.slice(this.stackName.length + 1);
     }
-    return path12;
+    return path15;
   }
 };
 
@@ -3191,7 +3575,7 @@ async function makeBodyParameter(stack, resolvedEnvironment, assetManifest, reso
   }
   const toolkitInfo = await resources.lookupToolkit();
   if (!toolkitInfo.found) {
-    error(
+    error2(
       `The template for stack "${stack.displayName}" is ${Math.round(templateJson.length / 1024)}KiB. Templates larger than ${LARGE_TEMPLATE_SIZE_KB}KiB must be uploaded to S3.
 Run the following command in order to setup an S3 bucket in this environment, and then re-deploy:
 
@@ -3220,7 +3604,7 @@ Run the following command in order to setup an S3 bucket in this environment, an
     }
   );
   const templateURL = `${toolkitInfo.bucketUrl}/${key}`;
-  debug("Storing template in S3 at:", templateURL);
+  debug2("Storing template in S3 at:", templateURL);
   return { TemplateURL: templateURL };
 }
 async function restUrlFromManifest(url, environment) {
@@ -3324,11 +3708,11 @@ var CloudFormationStack = class _CloudFormationStack {
     if (!this.exists) {
       return {};
     }
-    const result = {};
+    const result2 = {};
     (this.stack.Outputs || []).forEach((output) => {
-      result[output.OutputKey] = output.OutputValue;
+      result2[output.OutputKey] = output.OutputValue;
     });
-    return result;
+    return result2;
   }
   /**
    * The stack's status
@@ -3412,23 +3796,23 @@ async function describeChangeSet(cfn, stackName, changeSetName, { fetchAll }) {
 }
 async function waitFor(valueProvider, timeout = 5e3) {
   while (true) {
-    const result = await valueProvider();
-    if (result === null) {
+    const result2 = await valueProvider();
+    if (result2 === null) {
       return void 0;
-    } else if (result !== void 0) {
-      return result;
+    } else if (result2 !== void 0) {
+      return result2;
     }
     await new Promise((cb) => setTimeout(cb, timeout));
   }
 }
-async function waitForChangeSet(cfn, { ioHost, action }, stackName, changeSetName, { fetchAll }) {
-  await ioHost.notify(debug2(action, (0, import_util10.format)("Waiting for changeset %s on stack %s to finish creating...", changeSetName, stackName)));
+async function waitForChangeSet(cfn, ioHelper, stackName, changeSetName, { fetchAll }) {
+  await ioHelper.notify(debug3((0, import_util19.format)("Waiting for changeset %s on stack %s to finish creating...", changeSetName, stackName)));
   const ret = await waitFor(async () => {
     const description = await describeChangeSet(cfn, stackName, changeSetName, {
       fetchAll
     });
     if (description.Status === "CREATE_PENDING" || description.Status === "CREATE_IN_PROGRESS") {
-      await ioHost.notify(debug2(action, (0, import_util10.format)("Changeset %s on stack %s is still creating", changeSetName, stackName)));
+      await ioHelper.notify(debug3((0, import_util19.format)("Changeset %s on stack %s is still creating", changeSetName, stackName)));
       return void 0;
     }
     if (description.Status === import_client_cloudformation3.ChangeSetStatus.CREATE_COMPLETE || changeSetHasNoChanges(description)) {
@@ -3482,8 +3866,8 @@ function changeSetHasNoChanges(description) {
   ];
   return description.Status === "FAILED" && noChangeErrorPrefixes.some((p) => (description.StatusReason ?? "").startsWith(p));
 }
-async function waitForStackDelete(cfn, { ioHost, action }, stackName) {
-  const stack = await stabilizeStack(cfn, { ioHost, action }, stackName);
+async function waitForStackDelete(cfn, ioHelper, stackName) {
+  const stack = await stabilizeStack(cfn, ioHelper, stackName);
   if (!stack) {
     return void 0;
   }
@@ -3497,8 +3881,8 @@ async function waitForStackDelete(cfn, { ioHost, action }, stackName) {
   }
   return stack;
 }
-async function waitForStackDeploy(cfn, { ioHost, action }, stackName) {
-  const stack = await stabilizeStack(cfn, { ioHost, action }, stackName);
+async function waitForStackDeploy(cfn, ioHelper, stackName) {
+  const stack = await stabilizeStack(cfn, ioHelper, stackName);
   if (!stack) {
     return void 0;
   }
@@ -3512,20 +3896,20 @@ async function waitForStackDeploy(cfn, { ioHost, action }, stackName) {
   }
   return stack;
 }
-async function stabilizeStack(cfn, { ioHost, action }, stackName) {
-  await ioHost.notify(debug2(action, (0, import_util10.format)("Waiting for stack %s to finish creating or updating...", stackName)));
+async function stabilizeStack(cfn, ioHelper, stackName) {
+  await ioHelper.notify(debug3((0, import_util19.format)("Waiting for stack %s to finish creating or updating...", stackName)));
   return waitFor(async () => {
     const stack = await CloudFormationStack.lookup(cfn, stackName);
     if (!stack.exists) {
-      await ioHost.notify(debug2(action, (0, import_util10.format)("Stack %s does not exist", stackName)));
+      await ioHelper.notify(debug3((0, import_util19.format)("Stack %s does not exist", stackName)));
       return null;
     }
     const status = stack.stackStatus;
     if (status.isInProgress) {
-      await ioHost.notify(debug2(action, (0, import_util10.format)("Stack %s has an ongoing operation in progress and is not stable (%s)", stackName, status)));
+      await ioHelper.notify(debug3((0, import_util19.format)("Stack %s has an ongoing operation in progress and is not stable (%s)", stackName, status)));
       return void 0;
     } else if (status.isReviewInProgress) {
-      await ioHost.notify(debug2(action, (0, import_util10.format)("Stack %s is in REVIEW_IN_PROGRESS state. Considering this is a stable status (%s)", stackName, status)));
+      await ioHelper.notify(debug3((0, import_util19.format)("Stack %s is in REVIEW_IN_PROGRESS state. Considering this is a stable status (%s)", stackName, status)));
     }
     return stack;
   });
@@ -3622,13 +4006,13 @@ var chalk12 = __toESM(require("chalk"));
 // ../../aws-cdk/lib/api/deployments/asset-publishing.ts
 var import_cx_api4 = require("@aws-cdk/cx-api");
 var import_cdk_assets3 = require("cdk-assets");
-async function publishAssets(manifest, sdk, targetEnv, options, { ioHost, action }) {
+async function publishAssets(manifest, sdk, targetEnv, options, ioHelper) {
   if (targetEnv.account === void 0 || targetEnv.account === import_cx_api4.UNKNOWN_ACCOUNT || targetEnv.region === void 0 || targetEnv.account === import_cx_api4.UNKNOWN_REGION) {
     throw new ToolkitError(`Asset publishing requires resolved account and region, got ${JSON.stringify(targetEnv)}`);
   }
   const publisher = new import_cdk_assets3.AssetPublishing(manifest, {
     aws: new PublishingAws(sdk, targetEnv),
-    progressListener: new PublishingProgressListener({ ioHost, action }),
+    progressListener: new PublishingProgressListener(ioHelper),
     throwOnError: false,
     publishInParallel: options.parallel ?? true,
     buildAssets: true,
@@ -3725,18 +4109,17 @@ var EVENT_TO_LEVEL = {
   shell_close: false
 };
 var BasePublishProgressListener = class {
-  constructor({ ioHost, action }) {
-    this.ioHost = ioHost;
-    this.action = action;
+  constructor(ioHelper) {
+    this.ioHelper = ioHelper;
   }
   onPublishEvent(type, event) {
     const level = EVENT_TO_LEVEL[type];
     if (level) {
-      void this.ioHost.notify(
+      void this.ioHelper.notify(
         formatMessage({
           level,
-          action: this.action,
-          message: this.getMessage(type, event)
+          message: this.getMessage(type, event),
+          data: void 0
         })
       );
     }
@@ -3749,7 +4132,7 @@ var PublishingProgressListener = class extends BasePublishProgressListener {
 };
 
 // ../../aws-cdk/lib/api/deployments/checks.ts
-async function determineAllowCrossAccountAssetPublishing(sdk, { ioHost, action }, customStackName) {
+async function determineAllowCrossAccountAssetPublishing(sdk, ioHelper, customStackName) {
   try {
     const stackName = customStackName || "CDKToolkit";
     const stackInfo = await getBootstrapStackInfo(sdk, stackName);
@@ -3761,8 +4144,8 @@ async function determineAllowCrossAccountAssetPublishing(sdk, { ioHost, action }
     }
     return false;
   } catch (e) {
-    await ioHost.notify(debug2(action, `Error determining cross account asset publishing: ${e}`));
-    await ioHost.notify(debug2(action, "Defaulting to allowing cross account asset publishing"));
+    await ioHelper.notify(debug3(`Error determining cross account asset publishing: ${e}`));
+    await ioHelper.notify(debug3("Defaulting to allowing cross account asset publishing"));
     return true;
   }
 }
@@ -3794,16 +4177,16 @@ async function getBootstrapStackInfo(sdk, stackName) {
 }
 
 // ../../aws-cdk/lib/api/deployments/deploy-stack.ts
-var import_util13 = require("util");
+var import_util25 = require("util");
 var chalk9 = __toESM(require("chalk"));
-var uuid2 = __toESM(require("uuid"));
+var uuid3 = __toESM(require("uuid"));
 
 // ../../aws-cdk/lib/api/deployments/assets.ts
 var path5 = __toESM(require("path"));
 var cxschema2 = __toESM(require("@aws-cdk/cloud-assembly-schema"));
 var cxapi2 = __toESM(require("@aws-cdk/cx-api"));
 var chalk7 = __toESM(require("chalk"));
-async function addMetadataAssetsToManifest({ ioHost, action }, stack, assetManifest, envResources, reuse) {
+async function addMetadataAssetsToManifest(ioHelper, stack, assetManifest, envResources, reuse) {
   reuse = reuse || [];
   const assets = stack.assets;
   if (assets.length === 0) {
@@ -3817,23 +4200,23 @@ async function addMetadataAssetsToManifest({ ioHost, action }, stack, assetManif
   for (const asset of assets) {
     const reuseAsset = reuse.indexOf(asset.id) > -1;
     if (reuseAsset) {
-      await ioHost.notify(debug2(action, `Reusing asset ${asset.id}: ${JSON.stringify(asset)}`));
+      await ioHelper.notify(debug3(`Reusing asset ${asset.id}: ${JSON.stringify(asset)}`));
       continue;
     }
-    await ioHost.notify(debug2(action, `Preparing asset ${asset.id}: ${JSON.stringify(asset)}`));
+    await ioHelper.notify(debug3(`Preparing asset ${asset.id}: ${JSON.stringify(asset)}`));
     if (!stack.assembly) {
       throw new ToolkitError("Unexpected: stack assembly is required in order to find assets in assembly directory");
     }
-    Object.assign(params, await prepareAsset({ ioHost, action }, asset, assetManifest, envResources, toolkitInfo));
+    Object.assign(params, await prepareAsset(ioHelper, asset, assetManifest, envResources, toolkitInfo));
   }
   return params;
 }
-async function prepareAsset({ ioHost, action }, asset, assetManifest, envResources, toolkitInfo) {
+async function prepareAsset(ioHelper, asset, assetManifest, envResources, toolkitInfo) {
   switch (asset.packaging) {
     case "zip":
     case "file":
       return prepareFileAsset(
-        { ioHost, action },
+        ioHelper,
         asset,
         assetManifest,
         toolkitInfo,
@@ -3845,13 +4228,13 @@ async function prepareAsset({ ioHost, action }, asset, assetManifest, envResourc
       throw new ToolkitError(`Unsupported packaging type: ${asset.packaging}. You might need to upgrade your aws-cdk toolkit to support this asset type.`);
   }
 }
-async function prepareFileAsset({ ioHost, action }, asset, assetManifest, toolkitInfo, packaging) {
+async function prepareFileAsset(ioHelper, asset, assetManifest, toolkitInfo, packaging) {
   const extension = packaging === cxschema2.FileAssetPackaging.ZIP_DIRECTORY ? ".zip" : path5.extname(asset.path);
   const baseName = `${asset.sourceHash}${extension}`;
   const s3Prefix = asset.id === asset.sourceHash ? "assets/" : `assets/${asset.id}/`;
   const key = `${s3Prefix}${baseName}`;
   const s3url = `s3://${toolkitInfo.bucketName}/${key}`;
-  await ioHost.notify(debug2(action, `Storing asset ${asset.path} at ${s3url}`));
+  await ioHelper.notify(debug3(`Storing asset ${asset.path} at ${s3url}`));
   assetManifest.addFileAsset(asset.sourceHash, {
     path: asset.path,
     packaging
@@ -3892,7 +4275,7 @@ async function prepareDockerImageAsset(asset, assetManifest, envResources) {
 }
 
 // ../../aws-cdk/lib/api/deployments/hotswap-deployments.ts
-var import_util12 = require("util");
+var import_util23 = require("util");
 var cfn_diff = __toESM(require("@aws-cdk/cloudformation-diff"));
 var chalk8 = __toESM(require("chalk"));
 
@@ -4610,12 +4993,12 @@ async function fetchFileFromS3(s3Url, sdk) {
 async function exponentialBackOffRetry(fn, numOfRetries, backOff, errorCodeToRetry) {
   try {
     await fn();
-  } catch (error3) {
-    if (error3 && error3.name === errorCodeToRetry && numOfRetries > 0) {
+  } catch (error4) {
+    if (error4 && error4.name === errorCodeToRetry && numOfRetries > 0) {
       await sleep(backOff);
       await exponentialBackOffRetry(fn, numOfRetries - 1, backOff * 2, errorCodeToRetry);
     } else {
-      throw error3;
+      throw error4;
     }
   }
 }
@@ -5196,7 +5579,7 @@ var RESOURCE_DETECTORS = {
   },
   "AWS::CDK::Metadata": async () => []
 };
-async function tryHotswapDeployment(sdkProvider, { ioHost, action }, assetParams, cloudFormationStack, stackArtifact, hotswapMode, hotswapPropertyOverrides) {
+async function tryHotswapDeployment(sdkProvider, ioHelper, assetParams, cloudFormationStack, stackArtifact, hotswapMode, hotswapPropertyOverrides) {
   const resolvedEnv = await sdkProvider.resolveEnvironment(stackArtifact.environment);
   const sdk = (await sdkProvider.forEnvironment(resolvedEnv, 1 /* ForWriting */)).sdk;
   const currentTemplate = await loadCurrentTemplateWithNestedStacks(stackArtifact, sdk);
@@ -5218,13 +5601,13 @@ async function tryHotswapDeployment(sdkProvider, { ioHost, action }, assetParams
     currentTemplate.nestedStacks,
     hotswapPropertyOverrides
   );
-  await logNonHotswappableChanges({ ioHost, action }, nonHotswappableChanges, hotswapMode);
+  await logNonHotswappableChanges(ioHelper, nonHotswappableChanges, hotswapMode);
   if (hotswapMode === "fall-back" /* FALL_BACK */) {
     if (nonHotswappableChanges.length > 0) {
       return void 0;
     }
   }
-  await applyAllHotswappableChanges(sdk, { ioHost, action }, hotswappableChanges);
+  await applyAllHotswappableChanges(sdk, ioHelper, hotswappableChanges);
   return {
     type: "did-deploy-stack",
     noOp: hotswappableChanges.length === 0,
@@ -5415,51 +5798,51 @@ function isCandidateForHotswapping(change, logicalId) {
     propertyUpdates: change.propertyUpdates
   };
 }
-async function applyAllHotswappableChanges(sdk, { ioHost, action }, hotswappableChanges) {
+async function applyAllHotswappableChanges(sdk, ioHelper, hotswappableChanges) {
   if (hotswappableChanges.length > 0) {
-    await ioHost.notify(info2(action, `
+    await ioHelper.notify(info3(`
 ${ICON} hotswapping resources:`));
   }
   const limit = pLimit(10);
   return Promise.all(hotswappableChanges.map((hotswapOperation) => limit(() => {
-    return applyHotswappableChange(sdk, { ioHost, action }, hotswapOperation);
+    return applyHotswappableChange(sdk, ioHelper, hotswapOperation);
   })));
 }
-async function applyHotswappableChange(sdk, { ioHost, action }, hotswapOperation) {
+async function applyHotswappableChange(sdk, ioHelper, hotswapOperation) {
   const customUserAgent = `cdk-hotswap/success-${hotswapOperation.service}`;
   sdk.appendCustomUserAgent(customUserAgent);
   for (const name of hotswapOperation.resourceNames) {
-    await ioHost.notify(info2(action, (0, import_util12.format)(`   ${ICON} %s`, chalk8.bold(name))));
+    await ioHelper.notify(info3((0, import_util23.format)(`   ${ICON} %s`, chalk8.bold(name))));
   }
   try {
     await hotswapOperation.apply(sdk);
   } catch (e) {
     if (e.name === "TimeoutError" || e.name === "AbortError") {
-      const result = JSON.parse(formatErrorMessage(e));
-      const error3 = new ToolkitError(formatWaiterErrorResult(result));
-      error3.name = e.name;
-      throw error3;
+      const result2 = JSON.parse(formatErrorMessage(e));
+      const error4 = new ToolkitError(formatWaiterErrorResult(result2));
+      error4.name = e.name;
+      throw error4;
     }
     throw e;
   }
   for (const name of hotswapOperation.resourceNames) {
-    await ioHost.notify(info2(action, (0, import_util12.format)(`${ICON} %s %s`, chalk8.bold(name), chalk8.green("hotswapped!"))));
+    await ioHelper.notify(info3((0, import_util23.format)(`${ICON} %s %s`, chalk8.bold(name), chalk8.green("hotswapped!"))));
   }
   sdk.removeCustomUserAgent(customUserAgent);
 }
-function formatWaiterErrorResult(result) {
+function formatWaiterErrorResult(result2) {
   const main = [
-    `Resource is not in the expected state due to waiter status: ${result.state}`,
-    result.reason ? `${result.reason}.` : ""
+    `Resource is not in the expected state due to waiter status: ${result2.state}`,
+    result2.reason ? `${result2.reason}.` : ""
   ].join(". ");
-  if (result.observedResponses != null) {
-    const observedResponses = Object.entries(result.observedResponses).map(([msg, count]) => `  - ${msg} (${count})`).join("\n");
+  if (result2.observedResponses != null) {
+    const observedResponses = Object.entries(result2.observedResponses).map(([msg, count]) => `  - ${msg} (${count})`).join("\n");
     return `${main} Observed responses:
 ${observedResponses}`;
   }
   return main;
 }
-async function logNonHotswappableChanges({ ioHost, action }, nonHotswappableChanges, hotswapMode) {
+async function logNonHotswappableChanges(ioHelper, nonHotswappableChanges, hotswapMode) {
   if (nonHotswappableChanges.length === 0) {
     return;
   }
@@ -5471,13 +5854,13 @@ async function logNonHotswappableChanges({ ioHost, action }, nonHotswappableChan
   }
   const messages = [""];
   if (hotswapMode === "hotswap-only" /* HOTSWAP_ONLY */) {
-    messages.push((0, import_util12.format)("%s %s", chalk8.red("\u26A0\uFE0F"), chalk8.red("The following non-hotswappable changes were found. To reconcile these using CloudFormation, specify --hotswap-fallback")));
+    messages.push((0, import_util23.format)("%s %s", chalk8.red("\u26A0\uFE0F"), chalk8.red("The following non-hotswappable changes were found. To reconcile these using CloudFormation, specify --hotswap-fallback")));
   } else {
-    messages.push((0, import_util12.format)("%s %s", chalk8.red("\u26A0\uFE0F"), chalk8.red("The following non-hotswappable changes were found:")));
+    messages.push((0, import_util23.format)("%s %s", chalk8.red("\u26A0\uFE0F"), chalk8.red("The following non-hotswappable changes were found:")));
   }
   for (const change of nonHotswappableChanges) {
     if (change.rejectedChanges.length > 0) {
-      messages.push((0, import_util12.format)(
+      messages.push((0, import_util23.format)(
         "    logicalID: %s, type: %s, rejected changes: %s, reason: %s",
         chalk8.bold(change.logicalId),
         chalk8.bold(change.resourceType),
@@ -5485,7 +5868,7 @@ async function logNonHotswappableChanges({ ioHost, action }, nonHotswappableChan
         chalk8.red(change.reason)
       ));
     } else {
-      messages.push((0, import_util12.format)(
+      messages.push((0, import_util23.format)(
         "    logicalID: %s, type: %s, reason: %s",
         chalk8.bold(change.logicalId),
         chalk8.bold(change.resourceType),
@@ -5494,11 +5877,11 @@ async function logNonHotswappableChanges({ ioHost, action }, nonHotswappableChan
     }
   }
   messages.push("");
-  await ioHost.notify(info2(action, messages.join("\n")));
+  await ioHelper.notify(info3(messages.join("\n")));
 }
 
 // ../../aws-cdk/lib/api/deployments/deploy-stack.ts
-async function deployStack(options, { ioHost, action }) {
+async function deployStack(options, ioHelper) {
   const stackArtifact = options.stack;
   const stackEnv = options.resolvedEnvironment;
   options.sdk.appendCustomUserAgent(options.extraUserAgent);
@@ -5506,12 +5889,11 @@ async function deployStack(options, { ioHost, action }) {
   const deployName = options.deployName || stackArtifact.stackName;
   let cloudFormationStack = await CloudFormationStack.lookup(cfn, deployName);
   if (cloudFormationStack.stackStatus.isCreationFailure) {
-    await ioHost.notify(debug2(
-      action,
+    await ioHelper.notify(debug3(
       `Found existing stack ${deployName} that had previously failed creation. Deleting it before attempting to re-create it.`
     ));
     await cfn.deleteStack({ StackName: deployName });
-    const deletedStack = await waitForStackDelete(cfn, { ioHost, action }, deployName);
+    const deletedStack = await waitForStackDelete(cfn, ioHelper, deployName);
     if (deletedStack && deletedStack.stackStatus.name !== "DELETE_COMPLETE") {
       throw new ToolkitError(
         `Failed deleting stack ${deployName} that had previously failed creation (current state: ${deletedStack.stackStatus})`
@@ -5521,7 +5903,7 @@ async function deployStack(options, { ioHost, action }) {
   }
   const legacyAssets = new AssetManifestBuilder();
   const assetParams = await addMetadataAssetsToManifest(
-    { ioHost, action },
+    ioHelper,
     stackArtifact,
     legacyAssets,
     options.envResources,
@@ -5532,12 +5914,11 @@ async function deployStack(options, { ioHost, action }) {
   const stackParams = options.usePreviousParameters ? templateParams.updateExisting(finalParameterValues, cloudFormationStack.parameters) : templateParams.supplyAll(finalParameterValues);
   const hotswapMode = options.hotswap ?? "full-deployment" /* FULL_DEPLOYMENT */;
   const hotswapPropertyOverrides = options.hotswapPropertyOverrides ?? new HotswapPropertyOverrides();
-  if (await canSkipDeploy(options, cloudFormationStack, stackParams.hasChanges(cloudFormationStack.parameters), { ioHost, action })) {
-    await ioHost.notify(debug2(action, `${deployName}: skipping deployment (use --force to override)`));
+  if (await canSkipDeploy(options, cloudFormationStack, stackParams.hasChanges(cloudFormationStack.parameters), ioHelper)) {
+    await ioHelper.notify(debug3(`${deployName}: skipping deployment (use --force to override)`));
     if (hotswapMode !== "full-deployment" /* FULL_DEPLOYMENT */) {
-      await ioHost.notify(info2(
-        action,
-        (0, import_util13.format)(
+      await ioHelper.notify(info3(
+        (0, import_util25.format)(
           `
  ${ICON} %s
 `,
@@ -5552,7 +5933,7 @@ async function deployStack(options, { ioHost, action }) {
       stackArn: cloudFormationStack.stackId
     };
   } else {
-    await ioHost.notify(debug2(action, `${deployName}: deploying...`));
+    await ioHelper.notify(debug3(`${deployName}: deploying...`));
   }
   const bodyParameter = await makeBodyParameter(
     stackArtifact,
@@ -5565,17 +5946,17 @@ async function deployStack(options, { ioHost, action }) {
   try {
     bootstrapStackName = (await options.envResources.lookupToolkit()).stackName;
   } catch (e) {
-    await ioHost.notify(debug2(action, `Could not determine the bootstrap stack name: ${e}`));
+    await ioHelper.notify(debug3(`Could not determine the bootstrap stack name: ${e}`));
   }
   await publishAssets(legacyAssets.toManifest(stackArtifact.assembly.directory), options.sdkProvider, stackEnv, {
     parallel: options.assetParallelism,
-    allowCrossAccount: await determineAllowCrossAccountAssetPublishing(options.sdk, { ioHost, action }, bootstrapStackName)
-  }, { ioHost, action });
+    allowCrossAccount: await determineAllowCrossAccountAssetPublishing(options.sdk, ioHelper, bootstrapStackName)
+  }, ioHelper);
   if (hotswapMode !== "full-deployment" /* FULL_DEPLOYMENT */) {
     try {
       const hotswapDeploymentResult = await tryHotswapDeployment(
         options.sdkProvider,
-        { ioHost, action },
+        ioHelper,
         stackParams.values,
         cloudFormationStack,
         stackArtifact,
@@ -5585,7 +5966,7 @@ async function deployStack(options, { ioHost, action }) {
       if (hotswapDeploymentResult) {
         return hotswapDeploymentResult;
       }
-      await ioHost.notify(info2(action, (0, import_util13.format)(
+      await ioHelper.notify(info3((0, import_util25.format)(
         "Could not perform a hotswap deployment, as the stack %s contains non-Asset changes",
         stackArtifact.displayName
       )));
@@ -5593,13 +5974,13 @@ async function deployStack(options, { ioHost, action }) {
       if (!(e instanceof CfnEvaluationException)) {
         throw e;
       }
-      await ioHost.notify(info2(action, (0, import_util13.format)(
+      await ioHelper.notify(info3((0, import_util25.format)(
         "Could not perform a hotswap deployment, because the CloudFormation template could not be resolved: %s",
         formatErrorMessage(e)
       )));
     }
     if (hotswapMode === "fall-back" /* FALL_BACK */) {
-      await ioHost.notify(info2(action, "Falling back to doing a full deployment"));
+      await ioHelper.notify(info3("Falling back to doing a full deployment"));
       options.sdk.appendCustomUserAgent("cdk-hotswap/fallback");
     } else {
       return {
@@ -5616,25 +5997,23 @@ async function deployStack(options, { ioHost, action }) {
     stackArtifact,
     stackParams,
     bodyParameter,
-    ioHost,
-    action
+    ioHelper
   );
   return fullDeployment.performDeployment();
 }
 var FullCloudFormationDeployment = class {
-  constructor(options, cloudFormationStack, stackArtifact, stackParams, bodyParameter, ioHost, action) {
+  constructor(options, cloudFormationStack, stackArtifact, stackParams, bodyParameter, ioHelper) {
     this.options = options;
     this.cloudFormationStack = cloudFormationStack;
     this.stackArtifact = stackArtifact;
     this.stackParams = stackParams;
     this.bodyParameter = bodyParameter;
-    this.ioHost = ioHost;
-    this.action = action;
+    this.ioHelper = ioHelper;
     this.cfn = options.sdk.cloudFormation();
     this.stackName = options.deployName ?? stackArtifact.stackName;
     this.update = cloudFormationStack.exists && cloudFormationStack.stackStatus.name !== "REVIEW_IN_PROGRESS";
     this.verb = this.update ? "update" : "create";
-    this.uuid = uuid2.v4();
+    this.uuid = uuid3.v4();
   }
   async performDeployment() {
     const deploymentMethod = this.options.deploymentMethod ?? {
@@ -5657,17 +6036,16 @@ var FullCloudFormationDeployment = class {
     const changeSetDescription = await this.createChangeSet(changeSetName, execute, importExistingResources);
     await this.updateTerminationProtection();
     if (changeSetHasNoChanges(changeSetDescription)) {
-      await this.ioHost.notify(debug2(this.action, (0, import_util13.format)("No changes are to be performed on %s.", this.stackName)));
+      await this.ioHelper.notify(debug3((0, import_util25.format)("No changes are to be performed on %s.", this.stackName)));
       if (execute) {
-        await this.ioHost.notify(debug2(this.action, (0, import_util13.format)("Deleting empty change set %s", changeSetDescription.ChangeSetId)));
+        await this.ioHelper.notify(debug3((0, import_util25.format)("Deleting empty change set %s", changeSetDescription.ChangeSetId)));
         await this.cfn.deleteChangeSet({
           StackName: this.stackName,
           ChangeSetName: changeSetName
         });
       }
       if (this.options.force) {
-        await this.ioHost.notify(warn(
-          this.action,
+        await this.ioHelper.notify(warn2(
           [
             "You used the --force flag, but CloudFormation reported that the deployment would not make any changes.",
             "According to CloudFormation, all resources are already up-to-date with the state in your CDK app.",
@@ -5685,7 +6063,7 @@ var FullCloudFormationDeployment = class {
       };
     }
     if (!execute) {
-      await this.ioHost.notify(info2(this.action, (0, import_util13.format)(
+      await this.ioHelper.notify(info3((0, import_util25.format)(
         "Changeset %s created and waiting in review for manual execution (--no-execute)",
         changeSetDescription.ChangeSetId
       )));
@@ -5712,8 +6090,8 @@ var FullCloudFormationDeployment = class {
   }
   async createChangeSet(changeSetName, willExecute, importExistingResources) {
     await this.cleanupOldChangeset(changeSetName);
-    await this.ioHost.notify(debug2(this.action, `Attempting to create ChangeSet with name ${changeSetName} to ${this.verb} stack ${this.stackName}`));
-    await this.ioHost.notify(info2(this.action, (0, import_util13.format)("%s: creating CloudFormation changeset...", chalk9.bold(this.stackName))));
+    await this.ioHelper.notify(debug3(`Attempting to create ChangeSet with name ${changeSetName} to ${this.verb} stack ${this.stackName}`));
+    await this.ioHelper.notify(info3((0, import_util25.format)("%s: creating CloudFormation changeset...", chalk9.bold(this.stackName))));
     const changeSet = await this.cfn.createChangeSet({
       StackName: this.stackName,
       ChangeSetName: changeSetName,
@@ -5724,22 +6102,21 @@ var FullCloudFormationDeployment = class {
       ImportExistingResources: importExistingResources,
       ...this.commonPrepareOptions()
     });
-    await this.ioHost.notify(debug2(this.action, (0, import_util13.format)("Initiated creation of changeset: %s; waiting for it to finish creating...", changeSet.Id)));
-    return waitForChangeSet(this.cfn, { ioHost: this.ioHost, action: this.action }, this.stackName, changeSetName, {
+    await this.ioHelper.notify(debug3((0, import_util25.format)("Initiated creation of changeset: %s; waiting for it to finish creating...", changeSet.Id)));
+    return waitForChangeSet(this.cfn, this.ioHelper, this.stackName, changeSetName, {
       fetchAll: willExecute
     });
   }
   async executeChangeSet(changeSet) {
-    await this.ioHost.notify(debug2(this.action, (0, import_util13.format)("Initiating execution of changeset %s on stack %s", changeSet.ChangeSetId, this.stackName)));
+    await this.ioHelper.notify(debug3((0, import_util25.format)("Initiating execution of changeset %s on stack %s", changeSet.ChangeSetId, this.stackName)));
     await this.cfn.executeChangeSet({
       StackName: this.stackName,
       ChangeSetName: changeSet.ChangeSetName,
       ClientRequestToken: `exec${this.uuid}`,
       ...this.commonExecuteOptions()
     });
-    await this.ioHost.notify(debug2(
-      this.action,
-      (0, import_util13.format)(
+    await this.ioHelper.notify(debug3(
+      (0, import_util25.format)(
         "Execution of changeset %s on stack %s has started; waiting for the update to complete...",
         changeSet.ChangeSetId,
         this.stackName
@@ -5750,7 +6127,7 @@ var FullCloudFormationDeployment = class {
   }
   async cleanupOldChangeset(changeSetName) {
     if (this.cloudFormationStack.exists) {
-      await this.ioHost.notify(debug2(this.action, `Removing existing change set with name ${changeSetName} if it exists`));
+      await this.ioHelper.notify(debug3(`Removing existing change set with name ${changeSetName} if it exists`));
       await this.cfn.deleteChangeSet({
         StackName: this.stackName,
         ChangeSetName: changeSetName
@@ -5760,9 +6137,8 @@ var FullCloudFormationDeployment = class {
   async updateTerminationProtection() {
     const terminationProtection = this.stackArtifact.terminationProtection ?? false;
     if (!!this.cloudFormationStack.terminationProtection !== terminationProtection) {
-      await this.ioHost.notify(debug2(
-        this.action,
-        (0, import_util13.format)(
+      await this.ioHelper.notify(debug3(
+        (0, import_util25.format)(
           "Updating termination protection from %s to %s for stack %s",
           this.cloudFormationStack.terminationProtection,
           terminationProtection,
@@ -5773,11 +6149,11 @@ var FullCloudFormationDeployment = class {
         StackName: this.stackName,
         EnableTerminationProtection: terminationProtection
       });
-      await this.ioHost.notify(debug2(this.action, (0, import_util13.format)("Termination protection updated to %s for stack %s", terminationProtection, this.stackName)));
+      await this.ioHelper.notify(debug3((0, import_util25.format)("Termination protection updated to %s for stack %s", terminationProtection, this.stackName)));
     }
   }
   async directDeployment() {
-    await this.ioHost.notify(info2(this.action, (0, import_util13.format)("%s: %s stack...", chalk9.bold(this.stackName), this.update ? "updating" : "creating")));
+    await this.ioHelper.notify(info3((0, import_util25.format)("%s: %s stack...", chalk9.bold(this.stackName), this.update ? "updating" : "creating")));
     const startTime = /* @__PURE__ */ new Date();
     if (this.update) {
       await this.updateTerminationProtection();
@@ -5790,7 +6166,7 @@ var FullCloudFormationDeployment = class {
         });
       } catch (err) {
         if (err.message === "No updates are to be performed.") {
-          await this.ioHost.notify(debug2(this.action, (0, import_util13.format)("No updates are to be performed for stack %s", this.stackName)));
+          await this.ioHelper.notify(debug3((0, import_util25.format)("No updates are to be performed for stack %s", this.stackName)));
           return {
             type: "did-deploy-stack",
             noOp: true,
@@ -5819,14 +6195,13 @@ var FullCloudFormationDeployment = class {
       stack: this.stackArtifact,
       stackName: this.stackName,
       resourcesTotal: expectedChanges,
-      ioHost: this.ioHost,
-      action: this.action,
+      ioHelper: this.ioHelper,
       changeSetCreationTime: startTime
     });
     await monitor.start();
     let finalState = this.cloudFormationStack;
     try {
-      const successStack = await waitForStackDeploy(this.cfn, { ioHost: this.ioHost, action: this.action }, this.stackName);
+      const successStack = await waitForStackDeploy(this.cfn, this.ioHelper, this.stackName);
       if (!successStack) {
         throw new ToolkitError("Stack deploy failed (the stack disappeared while we were deploying it)");
       }
@@ -5836,7 +6211,7 @@ var FullCloudFormationDeployment = class {
     } finally {
       await monitor.stop();
     }
-    debug2(this.action, (0, import_util13.format)("Stack %s has completed updating", this.stackName));
+    debug3((0, import_util25.format)("Stack %s has completed updating", this.stackName));
     return {
       type: "did-deploy-stack",
       noOp: false,
@@ -5872,7 +6247,7 @@ var FullCloudFormationDeployment = class {
     };
   }
 };
-async function destroyStack(options, { ioHost, action }) {
+async function destroyStack(options, ioHelper) {
   const deployName = options.deployName || options.stack.stackName;
   const cfn = options.sdk.cloudFormation();
   const currentStack = await CloudFormationStack.lookup(cfn, deployName);
@@ -5883,13 +6258,12 @@ async function destroyStack(options, { ioHost, action }) {
     cfn,
     stack: options.stack,
     stackName: deployName,
-    ioHost,
-    action
+    ioHelper
   });
   await monitor.start();
   try {
     await cfn.deleteStack({ StackName: deployName, RoleARN: options.roleArn });
-    const destroyedStack = await waitForStackDelete(cfn, { ioHost, action }, deployName);
+    const destroyedStack = await waitForStackDelete(cfn, ioHelper, deployName);
     if (destroyedStack && destroyedStack.stackStatus.name !== "DELETE_COMPLETE") {
       throw new ToolkitError(`Failed to destroy ${deployName}: ${destroyedStack.stackStatus}`);
     }
@@ -5901,47 +6275,47 @@ async function destroyStack(options, { ioHost, action }) {
     }
   }
 }
-async function canSkipDeploy(deployStackOptions, cloudFormationStack, parameterChanges, { ioHost, action }) {
+async function canSkipDeploy(deployStackOptions, cloudFormationStack, parameterChanges, ioHelper) {
   const deployName = deployStackOptions.deployName || deployStackOptions.stack.stackName;
-  await ioHost.notify(debug2(action, `${deployName}: checking if we can skip deploy`));
+  await ioHelper.notify(debug3(`${deployName}: checking if we can skip deploy`));
   if (deployStackOptions.force) {
-    await ioHost.notify(debug2(action, `${deployName}: forced deployment`));
+    await ioHelper.notify(debug3(`${deployName}: forced deployment`));
     return false;
   }
   if (deployStackOptions.deploymentMethod?.method === "change-set" && deployStackOptions.deploymentMethod.execute === false) {
-    await ioHost.notify(debug2(action, `${deployName}: --no-execute, always creating change set`));
+    await ioHelper.notify(debug3(`${deployName}: --no-execute, always creating change set`));
     return false;
   }
   if (!cloudFormationStack.exists) {
-    await ioHost.notify(debug2(action, `${deployName}: no existing stack`));
+    await ioHelper.notify(debug3(`${deployName}: no existing stack`));
     return false;
   }
   if (JSON.stringify(deployStackOptions.stack.template) !== JSON.stringify(await cloudFormationStack.template())) {
-    await ioHost.notify(debug2(action, `${deployName}: template has changed`));
+    await ioHelper.notify(debug3(`${deployName}: template has changed`));
     return false;
   }
   if (!compareTags(cloudFormationStack.tags, deployStackOptions.tags ?? [])) {
-    await ioHost.notify(debug2(action, `${deployName}: tags have changed`));
+    await ioHelper.notify(debug3(`${deployName}: tags have changed`));
     return false;
   }
   if (!arrayEquals(cloudFormationStack.notificationArns, deployStackOptions.notificationArns ?? [])) {
-    await ioHost.notify(debug2(action, `${deployName}: notification arns have changed`));
+    await ioHelper.notify(debug3(`${deployName}: notification arns have changed`));
     return false;
   }
   if (!!deployStackOptions.stack.terminationProtection !== !!cloudFormationStack.terminationProtection) {
-    await ioHost.notify(debug2(action, `${deployName}: termination protection has been updated`));
+    await ioHelper.notify(debug3(`${deployName}: termination protection has been updated`));
     return false;
   }
   if (parameterChanges) {
     if (parameterChanges === "ssm") {
-      await ioHost.notify(debug2(action, `${deployName}: some parameters come from SSM so we have to assume they may have changed`));
+      await ioHelper.notify(debug3(`${deployName}: some parameters come from SSM so we have to assume they may have changed`));
     } else {
-      await ioHost.notify(debug2(action, `${deployName}: parameters have changed`));
+      await ioHelper.notify(debug3(`${deployName}: parameters have changed`));
     }
     return false;
   }
   if (cloudFormationStack.stackStatus.isFailure) {
-    await ioHost.notify(debug2(action, `${deployName}: stack is in a failure state`));
+    await ioHelper.notify(debug3(`${deployName}: stack is in a failure state`));
     return false;
   }
   return true;
@@ -5973,34 +6347,54 @@ function hasReplacement(cs) {
 
 // ../../aws-cdk/lib/notices.ts
 var https = __toESM(require("node:https"));
-var path9 = __toESM(require("path"));
-var fs10 = __toESM(require("fs-extra"));
+var path10 = __toESM(require("path"));
+var fs11 = __toESM(require("fs-extra"));
 var semver4 = __toESM(require("semver"));
 
 // ../../aws-cdk/lib/cli/version.ts
-var path7 = __toESM(require("path"));
+var path8 = __toESM(require("path"));
 var chalk10 = __toESM(require("chalk"));
-var fs8 = __toESM(require("fs-extra"));
+var fs9 = __toESM(require("fs-extra"));
 var semver3 = __toESM(require("semver"));
 
+// ../../aws-cdk/lib/cli/root-dir.ts
+var fs8 = __toESM(require("fs"));
+var path7 = __toESM(require("path"));
+function cliRootDir(fail) {
+  function _rootDir(dirname6) {
+    const manifestPath = path7.join(dirname6, "package.json");
+    if (fs8.existsSync(manifestPath)) {
+      return dirname6;
+    }
+    if (path7.dirname(dirname6) === dirname6) {
+      if (fail ?? true) {
+        throw new ToolkitError("Unable to find package manifest");
+      }
+      return void 0;
+    }
+    return _rootDir(path7.dirname(dirname6));
+  }
+  return _rootDir(__dirname);
+}
+
 // ../../aws-cdk/lib/cli/util/console-formatters.ts
 var stripAnsi = require("strip-ansi");
 
 // ../../aws-cdk/lib/cli/util/npm.ts
 var import_child_process = require("child_process");
-var import_util14 = require("util");
+var import_util27 = require("util");
 var semver2 = __toESM(require("semver"));
-var exec = (0, import_util14.promisify)(import_child_process.exec);
+var exec = (0, import_util27.promisify)(import_child_process.exec);
 
 // ../../aws-cdk/lib/cli/version.ts
 var ONE_DAY_IN_SECONDS = 1 * 24 * 60 * 60;
 function versionNumber() {
-  return require(path7.join(rootDir(), "package.json")).version.replace(/\+[0-9a-f]+$/, "");
+  return require(path8.join(cliRootDir(), "package.json")).version.replace(/\+[0-9a-f]+$/, "");
 }
 
 // ../../aws-cdk/lib/tree.ts
-var path8 = __toESM(require("path"));
-var fs9 = __toESM(require("fs-extra"));
+var path9 = __toESM(require("path"));
+var fs10 = __toESM(require("fs-extra"));
 function some(node, predicate) {
   return node != null && (predicate(node) || findInChildren());
   function findInChildren() {
@@ -6011,23 +6405,23 @@ function loadTree(assembly) {
   try {
     const outdir = assembly.directory;
     const fileName = assembly.tree()?.file;
-    return fileName ? fs9.readJSONSync(path8.join(outdir, fileName)).tree : {};
+    return fileName ? fs10.readJSONSync(path9.join(outdir, fileName)).tree : {};
   } catch (e) {
-    trace(`Failed to get tree.json file: ${e}. Proceeding with empty tree.`);
+    trace2(`Failed to get tree.json file: ${e}. Proceeding with empty tree.`);
     return void 0;
   }
 }
 function loadTreeFromDir(outdir) {
   try {
-    return fs9.readJSONSync(path8.join(outdir, "tree.json")).tree;
+    return fs10.readJSONSync(path9.join(outdir, "tree.json")).tree;
   } catch (e) {
-    trace(`Failed to get tree.json file: ${e}. Proceeding with empty tree.`);
+    trace2(`Failed to get tree.json file: ${e}. Proceeding with empty tree.`);
     return void 0;
   }
 }
 
 // ../../aws-cdk/lib/notices.ts
-var CACHE_FILE_PATH = path9.join(cdkCacheDir(), "notices.json");
+var CACHE_FILE_PATH = path10.join(cdkCacheDir(), "notices.json");
 var NoticesFilter = class _NoticesFilter {
   static filter(options) {
     const components = [
@@ -6210,7 +6604,7 @@ var Notices = class _Notices {
       const notices = await dataSource.fetch();
       this.data = new Set(this.includeAcknowlegded ? notices : notices.filter((n) => !this.acknowledgedIssueNumbers.has(n.issueNumber)));
     } catch (e) {
-      debug(`Could not refresh notices: ${e}`);
+      debug2(`Could not refresh notices: ${e}`);
     }
   }
   /**
@@ -6227,9 +6621,9 @@ var Notices = class _Notices {
       bootstrappedEnvironments: Array.from(this.bootstrappedEnvironments.values())
     });
     if (filteredNotices.length > 0) {
-      info("");
-      info("NOTICES         (What's this? https://github.com/aws/aws-cdk/wiki/CLI-Notices)");
-      info("");
+      info2("");
+      info2("NOTICES         (What's this? https://github.com/aws/aws-cdk/wiki/CLI-Notices)");
+      info2("");
       for (const filtered of filteredNotices) {
         const formatted = filtered.format();
         switch (filtered.notice.severity) {
@@ -6237,18 +6631,18 @@ var Notices = class _Notices {
             warning(formatted);
             break;
           case "error":
-            error(formatted);
+            error2(formatted);
             break;
           default:
-            info(formatted);
+            info2(formatted);
         }
-        info("");
+        info2("");
       }
-      info(`If you don\u2019t want to see a notice anymore, use "cdk acknowledge <id>". For example, "cdk acknowledge ${filteredNotices[0].notice.issueNumber}".`);
+      info2(`If you don\u2019t want to see a notice anymore, use "cdk acknowledge <id>". For example, "cdk acknowledge ${filteredNotices[0].notice.issueNumber}".`);
     }
     if (options.showTotal ?? false) {
-      info("");
-      info(`There are ${filteredNotices.length} unacknowledged notice(s).`);
+      info2("");
+      info2(`There are ${filteredNotices.length} unacknowledged notice(s).`);
     }
   }
 };
@@ -6322,7 +6716,7 @@ var WebsiteNoticeDataSource = class {
                   if (!data) {
                     throw new ToolkitError("'notices' key is missing");
                   }
-                  debug("Notices refreshed");
+                  debug2("Notices refreshed");
                   resolve3(data ?? []);
                 } catch (e) {
                   reject(new ToolkitError(`Failed to parse notices: ${formatErrorMessage(e)}`));
@@ -6360,7 +6754,7 @@ var CachedDataSource = class {
       await this.save(freshData);
       return freshData.notices;
     } else {
-      debug(`Reading cached notices from ${this.fileName}`);
+      debug2(`Reading cached notices from ${this.fileName}`);
       return data;
     }
   }
@@ -6371,7 +6765,7 @@ var CachedDataSource = class {
         notices: await this.dataSource.fetch()
       };
     } catch (e) {
-      debug(`Could not refresh notices: ${e}`);
+      debug2(`Could not refresh notices: ${e}`);
       return {
         expiration: Date.now() + TIME_TO_LIVE_ERROR,
         notices: []
@@ -6384,23 +6778,23 @@ var CachedDataSource = class {
       notices: []
     };
     try {
-      return fs10.existsSync(this.fileName) ? await fs10.readJSON(this.fileName) : defaultValue;
+      return fs11.existsSync(this.fileName) ? await fs11.readJSON(this.fileName) : defaultValue;
     } catch (e) {
-      debug(`Failed to load notices from cache: ${e}`);
+      debug2(`Failed to load notices from cache: ${e}`);
       return defaultValue;
     }
   }
   async save(cached2) {
     try {
-      await fs10.writeJSON(this.fileName, cached2);
+      await fs11.writeJSON(this.fileName, cached2);
     } catch (e) {
-      debug(`Failed to store notices in the cache: ${e}`);
+      debug2(`Failed to store notices in the cache: ${e}`);
     }
   }
 };
 
 // ../../aws-cdk/lib/api/toolkit-info.ts
-var import_util15 = require("util");
+var import_util30 = require("util");
 var chalk11 = __toESM(require("chalk"));
 
 // ../../aws-cdk/lib/api/bootstrap/bootstrap-props.ts
@@ -6408,6 +6802,7 @@ var BUCKET_NAME_OUTPUT = "BucketName";
 var REPOSITORY_NAME_OUTPUT = "ImageRepositoryName";
 var BUCKET_DOMAIN_NAME_OUTPUT = "BucketDomainName";
 var BOOTSTRAP_VERSION_OUTPUT = "BootstrapVersion";
+var BOOTSTRAP_VERSION_RESOURCE = "CdkBootstrapVersion";
 var BOOTSTRAP_VARIANT_PARAMETER = "BootstrapVariant";
 var DEFAULT_BOOTSTRAP_VARIANT = "AWS CDK: Default Resources";
 
@@ -6417,15 +6812,14 @@ var ToolkitInfo = class _ToolkitInfo {
   static determineName(overrideName) {
     return overrideName ?? DEFAULT_TOOLKIT_STACK_NAME;
   }
-  static async lookup(environment, sdk, { ioHost, action }, stackName) {
+  static async lookup(environment, sdk, ioHelper, stackName) {
     const cfn = sdk.cloudFormation();
     stackName = _ToolkitInfo.determineName(stackName);
     try {
-      const stack = await stabilizeStack(cfn, { ioHost, action }, stackName);
+      const stack = await stabilizeStack(cfn, ioHelper, stackName);
       if (!stack) {
-        await ioHost.notify(debug2(
-          action,
-          (0, import_util15.format)(
+        await ioHelper.notify(debug3(
+          (0, import_util30.format)(
             "The environment %s doesn't have the CDK toolkit stack (%s) installed. Use %s to setup your environment for use with the toolkit.",
             environment.name,
             stackName,
@@ -6435,9 +6829,8 @@ var ToolkitInfo = class _ToolkitInfo {
         return _ToolkitInfo.bootstrapStackNotFoundInfo(stackName);
       }
       if (stack.stackStatus.isCreationFailure) {
-        await ioHost.notify(debug2(
-          action,
-          (0, import_util15.format)(
+        await ioHelper.notify(debug3(
+          (0, import_util30.format)(
             "The environment %s has a CDK toolkit stack (%s) that failed to create. Use %s to try provisioning it again.",
             environment.name,
             stackName,
@@ -6548,21 +6941,21 @@ var EnvironmentResourcesRegistry = class {
     this.toolkitStackName = toolkitStackName;
     this.cache = /* @__PURE__ */ new Map();
   }
-  for(resolvedEnvironment, sdk, msg) {
+  for(resolvedEnvironment, sdk, ioHelper) {
     const key = `${resolvedEnvironment.account}:${resolvedEnvironment.region}`;
     let envCache = this.cache.get(key);
     if (!envCache) {
       envCache = emptyCache();
       this.cache.set(key, envCache);
     }
-    return new EnvironmentResources(resolvedEnvironment, sdk, msg, envCache, this.toolkitStackName);
+    return new EnvironmentResources(resolvedEnvironment, sdk, ioHelper, envCache, this.toolkitStackName);
   }
 };
 var EnvironmentResources = class {
-  constructor(environment, sdk, msg, cache, toolkitStackName) {
+  constructor(environment, sdk, ioHelper, cache, toolkitStackName) {
     this.environment = environment;
     this.sdk = sdk;
-    this.msg = msg;
+    this.ioHelper = ioHelper;
     this.cache = cache;
     this.toolkitStackName = toolkitStackName;
   }
@@ -6571,7 +6964,7 @@ var EnvironmentResources = class {
    */
   async lookupToolkit() {
     if (!this.cache.toolkitInfo) {
-      this.cache.toolkitInfo = await ToolkitInfo.lookup(this.environment, this.sdk, this.msg, this.toolkitStackName);
+      this.cache.toolkitInfo = await ToolkitInfo.lookup(this.environment, this.sdk, this.ioHelper, this.toolkitStackName);
     }
     return this.cache.toolkitInfo;
   }
@@ -6599,8 +6992,7 @@ var EnvironmentResources = class {
         }
         const bootstrapStack2 = await this.lookupToolkit();
         if (bootstrapStack2.found && bootstrapStack2.version < BOOTSTRAP_TEMPLATE_VERSION_INTRODUCING_GETPARAMETER) {
-          await this.msg.ioHost.notify(warn(
-            this.msg.action,
+          await this.ioHelper.notify(warn2(
             `Could not read SSM parameter ${ssmParameterName}: ${formatErrorMessage(e)}, falling back to version from ${bootstrapStack2}`
           ));
           doValidate(bootstrapStack2.version, this.environment);
@@ -6635,10 +7027,10 @@ var EnvironmentResources = class {
     }
     const ssm = this.sdk.ssm();
     try {
-      const result = await ssm.getParameter({ Name: parameterName });
-      const asNumber = parseInt(`${result.Parameter?.Value}`, 10);
+      const result2 = await ssm.getParameter({ Name: parameterName });
+      const asNumber = parseInt(`${result2.Parameter?.Value}`, 10);
       if (isNaN(asNumber)) {
-        throw new ToolkitError(`SSM parameter ${parameterName} not a number: ${result.Parameter?.Value}`);
+        throw new ToolkitError(`SSM parameter ${parameterName} not a number: ${result2.Parameter?.Value}`);
       }
       this.cache.ssmParameters.set(parameterName, asNumber);
       return asNumber;
@@ -6657,7 +7049,7 @@ var EnvironmentResources = class {
     }
     const ecr = this.sdk.ecr();
     try {
-      await this.msg.ioHost.notify(debug2(this.msg.action, `${repositoryName}: checking if ECR repository already exists`));
+      await this.ioHelper.notify(debug3(`${repositoryName}: checking if ECR repository already exists`));
       const describeResponse = await ecr.describeRepositories({
         repositoryNames: [repositoryName]
       });
@@ -6670,7 +7062,7 @@ var EnvironmentResources = class {
         throw e;
       }
     }
-    await this.msg.ioHost.notify(debug2(this.msg.action, `${repositoryName}: creating ECR repository`));
+    await this.ioHelper.notify(debug3(`${repositoryName}: creating ECR repository`));
     const assetTag = { Key: "awscdk:asset", Value: "true" };
     const response = await ecr.createRepository({
       repositoryName,
@@ -6680,7 +7072,7 @@ var EnvironmentResources = class {
     if (!repositoryUri) {
       throw new ToolkitError(`CreateRepository did not return a repository URI for ${repositoryUri}`);
     }
-    await this.msg.ioHost.notify(debug2(this.msg.action, `${repositoryName}: enable image scanning`));
+    await this.ioHelper.notify(debug3(`${repositoryName}: enable image scanning`));
     await ecr.putImageScanningConfiguration({
       repositoryName,
       imageScanningConfiguration: { scanOnPush: true }
@@ -6688,6 +7080,19 @@ var EnvironmentResources = class {
     return { repositoryUri };
   }
 };
+var NoBootstrapStackEnvironmentResources = class extends EnvironmentResources {
+  constructor(environment, sdk, ioHelper) {
+    super(environment, sdk, ioHelper, emptyCache());
+  }
+  /**
+   * Look up the toolkit for a given environment, using a given SDK
+   */
+  async lookupToolkit() {
+    throw new ToolkitError(
+      "Trying to perform an operation that requires a bootstrap stack; you should not see this error, this is a bug in the CDK CLI."
+    );
+  }
+};
 function emptyCache() {
   return {
     ssmParameters: /* @__PURE__ */ new Map(),
@@ -6710,12 +7115,11 @@ async function replaceEnvPlaceholders(object, env, sdkProvider) {
 
 // ../../aws-cdk/lib/api/environment/environment-access.ts
 var EnvironmentAccess = class {
-  constructor(sdkProvider, toolkitStackName, { ioHost, action }) {
+  constructor(sdkProvider, toolkitStackName, ioHelper) {
     this.sdkProvider = sdkProvider;
     this.sdkCache = /* @__PURE__ */ new Map();
     this.environmentResources = new EnvironmentResourcesRegistry(toolkitStackName);
-    this.ioHost = ioHost;
-    this.action = action;
+    this.ioHelper = ioHelper;
   }
   /**
    * Resolves the environment for a stack.
@@ -6794,7 +7198,7 @@ var EnvironmentAccess = class {
     }
     if (lookupEnv.isFallbackCredentials) {
       const arn = await lookupEnv.replacePlaceholders(stack.lookupRole?.arn);
-      await this.ioHost.notify(warn(this.action, `Lookup role ${arn} was not assumed. Proceeding with default credentials.`));
+      await this.ioHelper.notify(warn2(`Lookup role ${arn} was not assumed. Proceeding with default credentials.`));
     }
     return lookupEnv;
   }
@@ -6816,7 +7220,7 @@ var EnvironmentAccess = class {
     try {
       return await this.accessStackForLookup(stack);
     } catch (e) {
-      await this.ioHost.notify(warn(this.action, `${formatErrorMessage(e)}`));
+      await this.ioHelper.notify(warn2(`${formatErrorMessage(e)}`));
     }
     return this.accessStackForStackOperations(stack, 0 /* ForReading */);
   }
@@ -6857,7 +7261,7 @@ var EnvironmentAccess = class {
     return {
       sdk: stackSdk.sdk,
       resolvedEnvironment,
-      resources: this.environmentResources.for(resolvedEnvironment, stackSdk.sdk, { ioHost: this.ioHost, action: this.action }),
+      resources: this.environmentResources.for(resolvedEnvironment, stackSdk.sdk, this.ioHelper),
       // If we asked for a role, did not successfully assume it, and yet got here without an exception: that
       // means we must have fallback credentials.
       isFallbackCredentials: !stackSdk.didAssumeRole && !!assumeRoleArn,
@@ -6898,12 +7302,11 @@ var Deployments = class {
     this.publisherCache = /* @__PURE__ */ new Map();
     this.assetSdkProvider = props.sdkProvider;
     this.deployStackSdkProvider = props.sdkProvider;
-    this.ioHost = props.ioHost;
-    this.action = props.action;
+    this.ioHelper = props.ioHelper;
     this.envs = new EnvironmentAccess(
       props.sdkProvider,
       props.toolkitStackName ?? DEFAULT_TOOLKIT_STACK_NAME,
-      { ioHost: this.ioHost, action: this.action }
+      this.ioHelper
     );
   }
   /**
@@ -6917,12 +7320,12 @@ var Deployments = class {
     return loadCurrentTemplateWithNestedStacks(rootStackArtifact, env.sdk, retrieveProcessedTemplate);
   }
   async readCurrentTemplate(stackArtifact) {
-    await this.ioHost.notify(debug2(this.action, `Reading existing template for stack ${stackArtifact.displayName}.`));
+    await this.ioHelper.notify(debug3(`Reading existing template for stack ${stackArtifact.displayName}.`));
     const env = await this.envs.accessStackForLookupBestEffort(stackArtifact);
     return loadCurrentTemplate(stackArtifact, env.sdk);
   }
   async resourceIdentifierSummaries(stackArtifact) {
-    await this.ioHost.notify(debug2(this.action, `Retrieving template summary for stack ${stackArtifact.displayName}.`));
+    await this.ioHelper.notify(debug3(`Retrieving template summary for stack ${stackArtifact.displayName}.`));
     const env = await this.envs.accessStackForReadOnlyStackOperations(stackArtifact);
     const cfn = env.sdk.cloudFormation();
     await uploadStackTemplateAssets(stackArtifact, this);
@@ -6944,7 +7347,7 @@ var Deployments = class {
     }
     const response = await cfn.getTemplateSummary(cfnParam);
     if (!response.ResourceIdentifierSummaries) {
-      await this.ioHost.notify(debug2(this.action, 'GetTemplateSummary API call did not return "ResourceIdentifierSummaries"'));
+      await this.ioHelper.notify(debug3('GetTemplateSummary API call did not return "ResourceIdentifierSummaries"'));
     }
     return response.ResourceIdentifierSummaries ?? [];
   }
@@ -6992,7 +7395,7 @@ var Deployments = class {
       resourcesToImport: options.resourcesToImport,
       overrideTemplate: options.overrideTemplate,
       assetParallelism: options.assetParallelism
-    }, { ioHost: this.ioHost, action: this.action });
+    }, this.ioHelper);
   }
   async rollbackStack(options) {
     let resourcesToSkip = options.orphanLogicalIds ?? [];
@@ -7016,10 +7419,10 @@ var Deployments = class {
       const executionRoleArn = await env.replacePlaceholders(options.roleArn ?? options.stack.cloudFormationExecutionRoleArn);
       switch (cloudFormationStack.stackStatus.rollbackChoice) {
         case 3 /* NONE */:
-          await this.ioHost.notify(warn(this.action, `Stack ${deployName} does not need a rollback: ${cloudFormationStack.stackStatus}`));
+          await this.ioHelper.notify(warn2(`Stack ${deployName} does not need a rollback: ${cloudFormationStack.stackStatus}`));
           return { notInRollbackableState: true };
         case 0 /* START_ROLLBACK */:
-          await this.ioHost.notify(debug2(this.action, `Initiating rollback of stack ${deployName}`));
+          await this.ioHelper.notify(debug3(`Initiating rollback of stack ${deployName}`));
           await cfn.rollbackStack({
             StackName: deployName,
             RoleARN: executionRoleArn,
@@ -7038,7 +7441,7 @@ var Deployments = class {
             resourcesToSkip = poller.resourceErrors.filter((r) => !r.isStackEvent && r.parentStackLogicalIds.length === 0).map((r) => r.event.LogicalResourceId ?? "");
           }
           const skipDescription = resourcesToSkip.length > 0 ? ` (orphaning: ${resourcesToSkip.join(", ")})` : "";
-          await this.ioHost.notify(warn(this.action, `Continuing rollback of stack ${deployName}${skipDescription}`));
+          await this.ioHelper.notify(warn2(`Continuing rollback of stack ${deployName}${skipDescription}`));
           await cfn.continueUpdateRollback({
             StackName: deployName,
             ClientRequestToken: (0, import_crypto.randomUUID)(),
@@ -7047,8 +7450,7 @@ var Deployments = class {
           });
           break;
         case 2 /* ROLLBACK_FAILED */:
-          await this.ioHost.notify(warn(
-            this.action,
+          await this.ioHelper.notify(warn2(
             `Stack ${deployName} failed creation and rollback. This state cannot be rolled back. You can recreate this stack by running 'cdk deploy'.`
           ));
           return { notInRollbackableState: true };
@@ -7059,14 +7461,13 @@ var Deployments = class {
         cfn,
         stack: options.stack,
         stackName: deployName,
-        ioHost: this.ioHost,
-        action: this.action
+        ioHelper: this.ioHelper
       });
       await monitor.start();
       let stackErrorMessage = void 0;
       let finalStackState = cloudFormationStack;
       try {
-        const successStack = await stabilizeStack(cfn, { ioHost: this.ioHost, action: this.action }, deployName);
+        const successStack = await stabilizeStack(cfn, this.ioHelper, deployName);
         if (!successStack) {
           throw new ToolkitError("Stack deploy failed (the stack disappeared while we were rolling it back)");
         }
@@ -7101,10 +7502,8 @@ var Deployments = class {
       sdk: env.sdk,
       roleArn: executionRoleArn,
       stack: options.stack,
-      deployName: options.deployName,
-      quiet: options.quiet,
-      ci: options.ci
-    }, { ioHost: this.ioHost, action: this.action });
+      deployName: options.deployName
+    }, this.ioHelper);
   }
   async stackExists(options) {
     let env;
@@ -7138,7 +7537,7 @@ var Deployments = class {
     const publisher = this.cachedPublisher(assetManifest, resolvedEnvironment, options.stackName);
     await publisher.buildEntry(asset);
     if (publisher.hasFailures) {
-      throw new ToolkitError(`Failed to build asset ${asset.id}`);
+      throw new ToolkitError(`Failed to build asset ${asset.displayName(false)}`);
     }
   }
   /**
@@ -7147,18 +7546,18 @@ var Deployments = class {
   async publishSingleAsset(assetManifest, asset, options) {
     const stackEnv = await this.envs.resolveStackEnvironment(options.stack);
     const publisher = this.cachedPublisher(assetManifest, stackEnv, options.stackName);
-    await publisher.publishEntry(asset, { allowCrossAccount: await this.allowCrossAccountAssetPublishingForEnv(options.stack) });
+    await publisher.publishEntry(asset, {
+      allowCrossAccount: await this.allowCrossAccountAssetPublishingForEnv(options.stack),
+      force: options.forcePublish
+    });
     if (publisher.hasFailures) {
-      throw new ToolkitError(`Failed to publish asset ${asset.id}`);
+      throw new ToolkitError(`Failed to publish asset ${asset.displayName(true)}`);
     }
   }
   async allowCrossAccountAssetPublishingForEnv(stack) {
     if (this._allowCrossAccountAssetPublishing === void 0) {
       const env = await this.envs.accessStackForReadOnlyStackOperations(stack);
-      this._allowCrossAccountAssetPublishing = await determineAllowCrossAccountAssetPublishing(env.sdk, {
-        ioHost: this.ioHost,
-        action: this.action
-      }, this.props.toolkitStackName);
+      this._allowCrossAccountAssetPublishing = await determineAllowCrossAccountAssetPublishing(env.sdk, this.ioHelper, this.props.toolkitStackName);
     }
     return this._allowCrossAccountAssetPublishing;
   }
@@ -7192,15 +7591,15 @@ var Deployments = class {
       // The AssetPublishing class takes care of role assuming etc, so it's okay to
       // give it a direct `SdkProvider`.
       aws: new PublishingAws(this.assetSdkProvider, env),
-      progressListener: new ParallelSafeAssetProgress(prefix, { ioHost: this.ioHost, action: this.action })
+      progressListener: new ParallelSafeAssetProgress(prefix, this.ioHelper)
     });
     this.publisherCache.set(assetManifest, publisher);
     return publisher;
   }
 };
 var ParallelSafeAssetProgress = class extends BasePublishProgressListener {
-  constructor(prefix, { ioHost, action }) {
-    super({ ioHost, action });
+  constructor(prefix, ioHelper) {
+    super(ioHelper);
     this.prefix = prefix;
   }
   getMessage(type, event) {
@@ -7224,17 +7623,16 @@ function tagsForStack(stack) {
 }
 
 // ../../aws-cdk/lib/api/resource-import/importer.ts
-var import_util16 = require("util");
+var import_util34 = require("util");
 var cfnDiff = __toESM(require("@aws-cdk/cloudformation-diff"));
 var chalk13 = __toESM(require("chalk"));
-var fs11 = __toESM(require("fs-extra"));
+var fs12 = __toESM(require("fs-extra"));
 var promptly3 = __toESM(require("promptly"));
 var ResourceImporter = class {
   constructor(stack, props) {
     this.stack = stack;
     this.cfn = props.deployments;
-    this.ioHost = props.ioHost;
-    this.action = props.action;
+    this.ioHelper = props.ioHelper;
   }
   /**
    * Ask the user for resources to import
@@ -7256,23 +7654,23 @@ var ResourceImporter = class {
    * Load the resources to import from a file
    */
   async loadResourceIdentifiers(available, filename) {
-    const contents = await fs11.readJson(filename);
+    const contents = await fs12.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.ioHost.notify(info2(this.action, (0, import_util16.format)("%s: importing using %s", chalk13.blue(descr), chalk13.blue(fmtdict(idProps)))));
+        await this.ioHelper.notify(info3((0, import_util34.format)("%s: importing using %s", chalk13.blue(descr), chalk13.blue(fmtdict(idProps)))));
         ret.importResources.push(resource);
         ret.resourceMap[resource.logicalId] = idProps;
         delete contents[resource.logicalId];
       } else {
-        await this.ioHost.notify(info2(this.action, (0, import_util16.format)("%s: skipping", chalk13.blue(descr))));
+        await this.ioHelper.notify(info3((0, import_util34.format)("%s: skipping", chalk13.blue(descr))));
       }
     }
     const unknown = Object.keys(contents);
     if (unknown.length > 0) {
-      await this.ioHost.notify(warn(this.action, `Unrecognized resource identifiers in mapping file: ${unknown.join(", ")}`));
+      await this.ioHelper.notify(warn2(`Unrecognized resource identifiers in mapping file: ${unknown.join(", ")}`));
     }
     return ret;
   }
@@ -7302,18 +7700,18 @@ var ResourceImporter = class {
   }
   async importResources(overrideTemplate, resourcesToImport, options) {
     try {
-      const result = await this.cfn.deployStack({
+      const result2 = await this.cfn.deployStack({
         stack: this.stack,
         deployName: this.stack.stackName,
         ...options,
         overrideTemplate,
         resourcesToImport
       });
-      assertIsSuccessfulDeployStackResult(result);
-      const message = result.noOp ? " \u2705  %s (no changes)" : " \u2705  %s";
-      await this.ioHost.notify(info2(this.action, "\n" + chalk13.green((0, import_util16.format)(message, this.stack.displayName))));
+      assertIsSuccessfulDeployStackResult(result2);
+      const message2 = result2.noOp ? " \u2705  %s (no changes)" : " \u2705  %s";
+      await this.ioHelper.notify(info3("\n" + chalk13.green((0, import_util34.format)(message2, this.stack.displayName))));
     } catch (e) {
-      await this.ioHost.notify(error2(this.action, (0, import_util16.format)("\n \u274C  %s failed: %s", chalk13.bold(this.stack.displayName), e), "CDK_TOOLKIT_E3900"));
+      await this.ioHelper.notify(error3((0, import_util34.format)("\n \u274C  %s failed: %s", chalk13.bold(this.stack.displayName), e), "CDK_TOOLKIT_E3900"));
       throw e;
     }
   }
@@ -7332,7 +7730,7 @@ var ResourceImporter = class {
     if (nonAdditions.length) {
       const offendingResources = nonAdditions.map(([logId, _]) => this.describeResource(logId));
       if (allowNonAdditions) {
-        await this.ioHost.notify(warn(this.action, `Ignoring updated/deleted resources (--force): ${offendingResources.join(", ")}`));
+        await this.ioHelper.notify(warn2(`Ignoring updated/deleted resources (--force): ${offendingResources.join(", ")}`));
       } else {
         throw new ToolkitError(`No resource updates or deletes are allowed on import operation. Make sure to resolve pending changes to existing resources, before attempting an import. Updated/deleted resources: ${offendingResources.join(", ")} (--force to override)`);
       }
@@ -7405,7 +7803,7 @@ var ResourceImporter = class {
     const resourceName = this.describeResource(chg.logicalId);
     const resourceType = chg.resourceDiff.newResourceType;
     if (resourceType === void 0 || !(resourceType in resourceIdentifiers)) {
-      await this.ioHost.notify(warn(this.action, `${resourceName}: unsupported resource type ${resourceType}, skipping import.`));
+      await this.ioHelper.notify(warn2(`${resourceName}: unsupported resource type ${resourceType}, skipping import.`));
       return void 0;
     }
     const idPropSets = resourceIdentifiers[resourceType];
@@ -7422,7 +7820,7 @@ var ResourceImporter = class {
       }
     }
     if (satisfiedPropSets.length > 0) {
-      await this.ioHost.notify(info2(this.action, chalk13.grey(`Skipping import of ${resourceName}`)));
+      await this.ioHelper.notify(info3(chalk13.grey(`Skipping import of ${resourceName}`)));
       return void 0;
     }
     const prefix = `${chalk13.blue(resourceName)} (${resourceType})`;
@@ -7435,7 +7833,7 @@ var ResourceImporter = class {
       promptPattern = `${prefix}: enter %`;
     }
     if (preamble) {
-      await this.ioHost.notify(info2(this.action, preamble));
+      await this.ioHelper.notify(info3(preamble));
     }
     for (const idProps of idPropSets) {
       const input = {};
@@ -7459,7 +7857,7 @@ var ResourceImporter = class {
         return input;
       }
     }
-    await this.ioHost.notify(info2(this.action, chalk13.grey(`Skipping import of ${resourceName}`)));
+    await this.ioHelper.notify(info3(chalk13.grey(`Skipping import of ${resourceName}`)));
     return void 0;
   }
   /**
@@ -7510,12 +7908,11 @@ function addDefaultDeletionPolicy(resource) {
 
 // ../../aws-cdk/lib/api/resource-import/migrator.ts
 var chalk14 = __toESM(require("chalk"));
-var fs12 = __toESM(require("fs-extra"));
+var fs13 = __toESM(require("fs-extra"));
 var ResourceMigrator = class {
   constructor(props) {
     this.props = props;
-    this.ioHost = props.ioHost;
-    this.action = props.action;
+    this.ioHelper = props.ioHelper;
   }
   /**
    * Checks to see if a migrate.json file exists. If it does and the source is either `filepath` or
@@ -7527,16 +7924,15 @@ var ResourceMigrator = class {
     const stack = stacks.stackArtifacts[0];
     const migrateDeployment = new ResourceImporter(stack, {
       deployments: this.props.deployments,
-      ioHost: this.ioHost,
-      action: this.action
+      ioHelper: this.ioHelper
     });
     const resourcesToImport = await this.tryGetResources(await migrateDeployment.resolveEnvironment());
     if (resourcesToImport) {
-      await this.ioHost.notify(info2(this.action, `${chalk14.bold(stack.displayName)}: creating stack for resource migration...`));
-      await this.ioHost.notify(info2(this.action, `${chalk14.bold(stack.displayName)}: importing resources into stack...`));
+      await this.ioHelper.notify(info3(`${chalk14.bold(stack.displayName)}: creating stack for resource migration...`));
+      await this.ioHelper.notify(info3(`${chalk14.bold(stack.displayName)}: importing resources into stack...`));
       await this.performResourceMigration(migrateDeployment, resourcesToImport, options);
-      fs12.rmSync("migrate.json");
-      await this.ioHost.notify(info2(this.action, `${chalk14.bold(stack.displayName)}: applying CDKMetadata and Outputs to stack (if applicable)...`));
+      fs13.rmSync("migrate.json");
+      await this.ioHelper.notify(info3(`${chalk14.bold(stack.displayName)}: applying CDKMetadata and Outputs to stack (if applicable)...`));
     }
   }
   /**
@@ -7552,7 +7948,7 @@ var ResourceMigrator = class {
       rollback: options.rollback
     });
     elapsedDeployTime = (/* @__PURE__ */ new Date()).getTime() - startDeployTime;
-    await this.ioHost.notify(info2(this.action, `'
+    await this.ioHelper.notify(info3(`'
 \u2728  Resource migration time: ${formatTime(elapsedDeployTime)}s
 '`, "CDK_TOOLKIT_I5002", {
       duration: elapsedDeployTime
@@ -7560,7 +7956,7 @@ var ResourceMigrator = class {
   }
   async tryGetResources(environment) {
     try {
-      const migrateFile = fs12.readJsonSync("migrate.json", {
+      const migrateFile = fs13.readJsonSync("migrate.json", {
         encoding: "utf-8"
       });
       const sourceEnv = migrateFile.Source.split(":");
@@ -7576,22 +7972,35 @@ var ResourceMigrator = class {
 // ../../aws-cdk/lib/api/logs/logs-monitor.ts
 var util7 = __toESM(require("util"));
 var chalk15 = __toESM(require("chalk"));
-var SLEEP = 2e3;
+var uuid4 = __toESM(require("uuid"));
 var CloudWatchLogEventMonitor = class {
-  constructor(startTime) {
+  constructor(props) {
     /**
      * Map of environment (account:region) to LogGroupsAccessSettings
      */
     this.envsLogGroupsAccessSettings = /* @__PURE__ */ new Map();
-    this.active = false;
-    this.startTime = startTime?.getTime() ?? Date.now();
+    /**
+     * After reading events from all CloudWatch log groups
+     * how long should we wait to read more events.
+     *
+     * If there is some error with reading events (i.e. Throttle)
+     * then this is also how long we wait until we try again
+     */
+    this.pollingInterval = 2e3;
+    this.startTime = props.startTime?.getTime() ?? Date.now();
+    this.ioHelper = props.ioHelper;
   }
   /**
    * resume reading/printing events
    */
-  activate() {
-    this.active = true;
-    this.scheduleNextTick(0);
+  async activate() {
+    this.monitorId = uuid4.v4();
+    await this.ioHelper.notify(IO.CDK_TOOLKIT_I5032.msg("Start monitoring log groups", {
+      monitor: this.monitorId,
+      logGroupNames: this.logGroupNames()
+    }));
+    await this.tick();
+    this.scheduleNextTick();
   }
   /**
    * deactivates the monitor so no new events are read
@@ -7602,9 +8011,14 @@ var CloudWatchLogEventMonitor = class {
    * Also resets the start time to be when the new deployment was triggered
    * and clears the list of tracked log groups
    */
-  deactivate() {
-    this.active = false;
+  async deactivate() {
+    const oldMonitorId = this.monitorId;
+    this.monitorId = void 0;
     this.startTime = Date.now();
+    await this.ioHelper.notify(IO.CDK_TOOLKIT_I5034.msg("Stopped monitoring log groups", {
+      monitor: oldMonitorId,
+      logGroupNames: this.logGroupNames()
+    }));
     this.envsLogGroupsAccessSettings.clear();
   }
   /**
@@ -7631,22 +8045,31 @@ var CloudWatchLogEventMonitor = class {
       }
     });
   }
-  scheduleNextTick(sleep2) {
-    setTimeout(() => void this.tick(), sleep2);
+  logGroupNames() {
+    return Array.from(this.envsLogGroupsAccessSettings.values()).flatMap((settings) => Object.keys(settings.logGroupsStartTimes));
+  }
+  scheduleNextTick() {
+    if (!this.monitorId) {
+      return;
+    }
+    setTimeout(() => void this.tick(), this.pollingInterval);
   }
   async tick() {
-    if (!this.active) {
+    if (!this.monitorId) {
       return;
     }
     try {
       const events = flatten(await this.readNewEvents());
-      events.forEach((event) => {
-        this.print(event);
-      });
+      for (const event of events) {
+        await this.print(event);
+      }
+      if (!this.monitorId) {
+        return;
+      }
     } catch (e) {
-      error("Error occurred while monitoring logs: %s", e);
+      await this.ioHelper.notify(IO.CDK_TOOLKIT_E5035.msg("Error occurred while monitoring logs: %s", { error: e }));
     }
-    this.scheduleNextTick(SLEEP);
+    this.scheduleNextTick();
   }
   /**
    * Reads all new log events from a set of CloudWatch Log Groups
@@ -7664,15 +8087,16 @@ var CloudWatchLogEventMonitor = class {
   /**
    * Print out a cloudwatch event
    */
-  print(event) {
-    info(
+  async print(event) {
+    await this.ioHelper.notify(IO.CDK_TOOLKIT_I5033.msg(
       util7.format(
         "[%s] %s %s",
         chalk15.blue(event.logGroupName),
         chalk15.yellow(event.timestamp.toLocaleTimeString()),
         event.message.trim()
-      )
-    );
+      ),
+      event
+    ));
   }
   /**
    * Reads all new log events from a CloudWatch Log Group
@@ -7722,13 +8146,13 @@ var CloudWatchLogEventMonitor = class {
 
 // ../../aws-cdk/lib/api/logs/find-cloudwatch-logs.ts
 var IGNORE_LOGS_RESOURCE_TYPES = ["AWS::EC2::FlowLog", "AWS::CloudTrail::Trail", "AWS::CodeBuild::Project"];
-async function findCloudWatchLogGroups(sdkProvider, msg, stackArtifact) {
+async function findCloudWatchLogGroups(sdkProvider, ioHelper, stackArtifact) {
   let sdk;
   const resolvedEnv = await sdkProvider.resolveEnvironment(stackArtifact.environment);
   try {
-    sdk = (await new EnvironmentAccess(sdkProvider, DEFAULT_TOOLKIT_STACK_NAME, msg).accessStackForLookup(stackArtifact)).sdk;
+    sdk = (await new EnvironmentAccess(sdkProvider, DEFAULT_TOOLKIT_STACK_NAME, ioHelper).accessStackForLookup(stackArtifact)).sdk;
   } catch (e) {
-    debug(`Failed to access SDK environment: ${formatErrorMessage(e)}`);
+    await ioHelper.notify(IO.DEFAULT_TOOLKIT_DEBUG.msg(`Failed to access SDK environment: ${formatErrorMessage(e)}`));
     sdk = (await sdkProvider.forEnvironment(resolvedEnv, 0 /* ForReading */)).sdk;
   }
   const listStackResources = new LazyListStackResources(sdk, stackArtifact.stackName);
@@ -7796,12 +8220,11 @@ function findAllLogGroupNames(stackResources, evaluateCfnTemplate) {
 
 // ../../aws-cdk/lib/api/work-graph/work-graph.ts
 var WorkGraph = class {
-  constructor(nodes, props) {
+  constructor(nodes, ioHelper) {
     this.readyPool = [];
     this.lazyDependencies = /* @__PURE__ */ new Map();
     this.nodes = { ...nodes };
-    this.ioHost = props.ioHost;
-    this.action = props.action;
+    this.ioHelper = ioHelper;
   }
   addNodes(...nodes) {
     for (const node of nodes) {
@@ -7958,8 +8381,8 @@ var WorkGraph = class {
   deployed(node) {
     node.deploymentState = "completed" /* COMPLETED */;
   }
-  failed(node, error3) {
-    this.error = error3;
+  failed(node, error4) {
+    this.error = error4;
     node.deploymentState = "failed" /* FAILED */;
     this.skipRest();
     this.readyPool.splice(0);
@@ -8004,7 +8427,7 @@ var WorkGraph = class {
    * Do this in parallel, because there may be a lot of assets in an application (seen in practice: >100 assets)
    */
   async removeUnnecessaryAssets(isUnnecessary) {
-    await this.ioHost.notify(debug2(this.action, "Checking for previously published assets"));
+    await this.ioHelper.notify(debug3("Checking for previously published assets"));
     const publishes = this.nodesOfType("asset-publish");
     const classifiedNodes = await parallelPromises(
       8,
@@ -8014,7 +8437,7 @@ var WorkGraph = class {
     for (const assetNode of alreadyPublished) {
       this.removeNode(assetNode);
     }
-    await this.ioHost.notify(debug2(this.action, `${publishes.length} total assets, ${publishes.length - alreadyPublished.length} still need to be published`));
+    await this.ioHelper.notify(debug3(`${publishes.length} total assets, ${publishes.length - alreadyPublished.length} still need to be published`));
     const unusedBuilds = this.nodesOfType("asset-build").filter((build) => this.dependees(build).length === 0);
     for (const unusedBuild of unusedBuilds) {
       this.removeNode(unusedBuild);
@@ -8032,7 +8455,7 @@ var WorkGraph = class {
     this.readyPool.sort((a, b) => (b.priority ?? 0) - (a.priority ?? 0));
     if (this.readyPool.length === 0 && activeCount === 0 && pendingCount > 0) {
       const cycle = this.findCycle() ?? ["No cycle found!"];
-      await this.ioHost.notify(trace2(this.action, `Cycle ${cycle.join(" -> ")} in graph ${this}`));
+      await this.ioHelper.notify(trace3(`Cycle ${cycle.join(" -> ")} in graph ${this}`));
       throw new ToolkitError(`Unable to make progress anymore, dependency cycle between remaining artifacts: ${cycle.join(" -> ")} (run with -vv for full graph)`);
     }
   }
@@ -8058,17 +8481,17 @@ var WorkGraph = class {
       }
     }
     return void 0;
-    function recurse(nodeId, path12) {
+    function recurse(nodeId, path15) {
       if (seen.has(nodeId)) {
         return void 0;
       }
       try {
         for (const dep of self.nodes[nodeId].dependencies ?? []) {
-          const index = path12.indexOf(dep);
+          const index = path15.indexOf(dep);
           if (index > -1) {
-            return [...path12.slice(index), dep];
+            return [...path15.slice(index), dep];
           }
-          const cycle = recurse(dep, [...path12, dep]);
+          const cycle = recurse(dep, [...path15, dep]);
           if (cycle) {
             return cycle;
           }
@@ -8125,12 +8548,11 @@ function simplifyId(id) {
 var cxapi3 = __toESM(require("@aws-cdk/cx-api"));
 var import_cdk_assets4 = require("cdk-assets");
 var WorkGraphBuilder = class _WorkGraphBuilder {
-  constructor({ ioHost, action }, prebuildAssets, idPrefix = "") {
+  constructor(ioHelper, prebuildAssets, idPrefix = "") {
     this.prebuildAssets = prebuildAssets;
     this.idPrefix = idPrefix;
-    this.graph = new WorkGraph({}, { ioHost, action });
-    this.ioHost = ioHost;
-    this.action = action;
+    this.graph = new WorkGraph({}, ioHelper);
+    this.ioHelper = ioHelper;
   }
   static {
     /**
@@ -8170,7 +8592,7 @@ var WorkGraphBuilder = class _WorkGraphBuilder {
       const node = {
         type: "asset-build",
         id: buildId,
-        note: assetId,
+        note: asset.displayName(false),
         dependencies: /* @__PURE__ */ new Set([
           ...this.stackArtifactIds(assetManifestArtifact.dependencies),
           // If we disable prebuild, then assets inherit (stack) dependencies from their parent stack
@@ -8190,7 +8612,7 @@ var WorkGraphBuilder = class _WorkGraphBuilder {
       this.graph.addNodes({
         type: "asset-publish",
         id: publishId,
-        note: `${asset.id}`,
+        note: asset.displayName(true),
         dependencies: /* @__PURE__ */ new Set([
           buildId
         ]),
@@ -8224,7 +8646,7 @@ var WorkGraphBuilder = class _WorkGraphBuilder {
       } else if (cxapi3.NestedCloudAssemblyArtifact.isNestedCloudAssemblyArtifact(artifact)) {
         const assembly = new cxapi3.CloudAssembly(artifact.fullPath, { topoSort: false });
         const nestedGraph = new _WorkGraphBuilder(
-          { ioHost: this.ioHost, action: this.action },
+          this.ioHelper,
           this.prebuildAssets,
           `${this.idPrefix}${artifact.id}.`
         ).build(assembly.artifacts);
@@ -8274,6 +8696,469 @@ function onlyStacks(artifacts) {
   return artifacts.filter((x) => cxapi3.CloudFormationStackArtifact.isCloudFormationStackArtifact(x));
 }
 
+// ../../aws-cdk/lib/api/bootstrap/bootstrap-environment.ts
+var import_console = require("console");
+var path12 = __toESM(require("path"));
+
+// ../../aws-cdk/lib/api/bootstrap/deploy-bootstrap.ts
+var os4 = __toESM(require("os"));
+var path11 = __toESM(require("path"));
+var import_cloud_assembly_schema3 = require("@aws-cdk/cloud-assembly-schema");
+var import_cx_api6 = require("@aws-cdk/cx-api");
+var fs14 = __toESM(require("fs-extra"));
+var BootstrapStack = class _BootstrapStack {
+  constructor(sdkProvider, sdk, resolvedEnvironment, toolkitStackName, currentToolkitInfo, ioHelper) {
+    this.sdkProvider = sdkProvider;
+    this.sdk = sdk;
+    this.resolvedEnvironment = resolvedEnvironment;
+    this.toolkitStackName = toolkitStackName;
+    this.currentToolkitInfo = currentToolkitInfo;
+    this.ioHelper = ioHelper;
+  }
+  static async lookup(sdkProvider, environment, toolkitStackName, ioHelper) {
+    toolkitStackName = toolkitStackName ?? DEFAULT_TOOLKIT_STACK_NAME;
+    const resolvedEnvironment = await sdkProvider.resolveEnvironment(environment);
+    const sdk = (await sdkProvider.forEnvironment(resolvedEnvironment, 1 /* ForWriting */)).sdk;
+    const currentToolkitInfo = await ToolkitInfo.lookup(resolvedEnvironment, sdk, ioHelper, toolkitStackName);
+    return new _BootstrapStack(sdkProvider, sdk, resolvedEnvironment, toolkitStackName, currentToolkitInfo, ioHelper);
+  }
+  get parameters() {
+    return this.currentToolkitInfo.found ? this.currentToolkitInfo.bootstrapStack.parameters : {};
+  }
+  get terminationProtection() {
+    return this.currentToolkitInfo.found ? this.currentToolkitInfo.bootstrapStack.terminationProtection : void 0;
+  }
+  async partition() {
+    return (await this.sdk.currentAccount()).partition;
+  }
+  /**
+   * Perform the actual deployment of a bootstrap stack, given a template and some parameters
+   */
+  async update(template, parameters, options) {
+    if (this.currentToolkitInfo.found && !options.force) {
+      const abortResponse = {
+        type: "did-deploy-stack",
+        noOp: true,
+        outputs: {},
+        stackArn: this.currentToolkitInfo.bootstrapStack.stackId
+      };
+      const currentVariant = this.currentToolkitInfo.variant;
+      const newVariant = bootstrapVariantFromTemplate(template);
+      if (currentVariant !== newVariant) {
+        await this.ioHelper.notify(warn2(
+          `Bootstrap stack already exists, containing '${currentVariant}'. Not overwriting it with a template containing '${newVariant}' (use --force if you intend to overwrite)`
+        ));
+        return abortResponse;
+      }
+      const newVersion = bootstrapVersionFromTemplate(template);
+      const currentVersion = this.currentToolkitInfo.version;
+      if (newVersion < currentVersion) {
+        await this.ioHelper.notify(warn2(
+          `Bootstrap stack already at version ${currentVersion}. Not downgrading it to version ${newVersion} (use --force if you intend to downgrade)`
+        ));
+        if (newVersion === 0) {
+          await this.ioHelper.notify(warn2(
+            "(Did you set the '@aws-cdk/core:newStyleStackSynthesis' feature flag in cdk.json?)"
+          ));
+        }
+        return abortResponse;
+      }
+    }
+    const outdir = await fs14.mkdtemp(path11.join(os4.tmpdir(), "cdk-bootstrap"));
+    const builder = new import_cx_api6.CloudAssemblyBuilder(outdir);
+    const templateFile = `${this.toolkitStackName}.template.json`;
+    await fs14.writeJson(path11.join(builder.outdir, templateFile), template, {
+      spaces: 2
+    });
+    builder.addArtifact(this.toolkitStackName, {
+      type: import_cloud_assembly_schema3.ArtifactType.AWS_CLOUDFORMATION_STACK,
+      environment: import_cx_api6.EnvironmentUtils.format(this.resolvedEnvironment.account, this.resolvedEnvironment.region),
+      properties: {
+        templateFile,
+        terminationProtection: options.terminationProtection ?? false
+      }
+    });
+    const assembly = builder.buildAssembly();
+    const ret = await deployStack({
+      stack: assembly.getStackByName(this.toolkitStackName),
+      resolvedEnvironment: this.resolvedEnvironment,
+      sdk: this.sdk,
+      sdkProvider: this.sdkProvider,
+      force: options.force,
+      roleArn: options.roleArn,
+      tags: options.tags,
+      deploymentMethod: { method: "change-set", execute: options.execute },
+      parameters,
+      usePreviousParameters: options.usePreviousParameters ?? true,
+      // Obviously we can't need a bootstrap stack to deploy a bootstrap stack
+      envResources: new NoBootstrapStackEnvironmentResources(this.resolvedEnvironment, this.sdk, this.ioHelper)
+    }, this.ioHelper);
+    assertIsSuccessfulDeployStackResult(ret);
+    return ret;
+  }
+};
+function bootstrapVersionFromTemplate(template) {
+  const versionSources = [
+    template.Outputs?.[BOOTSTRAP_VERSION_OUTPUT]?.Value,
+    template.Resources?.[BOOTSTRAP_VERSION_RESOURCE]?.Properties?.Value
+  ];
+  for (const vs of versionSources) {
+    if (typeof vs === "number") {
+      return vs;
+    }
+    if (typeof vs === "string" && !isNaN(parseInt(vs, 10))) {
+      return parseInt(vs, 10);
+    }
+  }
+  return 0;
+}
+function bootstrapVariantFromTemplate(template) {
+  return template.Parameters?.[BOOTSTRAP_VARIANT_PARAMETER]?.Default ?? DEFAULT_BOOTSTRAP_VARIANT;
+}
+
+// ../../aws-cdk/lib/api/bootstrap/legacy-template.ts
+function legacyBootstrapTemplate(params) {
+  return {
+    Description: "The CDK Toolkit Stack. It was created by `cdk bootstrap` and manages resources necessary for managing your Cloud Applications with AWS CDK.",
+    Conditions: {
+      UsePublicAccessBlockConfiguration: {
+        "Fn::Equals": [
+          params.publicAccessBlockConfiguration || params.publicAccessBlockConfiguration === void 0 ? "true" : "false",
+          "true"
+        ]
+      }
+    },
+    Resources: {
+      StagingBucket: {
+        Type: "AWS::S3::Bucket",
+        Properties: {
+          BucketName: params.bucketName,
+          AccessControl: "Private",
+          BucketEncryption: {
+            ServerSideEncryptionConfiguration: [{
+              ServerSideEncryptionByDefault: {
+                SSEAlgorithm: "aws:kms",
+                KMSMasterKeyID: params.kmsKeyId
+              }
+            }]
+          },
+          PublicAccessBlockConfiguration: {
+            "Fn::If": [
+              "UsePublicAccessBlockConfiguration",
+              {
+                BlockPublicAcls: true,
+                BlockPublicPolicy: true,
+                IgnorePublicAcls: true,
+                RestrictPublicBuckets: true
+              },
+              { Ref: "AWS::NoValue" }
+            ]
+          }
+        }
+      },
+      StagingBucketPolicy: {
+        Type: "AWS::S3::BucketPolicy",
+        Properties: {
+          Bucket: { Ref: "StagingBucket" },
+          PolicyDocument: {
+            Id: "AccessControl",
+            Version: "2012-10-17",
+            Statement: [
+              {
+                Sid: "AllowSSLRequestsOnly",
+                Action: "s3:*",
+                Effect: "Deny",
+                Resource: [
+                  { "Fn::Sub": "${StagingBucket.Arn}" },
+                  { "Fn::Sub": "${StagingBucket.Arn}/*" }
+                ],
+                Condition: {
+                  Bool: { "aws:SecureTransport": "false" }
+                },
+                Principal: "*"
+              }
+            ]
+          }
+        }
+      }
+    },
+    Outputs: {
+      [BUCKET_NAME_OUTPUT]: {
+        Description: "The name of the S3 bucket owned by the CDK toolkit stack",
+        Value: { Ref: "StagingBucket" }
+      },
+      [BUCKET_DOMAIN_NAME_OUTPUT]: {
+        Description: "The domain name of the S3 bucket owned by the CDK toolkit stack",
+        Value: { "Fn::GetAtt": ["StagingBucket", "RegionalDomainName"] }
+      }
+    }
+  };
+}
+
+// ../../aws-cdk/lib/api/bootstrap/bootstrap-environment.ts
+var Bootstrapper = class {
+  constructor(source = { source: "default" }, ioHelper) {
+    this.source = source;
+    this.ioHelper = ioHelper;
+  }
+  bootstrapEnvironment(environment, sdkProvider, options = {}) {
+    switch (this.source.source) {
+      case "legacy":
+        return this.legacyBootstrap(environment, sdkProvider, options);
+      case "default":
+        return this.modernBootstrap(environment, sdkProvider, options);
+      case "custom":
+        return this.customBootstrap(environment, sdkProvider, options);
+    }
+  }
+  async showTemplate(json) {
+    const template = await this.loadTemplate();
+    process.stdout.write(`${serializeStructure(template, json)}
+`);
+  }
+  /**
+   * Deploy legacy bootstrap stack
+   *
+   */
+  async legacyBootstrap(environment, sdkProvider, options = {}) {
+    const params = options.parameters ?? {};
+    if (params.trustedAccounts?.length) {
+      throw new ToolkitError("--trust can only be passed for the modern bootstrap experience.");
+    }
+    if (params.cloudFormationExecutionPolicies?.length) {
+      throw new ToolkitError("--cloudformation-execution-policies can only be passed for the modern bootstrap experience.");
+    }
+    if (params.createCustomerMasterKey !== void 0) {
+      throw new ToolkitError("--bootstrap-customer-key can only be passed for the modern bootstrap experience.");
+    }
+    if (params.qualifier) {
+      throw new ToolkitError("--qualifier can only be passed for the modern bootstrap experience.");
+    }
+    const toolkitStackName = options.toolkitStackName ?? DEFAULT_TOOLKIT_STACK_NAME;
+    const current = await BootstrapStack.lookup(sdkProvider, environment, toolkitStackName, this.ioHelper);
+    return current.update(
+      await this.loadTemplate(params),
+      {},
+      {
+        ...options,
+        terminationProtection: options.terminationProtection ?? current.terminationProtection
+      }
+    );
+  }
+  /**
+   * Deploy CI/CD-ready bootstrap stack from template
+   *
+   */
+  async modernBootstrap(environment, sdkProvider, options = {}) {
+    const params = options.parameters ?? {};
+    const bootstrapTemplate = await this.loadTemplate();
+    const toolkitStackName = options.toolkitStackName ?? DEFAULT_TOOLKIT_STACK_NAME;
+    const current = await BootstrapStack.lookup(sdkProvider, environment, toolkitStackName, this.ioHelper);
+    const partition = await current.partition();
+    if (params.createCustomerMasterKey !== void 0 && params.kmsKeyId) {
+      throw new ToolkitError(
+        "You cannot pass '--bootstrap-kms-key-id' and '--bootstrap-customer-key' together. Specify one or the other"
+      );
+    }
+    const allTrusted = /* @__PURE__ */ new Set([
+      ...params.trustedAccounts ?? [],
+      ...params.trustedAccountsForLookup ?? []
+    ]);
+    const invalid = intersection(allTrusted, new Set(params.untrustedAccounts));
+    if (invalid.size > 0) {
+      throw new ToolkitError(`Accounts cannot be both trusted and untrusted. Found: ${[...invalid].join(",")}`);
+    }
+    const removeUntrusted = (accounts) => accounts.filter((acc) => !params.untrustedAccounts?.map(String).includes(String(acc)));
+    const trustedAccounts = removeUntrusted(params.trustedAccounts ?? splitCfnArray(current.parameters.TrustedAccounts));
+    (0, import_console.info)(`Trusted accounts for deployment: ${trustedAccounts.length > 0 ? trustedAccounts.join(", ") : "(none)"}`);
+    const trustedAccountsForLookup = removeUntrusted(
+      params.trustedAccountsForLookup ?? splitCfnArray(current.parameters.TrustedAccountsForLookup)
+    );
+    (0, import_console.info)(
+      `Trusted accounts for lookup: ${trustedAccountsForLookup.length > 0 ? trustedAccountsForLookup.join(", ") : "(none)"}`
+    );
+    const cloudFormationExecutionPolicies = params.cloudFormationExecutionPolicies ?? splitCfnArray(current.parameters.CloudFormationExecutionPolicies);
+    if (trustedAccounts.length === 0 && cloudFormationExecutionPolicies.length === 0) {
+      const implicitPolicy = `arn:${partition}:iam::aws:policy/AdministratorAccess`;
+      await this.ioHelper.notify(warn2(
+        `Using default execution policy of '${implicitPolicy}'. Pass '--cloudformation-execution-policies' to customize.`
+      ));
+    } else if (cloudFormationExecutionPolicies.length === 0) {
+      throw new ToolkitError(
+        `Please pass '--cloudformation-execution-policies' when using '--trust' to specify deployment permissions. Try a managed policy of the form 'arn:${partition}:iam::aws:policy/<PolicyName>'.`
+      );
+    } else {
+      (0, import_console.info)(`Execution policies: ${cloudFormationExecutionPolicies.join(", ")}`);
+    }
+    const currentKmsKeyId = current.parameters.FileAssetsBucketKmsKeyId;
+    const kmsKeyId = params.kmsKeyId ?? (params.createCustomerMasterKey === true ? CREATE_NEW_KEY : params.createCustomerMasterKey === false || currentKmsKeyId === void 0 ? USE_AWS_MANAGED_KEY : void 0);
+    const currentPermissionsBoundary = current.parameters.InputPermissionsBoundary || void 0;
+    const inputPolicyName = params.examplePermissionsBoundary ? CDK_BOOTSTRAP_PERMISSIONS_BOUNDARY : params.customPermissionsBoundary;
+    let policyName;
+    if (inputPolicyName) {
+      const sdk = (await sdkProvider.forEnvironment(environment, 1 /* ForWriting */)).sdk;
+      policyName = await this.getPolicyName(environment, sdk, inputPolicyName, partition, params);
+    }
+    if (currentPermissionsBoundary !== policyName) {
+      if (!currentPermissionsBoundary) {
+        await this.ioHelper.notify(warn2(
+          `Adding new permissions boundary ${policyName}`
+        ));
+      } else if (!policyName) {
+        await this.ioHelper.notify(warn2(
+          `Removing existing permissions boundary ${currentPermissionsBoundary}`
+        ));
+      } else {
+        await this.ioHelper.notify(warn2(
+          `Changing permissions boundary from ${currentPermissionsBoundary} to ${policyName}`
+        ));
+      }
+    }
+    return current.update(
+      bootstrapTemplate,
+      {
+        FileAssetsBucketName: params.bucketName,
+        FileAssetsBucketKmsKeyId: kmsKeyId,
+        // Empty array becomes empty string
+        TrustedAccounts: trustedAccounts.join(","),
+        TrustedAccountsForLookup: trustedAccountsForLookup.join(","),
+        CloudFormationExecutionPolicies: cloudFormationExecutionPolicies.join(","),
+        Qualifier: params.qualifier,
+        PublicAccessBlockConfiguration: params.publicAccessBlockConfiguration || params.publicAccessBlockConfiguration === void 0 ? "true" : "false",
+        InputPermissionsBoundary: policyName
+      },
+      {
+        ...options,
+        terminationProtection: options.terminationProtection ?? current.terminationProtection
+      }
+    );
+  }
+  async getPolicyName(environment, sdk, permissionsBoundary, partition, params) {
+    if (permissionsBoundary !== CDK_BOOTSTRAP_PERMISSIONS_BOUNDARY) {
+      this.validatePolicyName(permissionsBoundary);
+      return Promise.resolve(permissionsBoundary);
+    }
+    const arn = await this.getExamplePermissionsBoundary(
+      params.qualifier ?? "hnb659fds",
+      partition,
+      environment.account,
+      sdk
+    );
+    const policyName = arn.split("/").pop();
+    if (!policyName) {
+      throw new ToolkitError("Could not retrieve the example permission boundary!");
+    }
+    return Promise.resolve(policyName);
+  }
+  async getExamplePermissionsBoundary(qualifier, partition, account, sdk) {
+    const iam = sdk.iam();
+    let policyName = `cdk-${qualifier}-permissions-boundary`;
+    const arn = `arn:${partition}:iam::${account}:policy/${policyName}`;
+    try {
+      let getPolicyResp = await iam.getPolicy({ PolicyArn: arn });
+      if (getPolicyResp.Policy) {
+        return arn;
+      }
+    } catch (e) {
+      if (e.name === "NoSuchEntity") {
+      } else {
+        throw e;
+      }
+    }
+    const policyDoc = {
+      Version: "2012-10-17",
+      Statement: [
+        {
+          Action: ["*"],
+          Resource: "*",
+          Effect: "Allow",
+          Sid: "ExplicitAllowAll"
+        },
+        {
+          Condition: {
+            StringEquals: {
+              "iam:PermissionsBoundary": `arn:${partition}:iam::${account}:policy/cdk-${qualifier}-permissions-boundary`
+            }
+          },
+          Action: [
+            "iam:CreateUser",
+            "iam:CreateRole",
+            "iam:PutRolePermissionsBoundary",
+            "iam:PutUserPermissionsBoundary"
+          ],
+          Resource: "*",
+          Effect: "Allow",
+          Sid: "DenyAccessIfRequiredPermBoundaryIsNotBeingApplied"
+        },
+        {
+          Action: [
+            "iam:CreatePolicyVersion",
+            "iam:DeletePolicy",
+            "iam:DeletePolicyVersion",
+            "iam:SetDefaultPolicyVersion"
+          ],
+          Resource: `arn:${partition}:iam::${account}:policy/cdk-${qualifier}-permissions-boundary`,
+          Effect: "Deny",
+          Sid: "DenyPermBoundaryIAMPolicyAlteration"
+        },
+        {
+          Action: ["iam:DeleteUserPermissionsBoundary", "iam:DeleteRolePermissionsBoundary"],
+          Resource: "*",
+          Effect: "Deny",
+          Sid: "DenyRemovalOfPermBoundaryFromAnyUserOrRole"
+        }
+      ]
+    };
+    const request2 = {
+      PolicyName: policyName,
+      PolicyDocument: JSON.stringify(policyDoc)
+    };
+    const createPolicyResponse = await iam.createPolicy(request2);
+    if (createPolicyResponse.Policy?.Arn) {
+      return createPolicyResponse.Policy.Arn;
+    } else {
+      throw new ToolkitError(`Could not retrieve the example permission boundary ${arn}!`);
+    }
+  }
+  validatePolicyName(permissionsBoundary) {
+    const regexp = /[\w+\/=,.@-]+/;
+    const matches = regexp.exec(permissionsBoundary);
+    if (!(matches && matches.length === 1 && matches[0] === permissionsBoundary)) {
+      throw new ToolkitError(`The permissions boundary name ${permissionsBoundary} does not match the IAM conventions.`);
+    }
+  }
+  async customBootstrap(environment, sdkProvider, options = {}) {
+    const version = bootstrapVersionFromTemplate(await this.loadTemplate());
+    if (version === 0) {
+      return this.legacyBootstrap(environment, sdkProvider, options);
+    } else {
+      return this.modernBootstrap(environment, sdkProvider, options);
+    }
+  }
+  async loadTemplate(params = {}) {
+    switch (this.source.source) {
+      case "custom":
+        return loadStructuredFile(this.source.templateFile);
+      case "default":
+        return loadStructuredFile(path12.join(bundledPackageRootDir(__dirname), "lib", "api", "bootstrap", "bootstrap-template.yaml"));
+      case "legacy":
+        return legacyBootstrapTemplate(params);
+    }
+  }
+};
+var USE_AWS_MANAGED_KEY = "AWS_MANAGED_KEY";
+var CREATE_NEW_KEY = "";
+var CDK_BOOTSTRAP_PERMISSIONS_BOUNDARY = "CDK_BOOTSTRAP_PERMISSIONS_BOUNDARY";
+function splitCfnArray(xs) {
+  if (xs === "" || xs === void 0) {
+    return [];
+  }
+  return xs.split(",");
+}
+function intersection(xs, ys) {
+  return new Set(Array.from(xs).filter((x) => ys.has(x)));
+}
+
 // ../../aws-cdk/lib/context-providers/index.ts
 var context_providers_exports = {};
 __export(context_providers_exports, {
@@ -8293,8 +9178,8 @@ var AmiContextProviderPlugin = class {
   async getValue(args) {
     const region = args.region;
     const account = args.account;
-    info(`Searching for AMI in ${account}:${region}`);
-    debug(`AMI search parameters: ${JSON.stringify(args)}`);
+    info2(`Searching for AMI in ${account}:${region}`);
+    debug2(`AMI search parameters: ${JSON.stringify(args)}`);
     const ec2 = (await initContextProviderSdk(this.aws, args)).ec2();
     const response = await ec2.describeImages({
       Owners: args.owners,
@@ -8308,7 +9193,7 @@ var AmiContextProviderPlugin = class {
       throw new ContextProviderError("No AMI found that matched the search criteria");
     }
     images.sort(descending((i) => Date.parse(i.CreationDate || "1970")));
-    debug(`Selected image '${images[0].ImageId}' created at '${images[0].CreationDate}'`);
+    debug2(`Selected image '${images[0].ImageId}' created at '${images[0].CreationDate}'`);
     return images[0].ImageId;
   }
 };
@@ -8326,7 +9211,7 @@ var AZContextProviderPlugin = class {
   async getValue(args) {
     const region = args.region;
     const account = args.account;
-    debug(`Reading AZs for ${account}:${region}`);
+    debug2(`Reading AZs for ${account}:${region}`);
     const ec2 = (await initContextProviderSdk(this.aws, args)).ec2();
     const response = await ec2.describeAvailabilityZones({});
     if (!response.AvailabilityZones) {
@@ -8339,27 +9224,6 @@ var AZContextProviderPlugin = class {
   }
 };
 
-// ../../aws-cdk/lib/util/json.ts
-function getResultObj(jsonObject, identifier, propertiesToReturn) {
-  const propsObj = {};
-  propertiesToReturn.forEach((propName) => {
-    Object.assign(propsObj, { [propName]: findJsonValue(jsonObject, propName) });
-  });
-  Object.assign(propsObj, { ["Identifier"]: identifier });
-  return propsObj;
-}
-function findJsonValue(jsonObject, path12) {
-  const paths = path12.split(".");
-  let obj = jsonObject;
-  paths.forEach((p) => {
-    obj = obj[p];
-    if (obj === void 0) {
-      throw new TypeError(`Cannot read field ${path12}. ${p} is not found.`);
-    }
-  });
-  return obj;
-}
-
 // ../../aws-cdk/lib/context-providers/cc-api-provider.ts
 var CcApiContextProviderPlugin = class {
   constructor(aws) {
@@ -8374,8 +9238,8 @@ var CcApiContextProviderPlugin = class {
    */
   async getValue(args) {
     const cloudControl = (await initContextProviderSdk(this.aws, args)).cloudControl();
-    const result = await this.findResources(cloudControl, args);
-    return result;
+    const result2 = await this.findResources(cloudControl, args);
+    return result2;
   }
   async findResources(cc, args) {
     if (args.exactIdentifier && args.propertyMatch) {
@@ -8400,14 +9264,14 @@ var CcApiContextProviderPlugin = class {
   async getResource(cc, typeName, exactIdentifier, propertiesToReturn) {
     const resultObjs = [];
     try {
-      const result = await cc.getResource({
+      const result2 = await cc.getResource({
         TypeName: typeName,
         Identifier: exactIdentifier
       });
-      const id = result.ResourceDescription?.Identifier ?? "";
+      const id = result2.ResourceDescription?.Identifier ?? "";
       if (id !== "") {
-        const propsObject = JSON.parse(result.ResourceDescription?.Properties ?? "");
-        const propsObj = getResultObj(propsObject, result.ResourceDescription?.Identifier, propertiesToReturn);
+        const propsObject = JSON.parse(result2.ResourceDescription?.Properties ?? "");
+        const propsObj = getResultObj(propsObject, result2.ResourceDescription?.Identifier, propertiesToReturn);
         resultObjs.push(propsObj);
       } else {
         throw new ContextProviderError(`Could not get resource ${exactIdentifier}.`);
@@ -8427,10 +9291,10 @@ var CcApiContextProviderPlugin = class {
   async listResources(cc, typeName, propertyMatch, propertiesToReturn) {
     const resultObjs = [];
     try {
-      const result = await cc.listResources({
+      const result2 = await cc.listResources({
         TypeName: typeName
       });
-      result.ResourceDescriptions?.forEach((resource) => {
+      result2.ResourceDescriptions?.forEach((resource) => {
         const id = resource.Identifier ?? "";
         if (id !== "") {
           const propsObject = JSON.parse(resource.Properties ?? "");
@@ -8470,17 +9334,17 @@ var EndpointServiceAZContextProviderPlugin = class {
     const region = args.region;
     const account = args.account;
     const serviceName = args.serviceName;
-    debug(`Reading AZs for ${account}:${region}:${serviceName}`);
+    debug2(`Reading AZs for ${account}:${region}:${serviceName}`);
     const ec2 = (await initContextProviderSdk(this.aws, args)).ec2();
     const response = await ec2.describeVpcEndpointServices({
       ServiceNames: [serviceName]
     });
     if (!response.ServiceDetails || response.ServiceDetails.length === 0) {
-      debug(`Could not retrieve service details for ${account}:${region}:${serviceName}`);
+      debug2(`Could not retrieve service details for ${account}:${region}:${serviceName}`);
       return [];
     }
     const azs = response.ServiceDetails[0].AvailabilityZones;
-    debug(`Endpoint service ${account}:${region}:${serviceName} is available in availability zones ${azs}`);
+    debug2(`Endpoint service ${account}:${region}:${serviceName} is available in availability zones ${azs}`);
     return azs;
   }
 };
@@ -8497,7 +9361,7 @@ var HostedZoneContextProviderPlugin = class {
       throw new ContextProviderError(`HostedZoneProvider requires domainName property to be set in ${args}`);
     }
     const domainName = args.domainName;
-    debug(`Reading hosted zone ${account}:${region}:${domainName}`);
+    debug2(`Reading hosted zone ${account}:${region}:${domainName}`);
     const r53 = (await initContextProviderSdk(this.aws, args)).route53();
     const response = await r53.listHostedZonesByName({ DNSName: domainName });
     if (!response.HostedZones) {
@@ -8516,9 +9380,9 @@ var HostedZoneContextProviderPlugin = class {
   async filterZones(r53, zones, props) {
     let candidates = [];
     const domainName = props.domainName.endsWith(".") ? props.domainName : `${props.domainName}.`;
-    debug(`Found the following zones ${JSON.stringify(zones)}`);
+    debug2(`Found the following zones ${JSON.stringify(zones)}`);
     candidates = zones.filter((zone) => zone.Name === domainName);
-    debug(`Found the following matched name zones ${JSON.stringify(candidates)}`);
+    debug2(`Found the following matched name zones ${JSON.stringify(candidates)}`);
     if (props.privateZone) {
       candidates = candidates.filter((zone) => zone.Config && zone.Config.PrivateZone);
     } else {
@@ -8529,7 +9393,7 @@ var HostedZoneContextProviderPlugin = class {
       for (const zone of candidates) {
         const data = await r53.getHostedZone({ Id: zone.Id });
         if (!data.VPCs) {
-          debug(`Expected VPC for private zone but no VPC found ${zone.Id}`);
+          debug2(`Expected VPC for private zone but no VPC found ${zone.Id}`);
           continue;
         }
         if (data.VPCs.map((vpc) => vpc.VPCId).includes(props.vpcId)) {
@@ -8557,7 +9421,7 @@ var KeyContextProviderPlugin = class {
   }
   // TODO: use paginator function
   async findKey(kms, args) {
-    debug(`Listing keys in ${args.account}:${args.region}`);
+    debug2(`Listing keys in ${args.account}:${args.region}`);
     let response;
     let nextMarker;
     do {
@@ -8584,7 +9448,7 @@ var KeyContextProviderPlugin = class {
     if (!alias.TargetKeyId) {
       throw new ContextProviderError(`Could not find any key with alias named ${args.aliasName}`);
     }
-    debug(`Key found ${alias.TargetKeyId}`);
+    debug2(`Key found ${alias.TargetKeyId}`);
     return {
       keyId: alias.TargetKeyId
     };
@@ -8592,7 +9456,7 @@ var KeyContextProviderPlugin = class {
 };
 
 // ../../aws-cdk/lib/context-providers/load-balancers.ts
-var import_cx_api6 = require("@aws-cdk/cx-api");
+var import_cx_api7 = require("@aws-cdk/cx-api");
 var LoadBalancerContextProviderPlugin = class {
   constructor(aws) {
     this.aws = aws;
@@ -8602,7 +9466,7 @@ var LoadBalancerContextProviderPlugin = class {
       throw new ContextProviderError("The load balancer lookup query must specify either `loadBalancerArn` or `loadBalancerTags`");
     }
     const loadBalancer = await (await LoadBalancerProvider.getClient(this.aws, query)).getLoadBalancer();
-    const ipAddressType = loadBalancer.IpAddressType === "ipv4" ? import_cx_api6.LoadBalancerIpAddressType.IPV4 : import_cx_api6.LoadBalancerIpAddressType.DUAL_STACK;
+    const ipAddressType = loadBalancer.IpAddressType === "ipv4" ? import_cx_api7.LoadBalancerIpAddressType.IPV4 : import_cx_api7.LoadBalancerIpAddressType.DUAL_STACK;
     return {
       loadBalancerArn: loadBalancer.LoadBalancerArn,
       loadBalancerCanonicalHostedZoneId: loadBalancer.CanonicalHostedZoneId,
@@ -8812,7 +9676,7 @@ var SSMContextProviderPlugin = class {
       throw new ContextProviderError("parameterName must be provided in props for SSMContextProviderPlugin");
     }
     const parameterName = args.parameterName;
-    debug(`Reading SSM parameter ${account}:${region}:${parameterName}`);
+    debug2(`Reading SSM parameter ${account}:${region}:${parameterName}`);
     const response = await this.getSsmParameterValue(args);
     const parameterNotFound = !response.Parameter || response.Parameter.Value === void 0;
     const suppressError = "ignoreErrorOnMissingContext" in args && args.ignoreErrorOnMissingContext;
@@ -8849,7 +9713,7 @@ var SSMContextProviderPlugin = class {
 };
 
 // ../../aws-cdk/lib/context-providers/vpcs.ts
-var import_cx_api7 = require("@aws-cdk/cx-api");
+var import_cx_api8 = require("@aws-cdk/cx-api");
 var VpcNetworkContextProviderPlugin = class {
   constructor(aws) {
     this.aws = aws;
@@ -8861,7 +9725,7 @@ var VpcNetworkContextProviderPlugin = class {
   }
   async findVpc(ec2, args) {
     const filters = Object.entries(args.filter).map(([tag, value]) => ({ Name: tag, Values: [value] }));
-    debug(`Listing VPCs in ${args.account}:${args.region}`);
+    debug2(`Listing VPCs in ${args.account}:${args.region}`);
     const response = await ec2.describeVpcs({ Filters: filters });
     const vpcs = response.Vpcs || [];
     if (vpcs.length === 0) {
@@ -8874,7 +9738,7 @@ var VpcNetworkContextProviderPlugin = class {
   }
   async readVpcProps(ec2, vpc, args) {
     const vpcId = vpc.VpcId;
-    debug(`Describing VPC ${vpcId}`);
+    debug2(`Describing VPC ${vpcId}`);
     const filters = { Filters: [{ Name: "vpc-id", Values: [vpcId] }] };
     const subnetsResponse = await ec2.describeSubnets(filters);
     const listedSubnets = subnetsResponse.Subnets || [];
@@ -9086,11 +9950,11 @@ function groupAsymmetricSubnets(subnets) {
 function subnetTypeToVpcSubnetType(type) {
   switch (type) {
     case "Isolated" /* Isolated */:
-      return import_cx_api7.VpcSubnetGroupType.ISOLATED;
+      return import_cx_api8.VpcSubnetGroupType.ISOLATED;
     case "Private" /* Private */:
-      return import_cx_api7.VpcSubnetGroupType.PRIVATE;
+      return import_cx_api8.VpcSubnetGroupType.PRIVATE;
     case "Public" /* Public */:
-      return import_cx_api7.VpcSubnetGroupType.PUBLIC;
+      return import_cx_api8.VpcSubnetGroupType.PUBLIC;
   }
 }
 function isValidSubnetType(val) {
@@ -9156,7 +10020,7 @@ async function provideContextValues(missingValues, context, sdk) {
       value = { [cxapi4.PROVIDER_ERROR_KEY]: formatErrorMessage(e), [TRANSIENT_CONTEXT_KEY]: true };
     }
     context.set(key, value);
-    debug(`Setting "${key}" context to ${JSON.stringify(value)}`);
+    debug2(`Setting "${key}" context to ${JSON.stringify(value)}`);
   }
 }
 function registerContextProvider(name, provider) {
@@ -9184,13 +10048,13 @@ var availableContextProviders = {
 
 // ../../aws-cdk/lib/api/util/rwlock.ts
 var import_fs = require("fs");
-var path10 = __toESM(require("path"));
+var path13 = __toESM(require("path"));
 var RWLock = class {
   constructor(directory) {
     this.directory = directory;
     this.readCounter = 0;
     this.pidString = `${process.pid}`;
-    this.writerFile = path10.join(this.directory, "synth.lock");
+    this.writerFile = path13.join(this.directory, "synth.lock");
   }
   /**
    * Acquire a writer lock.
@@ -9232,7 +10096,7 @@ var RWLock = class {
    * is incremented "atomically" from the point of view of this PID.).
    */
   readerFile() {
-    return path10.join(this.directory, `read.${this.pidString}.${++this.readCounter}.lock`);
+    return path13.join(this.directory, `read.${this.pidString}.${++this.readCounter}.lock`);
   }
   /**
    * Do the actual acquiring of a read lock.
@@ -9289,7 +10153,7 @@ var RWLock = class {
         if (processExists(pid)) {
           ret.push(pid);
         } else {
-          await deleteFile(path10.join(this.directory, fname));
+          await deleteFile(path13.join(this.directory, fname));
         }
       }
     }
@@ -9308,7 +10172,7 @@ async function readFileIfExists(filename) {
 }
 var tmpCounter = 0;
 async function writeFileAtomic(filename, contents) {
-  await import_fs.promises.mkdir(path10.dirname(filename), { recursive: true });
+  await import_fs.promises.mkdir(path13.dirname(filename), { recursive: true });
   const tmpFile = `${filename}.${process.pid}_${++tmpCounter}`;
   await import_fs.promises.writeFile(tmpFile, contents, { encoding: "utf-8" });
   await import_fs.promises.rename(tmpFile, filename);
@@ -9333,7 +10197,7 @@ function processExists(pid) {
 }
 
 // ../../aws-cdk/lib/api/cxapp/cloud-assembly.ts
-var import_cx_api8 = require("@aws-cdk/cx-api");
+var import_cx_api9 = require("@aws-cdk/cx-api");
 var chalk16 = __toESM(require("chalk"));
 var import_minimatch = require("minimatch");
 var semver5 = __toESM(require("semver"));
@@ -9494,36 +10358,36 @@ var StackCollection = class _StackCollection {
     let warnings = false;
     let errors = false;
     for (const stack of this.stackArtifacts) {
-      for (const message of stack.messages) {
-        switch (message.level) {
-          case import_cx_api8.SynthesisMessageLevel.WARNING:
+      for (const message2 of stack.messages) {
+        switch (message2.level) {
+          case import_cx_api9.SynthesisMessageLevel.WARNING:
             warnings = true;
-            await logger("warn", message);
+            await logger("warn", message2);
             break;
-          case import_cx_api8.SynthesisMessageLevel.ERROR:
+          case import_cx_api9.SynthesisMessageLevel.ERROR:
             errors = true;
-            await logger("error", message);
+            await logger("error", message2);
             break;
-          case import_cx_api8.SynthesisMessageLevel.INFO:
-            await logger("info", message);
+          case import_cx_api9.SynthesisMessageLevel.INFO:
+            await logger("info", message2);
             break;
         }
       }
     }
     if (errors && failAt != "none") {
-      throw new AssemblyError("Found errors");
+      throw AssemblyError.withStacks("Found errors", this.stackArtifacts);
     }
     if (warnings && failAt === "warn") {
-      throw new AssemblyError("Found warnings (--strict mode)");
+      throw AssemblyError.withStacks("Found warnings (--strict mode)", this.stackArtifacts);
     }
   }
 };
 function indexByHierarchicalId(stacks) {
-  const result = /* @__PURE__ */ new Map();
+  const result2 = /* @__PURE__ */ new Map();
   for (const stack of stacks) {
-    result.set(stack.hierarchicalId, stack);
+    result2.set(stack.hierarchicalId, stack);
   }
-  return result;
+  return result2;
 }
 function includeDownstreamStacks(selectedStacks, allStacks) {
   const added = new Array();
@@ -9539,7 +10403,7 @@ function includeDownstreamStacks(selectedStacks, allStacks) {
     }
   } while (madeProgress);
   if (added.length > 0) {
-    info("Including depending stacks: %s", chalk16.bold(added.join(", ")));
+    info2("Including depending stacks: %s", chalk16.bold(added.join(", ")));
   }
 }
 function includeUpstreamStacks(selectedStacks, allStacks) {
@@ -9558,7 +10422,7 @@ function includeUpstreamStacks(selectedStacks, allStacks) {
     }
   }
   if (added.length > 0) {
-    info("Including dependency stacks: %s", chalk16.bold(added.join(", ")));
+    info2("Including dependency stacks: %s", chalk16.bold(added.join(", ")));
   }
 }
 function sanitizePatterns(patterns) {
@@ -9568,12 +10432,12 @@ function sanitizePatterns(patterns) {
 }
 
 // ../../aws-cdk/lib/api/cxapp/exec.ts
-var path11 = __toESM(require("path"));
+var path14 = __toESM(require("path"));
 var cxschema4 = __toESM(require("@aws-cdk/cloud-assembly-schema"));
 var cxapi5 = __toESM(require("@aws-cdk/cx-api"));
-var fs14 = __toESM(require("fs-extra"));
+var fs16 = __toESM(require("fs-extra"));
 var semver6 = __toESM(require("semver"));
-async function prepareDefaultEnvironment(aws, logFn = debug) {
+async function prepareDefaultEnvironment(aws, logFn = debug2) {
   const env = {};
   env[cxapi5.DEFAULT_REGION_ENV] = aws.defaultRegion;
   await logFn(`Setting "${cxapi5.DEFAULT_REGION_ENV}" environment variable to`, env[cxapi5.DEFAULT_REGION_ENV]);
@@ -9610,7 +10474,7 @@ async function prepareContext(settings, context, env) {
   }
   const bundlingStacks = settings.get(["bundlingStacks"]) ?? ["**"];
   context[cxapi5.BUNDLING_STACKS] = bundlingStacks;
-  debug("context:", context);
+  debug2("context:", context);
   return context;
 }
 function appToArray(app) {
@@ -9627,14 +10491,14 @@ async function guessExecutable(app) {
   if (commandLine.length === 1) {
     let fstat;
     try {
-      fstat = await fs14.stat(commandLine[0]);
+      fstat = await fs16.stat(commandLine[0]);
     } catch {
-      debug(`Not a file: '${commandLine[0]}'. Using '${commandLine}' as command-line`);
+      debug2(`Not a file: '${commandLine[0]}'. Using '${commandLine}' as command-line`);
       return commandLine;
     }
-    const isExecutable = (fstat.mode & fs14.constants.X_OK) !== 0;
+    const isExecutable = (fstat.mode & fs16.constants.X_OK) !== 0;
     const isWindows = process.platform === "win32";
-    const handler = EXTENSION_MAP.get(path11.extname(commandLine[0]));
+    const handler = EXTENSION_MAP.get(path14.extname(commandLine[0]));
     if (handler && (!isExecutable || isWindows)) {
       return handler(commandLine[0]);
     }
@@ -9648,6 +10512,7 @@ function spaceAvailableForContext(env, limit) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  Bootstrapper,
   CliIoHost,
   CloudAssembly,
   CloudWatchLogEventMonitor,
@@ -9667,21 +10532,14 @@ function spaceAvailableForContext(env, limit) {
   WorkGraphBuilder,
   contextproviders,
   findCloudWatchLogGroups,
-  formatErrorMessage,
-  formatSdkLoggerContent,
-  formatTime,
   guessExecutable,
   loadTree,
-  obscureTemplate,
   prepareContext,
   prepareDefaultEnvironment,
   sanitizePatterns,
-  serializeStructure,
   some,
   spaceAvailableForContext,
-  splitBySize,
   tagsForStack,
-  validateSnsTopicArn,
   versionNumber
 });
 //# sourceMappingURL=aws-cdk.js.map