@aws-cdk/toolkit-lib 0.1.4 → 0.1.6

package/lib/api/aws-cdk.js

@@ -27,12 +27,12 @@ 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
@@ -58,7 +58,6 @@ __export(aws_cdk_exports, {
   WorkGraphBuilder: () => WorkGraphBuilder,
   contextproviders: () => context_providers_exports,
   findCloudWatchLogGroups: () => findCloudWatchLogGroups,
-  formatSdkLoggerContent: () => formatSdkLoggerContent,
   guessExecutable: () => guessExecutable,
   loadTree: () => loadTree,
   prepareContext: () => prepareContext,
@@ -99,19 +98,19 @@ var path2 = __toESM(require("path"));
 var fs3 = __toESM(require("fs-extra"));
 
 // ../../aws-cdk/lib/logging.ts
-var util4 = __toESM(require("util"));
 var chalk4 = __toESM(require("chalk"));
 
 // ../../aws-cdk/lib/toolkit/cli-io-host.ts
-var util3 = __toESM(require("node:util"));
+var util5 = __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.
@@ -141,46 +140,92 @@ 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 });
   }
 };
 
+// ../tmp-toolkit-helpers/src/api/io/private/span.ts
+var util = __toESM(require("node:util"));
+var uuid = __toESM(require("uuid"));
+
 // ../tmp-toolkit-helpers/src/util/archive.ts
 var glob = __toESM(require("glob"));
 
 // ../tmp-toolkit-helpers/src/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");
+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";
 }
 
 // ../tmp-toolkit-helpers/src/util/archive.ts
@@ -194,18 +239,6 @@ function flatten(xs) {
   return Array.prototype.concat.apply([], xs);
 }
 
-// ../tmp-toolkit-helpers/src/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]}`;
-}
-
 // ../tmp-toolkit-helpers/src/util/cloudformation.ts
 function stackEventHasErrorMessage(status) {
   return status.endsWith("_FAILED") || status === "ROLLBACK_IN_PROGRESS" || status === "UPDATE_ROLLBACK_IN_PROGRESS";
@@ -368,6 +401,9 @@ function deepSet(x, path15, value) {
   }
   while (path15.length > 1 && isObject(x)) {
     const key = path15.shift();
+    if (isPrototypePollutingKey(key)) {
+      continue;
+    }
     if (!(key in x)) {
       x[key] = {};
     }
@@ -376,16 +412,23 @@ function deepSet(x, path15, value) {
   if (!isObject(x)) {
     throw new ToolkitError(`Expected an object, got '${x}'`);
   }
+  const finalKey = path15[0];
+  if (isPrototypePollutingKey(finalKey)) {
+    return;
+  }
   if (value !== void 0) {
-    x[path15[0]] = value;
+    x[finalKey] = value;
   } else {
-    delete x[path15[0]];
+    delete x[finalKey];
   }
 }
+function isPrototypePollutingKey(key) {
+  return key === "__proto__" || key === "constructor" || key === "prototype";
+}
 function deepMerge(...objects) {
   function mergeOne(target, source) {
     for (const key of Object.keys(source)) {
-      if (key === "__proto__" || key === "constructor") {
+      if (isPrototypePollutingKey(key)) {
         continue;
       }
       const value = source[key];
@@ -412,20 +455,20 @@ function deepMerge(...objects) {
 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);
@@ -434,10 +477,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();
@@ -524,15 +567,6 @@ async function loadStructuredFile(fileName) {
   const contents = await fs2.readFile(fileName, { encoding: "utf-8" });
   return deserializeStructure(contents);
 }
-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;
-}
 
 // ../tmp-toolkit-helpers/src/util/string-manipulation.ts
 function padLeft(n, x, char = " ") {
@@ -554,6 +588,669 @@ function millisecondsToSeconds(num) {
 // ../tmp-toolkit-helpers/src/util/version-range.ts
 var semver = __toESM(require("semver"));
 
+// ../tmp-toolkit-helpers/src/api/io/private/span.ts
+var SpanMaker = class {
+  definition;
+  ioHelper;
+  constructor(ioHelper, definition) {
+    this.definition = definition;
+    this.ioHelper = ioHelper;
+  }
+  async begin(a, b) {
+    const spanId = uuid.v4();
+    const startTime = (/* @__PURE__ */ new Date()).getTime();
+    const notify = (msg) => {
+      return this.ioHelper.notify(withSpanId(spanId, msg));
+    };
+    const startInput = parseArgs(a, b);
+    const startMsg = startInput.message ?? `Starting ${this.definition.name} ...`;
+    const startPayload = startInput.payload;
+    await notify(this.definition.start.msg(
+      startMsg,
+      startPayload
+    ));
+    const timingMsgTemplate = "\n\u2728  %s time: %ds\n";
+    const time = () => {
+      const elapsedTime = (/* @__PURE__ */ new Date()).getTime() - startTime;
+      return {
+        asMs: elapsedTime,
+        asSec: formatTime(elapsedTime)
+      };
+    };
+    return {
+      elapsedTime: async () => {
+        return time();
+      },
+      notify: async (msg) => {
+        await notify(msg);
+      },
+      timing: async (maker, message2) => {
+        const duration = time();
+        const timingMsg = message2 ? message2 : util.format(timingMsgTemplate, this.definition.name, duration.asSec);
+        await notify(maker.msg(timingMsg, {
+          duration: duration.asMs
+        }));
+        return duration;
+      },
+      end: async (x, y) => {
+        const duration = time();
+        const endInput = parseArgs(x, y);
+        const endMsg = endInput.message ?? util.format(timingMsgTemplate, this.definition.name, duration.asSec);
+        const endPayload = endInput.payload;
+        await notify(this.definition.end.msg(
+          endMsg,
+          {
+            duration: duration.asMs,
+            ...endPayload
+          }
+        ));
+        return duration;
+      }
+    };
+  }
+};
+function parseArgs(first, second) {
+  const firstIsMessage = typeof first === "string";
+  const message2 = firstIsMessage || second ? first : void 0;
+  const payload = firstIsMessage || second ? second : first;
+  return {
+    message: message2,
+    payload
+  };
+}
+function withSpanId(span, message2) {
+  return {
+    ...message2,
+    span
+  };
+}
+
+// ../tmp-toolkit-helpers/src/api/io/private/io-helper.ts
+var IoHelper = class _IoHelper {
+  static fromIoHost(ioHost, action) {
+    return new _IoHelper(ioHost, action);
+  }
+  ioHost;
+  action;
+  constructor(ioHost, action) {
+    this.ioHost = ioHost;
+    this.action = action;
+  }
+  /**
+   * Forward a message to the IoHost, while injection the current action
+   */
+  notify(msg) {
+    return this.ioHost.notify({
+      ...msg,
+      action: this.action
+    });
+  }
+  /**
+   * Forward a request to the IoHost, while injection the current action
+   */
+  requestResponse(msg) {
+    return this.ioHost.requestResponse({
+      ...msg,
+      action: this.action
+    });
+  }
+  /**
+   * Create a new marker from a given registry entry
+   */
+  span(definition) {
+    return new SpanMaker(this, definition);
+  }
+};
+function asIoHelper(ioHost, action) {
+  return IoHelper.fromIoHost(ioHost, action);
+}
+
+// ../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 (0000)
+  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"
+  }),
+  DEFAULT_TOOLKIT_ERROR: error({
+    code: "CDK_TOOLKIT_E0000",
+    description: "Default error messages emitted from the Toolkit"
+  }),
+  DEFAULT_TOOLKIT_TRACE: trace({
+    code: "CDK_TOOLKIT_I0000",
+    description: "Default trace messages emitted from the Toolkit"
+  }),
+  // 1: Synth (1xxx)
+  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 (2xxx)
+  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 (4xxx)
+  // 5: Deploy & Watch (5xxx)
+  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 (52xx)
+  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 (53xx)
+  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"
+  }),
+  // Hotswap (54xx)
+  CDK_TOOLKIT_I5400: trace({
+    code: "CDK_TOOLKIT_I5400",
+    description: "Starting a hotswap deployment",
+    interface: "HotswapDeployment"
+  }),
+  CDK_TOOLKIT_I5410: info({
+    code: "CDK_TOOLKIT_I5410",
+    description: "Hotswap deployment has ended, a full deployment might still follow if needed",
+    interface: "Duration"
+  }),
+  // Stack Monitor (55xx)
+  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 (59xx)
+  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 (6xxx)
+  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 (7xxx)
+  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 (9xxx)
+  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"
+  }),
+  // Notices
+  CDK_TOOLKIT_I0100: info({
+    code: "CDK_TOOLKIT_I0100",
+    description: "Notices decoration (the header or footer of a list of notices)"
+  }),
+  CDK_TOOLKIT_W0101: warn({
+    code: "CDK_TOOLKIT_W0101",
+    description: "A notice that is marked as a warning"
+  }),
+  CDK_TOOLKIT_E0101: error({
+    code: "CDK_TOOLKIT_E0101",
+    description: "A notice that is marked as an error"
+  }),
+  CDK_TOOLKIT_I0101: info({
+    code: "CDK_TOOLKIT_I0101",
+    description: "A notice that is marked as informational"
+  }),
+  // 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
+  },
+  HOTSWAP: {
+    name: "hotswap-deployment",
+    start: IO.CDK_TOOLKIT_I5400,
+    end: IO.CDK_TOOLKIT_I5410
+  }
+};
+
+// ../tmp-toolkit-helpers/src/api/io/private/io-default-messages.ts
+var util2 = __toESM(require("util"));
+var IoDefaultMessages = class {
+  constructor(ioHelper) {
+    this.ioHelper = ioHelper;
+  }
+  notify(msg) {
+    return this.ioHelper.notify(msg);
+  }
+  requestResponse(msg) {
+    return this.ioHelper.requestResponse(msg);
+  }
+  error(input, ...args) {
+    this.emitMessage(IO.DEFAULT_TOOLKIT_ERROR, input, ...args);
+  }
+  warn(input, ...args) {
+    this.emitMessage(IO.DEFAULT_TOOLKIT_WARN, input, ...args);
+  }
+  warning(input, ...args) {
+    this.emitMessage(IO.DEFAULT_TOOLKIT_WARN, input, ...args);
+  }
+  info(input, ...args) {
+    this.emitMessage(IO.DEFAULT_TOOLKIT_INFO, input, ...args);
+  }
+  debug(input, ...args) {
+    this.emitMessage(IO.DEFAULT_TOOLKIT_DEBUG, input, ...args);
+  }
+  trace(input, ...args) {
+    this.emitMessage(IO.DEFAULT_TOOLKIT_TRACE, input, ...args);
+  }
+  result(input, ...args) {
+    const message2 = args.length > 0 ? util2.format(input, ...args) : input;
+    void this.ioHelper.notify({
+      time: /* @__PURE__ */ new Date(),
+      code: IO.DEFAULT_TOOLKIT_INFO.code,
+      level: "result",
+      message: message2,
+      data: void 0
+    });
+  }
+  emitMessage(maker, input, ...args) {
+    const message2 = args.length > 0 ? util2.format(input, ...args) : input;
+    void this.ioHelper.notify(maker.msg(message2));
+  }
+};
+
 // ../../aws-cdk/lib/cli/activity-printer/base.ts
 var ActivityPrinterBase = class {
   constructor(props) {
@@ -581,14 +1278,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:
@@ -659,7 +1356,7 @@ var ActivityPrinterBase = class {
 };
 
 // ../../aws-cdk/lib/cli/activity-printer/history.ts
-var util = __toESM(require("util"));
+var util3 = __toESM(require("util"));
 var chalk = __toESM(require("chalk"));
 var HistoryActivityPrinter = class _HistoryActivityPrinter extends ActivityPrinterBase {
   constructor(props) {
@@ -719,7 +1416,7 @@ var HistoryActivityPrinter = class _HistoryActivityPrinter extends ActivityPrint
     const resourceName = metadata ? metadata.constructPath : event.LogicalResourceId || "";
     const logicalId = resourceName !== event.LogicalResourceId ? `(${event.LogicalResourceId}) ` : "";
     this.stream.write(
-      util.format(
+      util3.format(
         "%s | %s%s | %s | %s | %s %s%s%s\n",
         event.StackName,
         progress !== false ? `${activity.progress.formatted} | ` : "",
@@ -744,7 +1441,7 @@ var HistoryActivityPrinter = class _HistoryActivityPrinter extends ActivityPrint
     }
     if (Object.keys(this.resourcesInProgress).length > 0) {
       this.stream.write(
-        util.format(
+        util3.format(
           "%s Currently in progress: %s\n",
           progress,
           chalk.bold(Object.keys(this.resourcesInProgress).join(", "))
@@ -771,7 +1468,7 @@ function colorFromStatusResult(status) {
 }
 
 // ../../aws-cdk/lib/cli/activity-printer/current.ts
-var util2 = __toESM(require("util"));
+var util4 = __toESM(require("util"));
 var chalk2 = __toESM(require("chalk"));
 
 // ../../aws-cdk/lib/cli/activity-printer/display.ts
@@ -855,7 +1552,7 @@ var CurrentActivityPrinter = class _CurrentActivityPrinter extends ActivityPrint
       ...toPrint.map((res) => {
         const color = colorFromStatusActivity(res.event.ResourceStatus);
         const resourceName = res.metadata?.constructPath ?? res.event.LogicalResourceId ?? "";
-        return util2.format(
+        return util4.format(
           "%s | %s | %s | %s%s",
           padLeft(_CurrentActivityPrinter.TIMESTAMP_WIDTH, new Date(res.event.Timestamp).toLocaleTimeString()),
           color(padRight(_CurrentActivityPrinter.STATUS_WIDTH, (res.event.ResourceStatus || "").slice(0, _CurrentActivityPrinter.STATUS_WIDTH))),
@@ -875,7 +1572,7 @@ var CurrentActivityPrinter = class _CurrentActivityPrinter extends ActivityPrint
         continue;
       }
       lines.push(
-        util2.format(
+        util4.format(
           chalk2.red("%s | %s | %s | %s%s") + "\n",
           padLeft(_CurrentActivityPrinter.TIMESTAMP_WIDTH, new Date(failure.event.Timestamp).toLocaleTimeString()),
           padRight(_CurrentActivityPrinter.STATUS_WIDTH, (failure.event.ResourceStatus || "").slice(0, _CurrentActivityPrinter.STATUS_WIDTH)),
@@ -884,9 +1581,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	\\_ ")}
 `));
       }
     }
@@ -944,24 +1641,24 @@ 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 = {}) {
+    /**
+     * Configure the target stream for notices
+     *
+     * (Not a setter because there's no need for additional logic when this value
+     * is changed yet)
+     */
+    this.noticesDestination = "stderr";
     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 */;
   }
   /**
@@ -997,7 +1694,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 */;
     }
@@ -1011,60 +1708,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).
@@ -1102,7 +1745,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) {
@@ -1110,8 +1753,8 @@ var CliIoHost = class _CliIoHost {
       return;
     }
     const output = this.formatMessage(msg);
-    const stream = this.selectStream(msg.level);
-    stream.write(output);
+    const stream = this.selectStream(msg);
+    stream?.write(output);
   }
   /**
    * Detect stack activity messages so they can be send to the printer.
@@ -1123,10 +1766,40 @@ 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 and configuration.
+   */
+  selectStream(msg) {
+    if (isNoticesMessage(msg)) {
+      return targetStreamObject(this.noticesDestination);
+    }
+    return this.selectStreamFromLevel(msg.level);
+  }
   /**
    * Determines the output stream, based on message level and configuration.
    */
-  selectStream(level) {
+  selectStreamFromLevel(level) {
     switch (level) {
       case "error":
         return process.stderr;
@@ -1160,6 +1833,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) {
@@ -1179,7 +1855,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";
   }
   /**
@@ -1194,7 +1870,7 @@ var CliIoHost = class _CliIoHost {
    */
   makeActivityPrinter() {
     const props = {
-      stream: this.selectStream("info")
+      stream: this.selectStreamFromLevel("info")
     };
     switch (this.stackProgress) {
       case "events" /* EVENTS */:
@@ -1213,7 +1889,7 @@ function isConfirmationPrompt(msg) {
 function extractPromptInfo(msg) {
   const isNumber = typeof msg.defaultResponse === "number";
   return {
-    default: util3.format(msg.defaultResponse),
+    default: util5.format(msg.defaultResponse),
     convertAnswer: isNumber ? (v) => Number(v) : (v) => String(v)
   };
 }
@@ -1228,40 +1904,50 @@ var styleMap = {
 function isCI() {
   return process.env.CI !== void 0 && process.env.CI !== "false" && process.env.CI !== "0";
 }
+function targetStreamObject(x) {
+  switch (x) {
+    case "stderr":
+      return process.stderr;
+    case "stdout":
+      return process.stdout;
+    case "drop":
+      return void 0;
+  }
+}
+function isNoticesMessage(msg) {
+  return IO.CDK_TOOLKIT_I0100.is(msg) || IO.CDK_TOOLKIT_W0101.is(msg) || IO.CDK_TOOLKIT_E0101.is(msg) || IO.CDK_TOOLKIT_I0101.is(msg);
+}
 
 // ../../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 finalMessage = style ? style(formattedMessage) : formattedMessage;
-  const ioHost = CliIoHost.instance();
-  const ioMessage = {
-    time: /* @__PURE__ */ new Date(),
-    action: ioHost.currentAction,
-    level,
-    message: finalMessage,
-    code
-  };
-  void ioHost.notify(ioMessage);
-}
-function getDefaultCode(level, category = "TOOLKIT") {
-  const levelIndicator = level === "error" ? "E" : level === "warn" ? "W" : "I";
-  return `CDK_${category}_${levelIndicator}0000`;
+function formatMessageAndLog(level, input, ...args) {
+  const singletonHost = CliIoHost.instance();
+  const helper = asIoHelper(singletonHost, singletonHost.currentAction);
+  if (typeof input === "string") {
+    const messages = new IoDefaultMessages(helper);
+    messages[level](input, ...args);
+  } else {
+    void helper.notify({
+      data: void 0,
+      time: /* @__PURE__ */ new Date(),
+      level,
+      ...input
+    });
+  }
 }
-var error = (input, ...args) => {
-  return formatMessageAndLog("error", input, void 0, ...args);
+var error2 = (input, ...args) => {
+  return formatMessageAndLog("error", input, ...args);
 };
 var warning = (input, ...args) => {
-  return formatMessageAndLog("warn", input, void 0, ...args);
+  return formatMessageAndLog("warn", input, ...args);
 };
-var info = (input, ...args) => {
-  return formatMessageAndLog("info", input, void 0, ...args);
+var info2 = (input, ...args) => {
+  return formatMessageAndLog("info", input, ...args);
 };
-var debug = (input, ...args) => {
-  return formatMessageAndLog("debug", input, void 0, ...args);
+var debug2 = (input, ...args) => {
+  return formatMessageAndLog("debug", input, ...args);
 };
-var trace = (input, ...args) => {
-  return formatMessageAndLog("trace", input, void 0, ...args);
+var trace2 = (input, ...args) => {
+  return formatMessageAndLog("trace", input, ...args);
 };
 
 // ../../aws-cdk/lib/api/aws-auth/account-cache.ts
@@ -1292,7 +1978,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();
@@ -1408,7 +2094,7 @@ function readIfPossible(filename) {
     }
     return fs4.readFileSync(filename, { encoding: "utf-8" });
   } catch (e) {
-    debug(e);
+    debug2(e);
     return void 0;
   }
 }
@@ -1721,19 +2407,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 };
       });
@@ -1858,7 +2544,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;
@@ -1876,7 +2562,7 @@ function getRegionFromIniFile(profile, data) {
 function tryGetCACert(bundlePath) {
   const path15 = bundlePath || caBundlePathFromEnvironment();
   if (path15) {
-    debug("Using CA bundle path: %s", path15);
+    debug2("Using CA bundle path: %s", path15);
     return readIfPossible(path15);
   }
   return void 0;
@@ -1905,7 +2591,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: {
@@ -1916,20 +2602,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;
@@ -1937,10 +2623,10 @@ async function tokenCodeFn(serialArn) {
 }
 
 // ../../aws-cdk/lib/api/aws-auth/credential-plugins.ts
-var import_util10 = require("util");
+var import_util11 = require("util");
 
 // ../../aws-cdk/lib/api/plugin/plugin.ts
-var import_util9 = require("util");
+var import_util10 = require("util");
 var chalk5 = __toESM(require("chalk"));
 
 // ../../aws-cdk/lib/api/plugin/context-provider-plugin.ts
@@ -1974,14 +2660,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) {
@@ -2030,7 +2716,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_util9.inspect)(provider)}`);
+      throw new ToolkitError(`Object you gave me does not look like a ContextProviderPlugin: ${(0, import_util10.inspect)(provider)}`);
     }
     this.contextProviderPlugins[pluginProviderName] = provider;
   }
@@ -2063,7 +2749,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);
@@ -2077,7 +2763,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
@@ -2099,7 +2785,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_util10.inspect)(initial)}`);
+    throw new AuthenticationError(`Plugin returned a value that doesn't resemble AWS credentials: ${(0, import_util11.inspect)(initial)}`);
   }
 }
 function v3ProviderFromV2Credentials(x) {
@@ -2118,7 +2804,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_util10.inspect)(newCreds)}`);
+        throw new AuthenticationError(`Plugin initially returned static V3 credentials but now returned something else: ${(0, import_util11.inspect)(newCreds)}`);
       }
       current = newCreds;
     }
@@ -2195,8 +2881,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.`
         );
@@ -2269,7 +2955,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;
       }
     });
@@ -2316,7 +3002,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 {
@@ -2343,7 +3029,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",
@@ -2406,42 +3092,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_util13 = 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_util13.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"));
@@ -2673,7 +3323,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
@@ -2683,56 +3332,50 @@ 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 util7 = __toESM(require("util"));
+var uuid2 = __toESM(require("uuid"));
 
 // ../../aws-cdk/lib/api/stack-events/stack-event-poller.ts
 var StackEventPoller = class _StackEventPoller {
@@ -2844,8 +3487,37 @@ function isStackTerminalState(state) {
   return !(state ?? "").endsWith("_IN_PROGRESS");
 }
 
+// ../tmp-toolkit-helpers/src/api/resource-metadata/resource-metadata.ts
+var import_cloud_assembly_schema2 = require("@aws-cdk/cloud-assembly-schema");
+function resourceMetadata(stack, logicalId) {
+  const metadata = stack.manifest?.metadata;
+  if (!metadata) {
+    return void 0;
+  }
+  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: simplifyConstructPath(path15, stack.stackName)
+      };
+    }
+  }
+  return void 0;
+}
+function simplifyConstructPath(path15, stackName) {
+  path15 = path15.replace(/\/Resource$/, "");
+  path15 = path15.replace(/^\//, "");
+  if (stackName) {
+    if (path15.startsWith(stackName + "/")) {
+      path15 = path15.slice(stackName.length + 1);
+    }
+  }
+  return path15;
+}
+
 // ../../aws-cdk/lib/api/stack-events/stack-progress-monitor.ts
-var util5 = __toESM(require("util"));
+var util6 = __toESM(require("util"));
 var StackProgressMonitor = class {
   constructor(resourcesTotal) {
     /**
@@ -2894,9 +3566,9 @@ var StackProgressMonitor = class {
    */
   get formatted() {
     if (this.resourcesTotal == null) {
-      return padLeft(3, util5.format("%s", this.resourcesDone));
+      return padLeft(3, util6.format("%s", this.resourcesDone));
     }
-    return util5.format(
+    return util6.format(
       "%s/%s",
       padLeft(this.resourceDigits, this.resourcesDone.toString()),
       padLeft(this.resourceDigits, this.resourcesTotal.toString())
@@ -2932,8 +3604,7 @@ var StackProgressMonitor = class {
 var StackActivityMonitor = class {
   constructor({
     cfn,
-    ioHost,
-    action,
+    ioHelper,
     stack,
     stackName,
     resourcesTotal,
@@ -2941,8 +3612,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);
@@ -2953,8 +3623,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,
@@ -2970,7 +3640,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,
@@ -2995,9 +3665,8 @@ var StackActivityMonitor = class {
         return;
       }
     } catch (e) {
-      await this.ioHost.notify(error2(
-        this.action,
-        util6.format("Error occurred while monitoring stack: %s", e),
+      await this.ioHelper.notify(error3(
+        util7.format("Error occurred while monitoring stack: %s", e),
         "CDK_TOOLKIT_E5500",
         { error: e }
       ));
@@ -3009,16 +3678,7 @@ var StackActivityMonitor = class {
     if (!logicalId || !metadata) {
       return void 0;
     }
-    for (const path15 of Object.keys(metadata)) {
-      const entry = metadata[path15].filter((e) => e.type === import_cloud_assembly_schema.ArtifactMetadataEntryType.LOGICAL_ID).find((e) => e.data === logicalId);
-      if (entry) {
-        return {
-          entry,
-          constructPath: this.simplifyConstructPath(path15)
-        };
-      }
-    }
-    return void 0;
+    return resourceMetadata(this.stack, logicalId);
   }
   /**
    * Reads all new events from the stack history
@@ -3038,7 +3698,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));
     }
   }
   /**
@@ -3061,7 +3721,7 @@ var StackActivityMonitor = class {
     const metadata = activity.metadata;
     const resourceName = metadata ? metadata.constructPath : event.LogicalResourceId || "";
     const logicalId = resourceName !== event.LogicalResourceId ? `(${event.LogicalResourceId}) ` : "";
-    return util6.format(
+    return util7.format(
       "%s | %s%s | %s | %s | %s %s%s%s",
       event.StackName,
       progress !== false ? `${activity.progress.formatted} | ` : "",
@@ -3083,14 +3743,6 @@ var StackActivityMonitor = class {
       }
     }
   }
-  simplifyConstructPath(path15) {
-    path15 = path15.replace(/\/Resource$/, "");
-    path15 = path15.replace(/^\//, "");
-    if (path15.startsWith(this.stackName + "/")) {
-      path15 = path15.slice(this.stackName.length + 1);
-    }
-    return path15;
-  }
 };
 
 // ../../aws-cdk/lib/api/stack-events/stack-status.ts
@@ -3173,7 +3825,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:
 
@@ -3202,7 +3854,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) {
@@ -3306,11 +3958,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
@@ -3394,23 +4046,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_util19.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_util19.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)) {
@@ -3464,8 +4116,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;
   }
@@ -3479,8 +4131,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;
   }
@@ -3494,20 +4146,20 @@ async function waitForStackDeploy(cfn, { ioHost, action }, stackName) {
   }
   return stack;
 }
-async function stabilizeStack(cfn, { ioHost, action }, stackName) {
-  await ioHost.notify(debug2(action, (0, import_util19.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_util19.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_util19.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_util19.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;
   });
@@ -3604,13 +4256,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,
@@ -3707,18 +4359,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
         })
       );
     }
@@ -3731,7 +4382,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);
@@ -3743,8 +4394,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;
   }
 }
@@ -3778,14 +4429,14 @@ async function getBootstrapStackInfo(sdk, stackName) {
 // ../../aws-cdk/lib/api/deployments/deploy-stack.ts
 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) {
@@ -3799,23 +4450,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,
@@ -3827,13 +4478,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
@@ -3936,8 +4587,9 @@ var CfnEvaluationException = class extends Error {
 };
 var EvaluateCloudFormationTemplate = class _EvaluateCloudFormationTemplate {
   constructor(props) {
-    this.stackName = props.stackName;
-    this.template = props.template;
+    this.stackArtifact = props.stackArtifact;
+    this.stackName = props.stackName ?? props.stackArtifact.stackName;
+    this.template = props.template ?? props.stackArtifact.template;
     this.context = {
       "AWS::AccountId": props.account,
       "AWS::Region": props.region,
@@ -3956,6 +4608,7 @@ var EvaluateCloudFormationTemplate = class _EvaluateCloudFormationTemplate {
   async createNestedEvaluateCloudFormationTemplate(stackName, nestedTemplate, nestedStackParameters) {
     const evaluatedParams = await this.evaluateCfnExpression(nestedStackParameters);
     return new _EvaluateCloudFormationTemplate({
+      stackArtifact: this.stackArtifact,
       stackName,
       template: nestedTemplate,
       parameters: evaluatedParams,
@@ -4084,6 +4737,9 @@ var EvaluateCloudFormationTemplate = class _EvaluateCloudFormationTemplate {
   getResourceProperty(logicalId, propertyName) {
     return this.template.Resources?.[logicalId]?.Properties?.[propertyName];
   }
+  metadataFor(logicalId) {
+    return resourceMetadata(this.stackArtifact, logicalId);
+  }
   references(logicalId, templateElement) {
     if (typeof templateElement === "string") {
       return logicalId === templateElement;
@@ -4492,16 +5148,17 @@ async function isHotswappableAppSyncChange(logicalId, change, evaluateCfnTemplat
     } else {
       physicalName = arn;
     }
+    if (!physicalName) {
+      return ret;
+    }
     ret.push({
+      change: {
+        cause: change
+      },
       hotswappable: true,
-      resourceType: change.newValue.Type,
-      propsChanged: namesOfHotswappableChanges,
       service: "appsync",
       resourceNames: [`${change.newValue.Type} '${physicalName}'`],
       apply: async (sdk) => {
-        if (!physicalName) {
-          return;
-        }
         const sdkProperties = {
           ...change.oldValue.Properties,
           Definition: change.newValue.Properties?.Definition,
@@ -4592,12 +5249,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;
     }
   }
 }
@@ -4621,16 +5278,17 @@ async function isHotswappableCodeBuildProjectChange(logicalId, change, evaluateC
       logicalId,
       change.newValue.Properties?.Name
     );
+    if (!projectName) {
+      return ret;
+    }
     ret.push({
+      change: {
+        cause: change
+      },
       hotswappable: true,
-      resourceType: change.newValue.Type,
-      propsChanged: classifiedChanges.namesOfHotswappableProps,
       service: "codebuild",
       resourceNames: [`CodeBuild Project '${projectName}'`],
       apply: async (sdk) => {
-        if (!projectName) {
-          return;
-        }
         updateProjectInput.name = projectName;
         for (const updatedPropName in change.propertyUpdates) {
           const updatedProp = change.propertyUpdates[updatedPropName];
@@ -4666,6 +5324,7 @@ function convertSourceCloudformationKeyToSdkKey(key) {
 }
 
 // ../../aws-cdk/lib/api/hotswap/ecs-services.ts
+var ECS_SERVICE_RESOURCE_TYPE = "AWS::ECS::Service";
 async function isHotswappableEcsServiceChange(logicalId, change, evaluateCfnTemplate, hotswapPropertyOverrides) {
   if (change.newValue.Type !== "AWS::ECS::TaskDefinition") {
     return [];
@@ -4675,7 +5334,7 @@ async function isHotswappableEcsServiceChange(logicalId, change, evaluateCfnTemp
   classifiedChanges.reportNonHotswappablePropertyChanges(ret);
   const resourcesReferencingTaskDef = evaluateCfnTemplate.findReferencesTo(logicalId);
   const ecsServiceResourcesReferencingTaskDef = resourcesReferencingTaskDef.filter(
-    (r) => r.Type === "AWS::ECS::Service"
+    (r) => r.Type === ECS_SERVICE_RESOURCE_TYPE
   );
   const ecsServicesReferencingTaskDef = new Array();
   for (const ecsServiceResource of ecsServiceResourcesReferencingTaskDef) {
@@ -4688,7 +5347,7 @@ async function isHotswappableEcsServiceChange(logicalId, change, evaluateCfnTemp
     reportNonHotswappableChange(ret, change, void 0, "No ECS services reference the changed task definition", false);
   }
   if (resourcesReferencingTaskDef.length > ecsServicesReferencingTaskDef.length) {
-    const nonEcsServiceTaskDefRefs = resourcesReferencingTaskDef.filter((r) => r.Type !== "AWS::ECS::Service");
+    const nonEcsServiceTaskDefRefs = resourcesReferencingTaskDef.filter((r) => r.Type !== ECS_SERVICE_RESOURCE_TYPE);
     for (const taskRef of nonEcsServiceTaskDefRefs) {
       reportNonHotswappableChange(
         ret,
@@ -4702,9 +5361,10 @@ async function isHotswappableEcsServiceChange(logicalId, change, evaluateCfnTemp
   if (namesOfHotswappableChanges.length > 0) {
     const taskDefinitionResource = await prepareTaskDefinitionChange(evaluateCfnTemplate, logicalId, change);
     ret.push({
+      change: {
+        cause: change
+      },
       hotswappable: true,
-      resourceType: change.newValue.Type,
-      propsChanged: namesOfHotswappableChanges,
       service: "ecs-service",
       resourceNames: [
         `ECS Task Definition '${await taskDefinitionResource.Family}'`,
@@ -4794,17 +5454,7 @@ var import_stream = require("stream");
 var archiver2 = require("archiver");
 async function isHotswappableLambdaFunctionChange(logicalId, change, evaluateCfnTemplate) {
   if (change.newValue.Type === "AWS::Lambda::Version") {
-    return [
-      {
-        hotswappable: true,
-        resourceType: "AWS::Lambda::Version",
-        resourceNames: [],
-        propsChanged: [],
-        service: "lambda",
-        apply: async (_sdk) => {
-        }
-      }
-    ];
+    return [];
   }
   if (change.newValue.Type === "AWS::Lambda::Alias") {
     return classifyAliasChanges(change);
@@ -4820,36 +5470,27 @@ async function isHotswappableLambdaFunctionChange(logicalId, change, evaluateCfn
     change.newValue.Properties?.FunctionName
   );
   const namesOfHotswappableChanges = Object.keys(classifiedChanges.hotswappableProps);
-  if (namesOfHotswappableChanges.length > 0) {
+  if (functionName && namesOfHotswappableChanges.length > 0) {
+    const lambdaCodeChange = await evaluateLambdaFunctionProps(
+      classifiedChanges.hotswappableProps,
+      change.newValue.Properties?.Runtime,
+      evaluateCfnTemplate
+    );
+    if (lambdaCodeChange === void 0) {
+      return ret;
+    }
+    const dependencies = await dependantResources(logicalId, functionName, evaluateCfnTemplate);
     ret.push({
+      change: {
+        cause: change
+      },
       hotswappable: true,
-      resourceType: change.newValue.Type,
-      propsChanged: namesOfHotswappableChanges,
       service: "lambda",
       resourceNames: [
         `Lambda Function '${functionName}'`,
-        // add Version here if we're publishing a new one
-        ...await renderVersions(logicalId, evaluateCfnTemplate, [`Lambda Version for Function '${functionName}'`]),
-        // add any Aliases that we are hotswapping here
-        ...await renderAliases(
-          logicalId,
-          evaluateCfnTemplate,
-          async (alias) => `Lambda Alias '${alias}' for Function '${functionName}'`
-        )
+        ...dependencies.map((d) => d.description ?? `${d.resourceType} '${d.physicalName}'`)
       ],
       apply: async (sdk) => {
-        const lambdaCodeChange = await evaluateLambdaFunctionProps(
-          classifiedChanges.hotswappableProps,
-          change.newValue.Properties?.Runtime,
-          evaluateCfnTemplate
-        );
-        if (lambdaCodeChange === void 0) {
-          return;
-        }
-        if (!functionName) {
-          return;
-        }
-        const { versionsReferencingFunction, aliasesNames } = await versionsAndAliases(logicalId, evaluateCfnTemplate);
         const lambda = sdk.lambda();
         const operations = [];
         if (lambdaCodeChange.code !== void 0 || lambdaCodeChange.configurations !== void 0) {
@@ -4877,17 +5518,19 @@ async function isHotswappableLambdaFunctionChange(logicalId, change, evaluateCfn
             const updateFunctionCodeResponse = await lambda.updateFunctionConfiguration(updateRequest);
             await waitForLambdasPropertiesUpdateToFinish(updateFunctionCodeResponse, lambda, functionName);
           }
-          if (versionsReferencingFunction.length > 0) {
+          const versions = dependencies.filter((d) => d.resourceType === "AWS::Lambda::Version");
+          if (versions.length) {
             const publishVersionPromise = lambda.publishVersion({
               FunctionName: functionName
             });
-            if (aliasesNames.length > 0) {
+            const aliases = dependencies.filter((d) => d.resourceType === "AWS::Lambda::Alias");
+            if (aliases.length) {
               const versionUpdate = await publishVersionPromise;
-              for (const alias of aliasesNames) {
+              for (const alias of aliases) {
                 operations.push(
                   lambda.updateAlias({
                     FunctionName: functionName,
-                    Name: alias,
+                    Name: alias.physicalName,
                     FunctionVersion: versionUpdate.Version
                   })
                 );
@@ -4907,18 +5550,6 @@ function classifyAliasChanges(change) {
   const ret = [];
   const classifiedChanges = classifyChanges(change, ["FunctionVersion"]);
   classifiedChanges.reportNonHotswappablePropertyChanges(ret);
-  const namesOfHotswappableChanges = Object.keys(classifiedChanges.hotswappableProps);
-  if (namesOfHotswappableChanges.length > 0) {
-    ret.push({
-      hotswappable: true,
-      resourceType: change.newValue.Type,
-      propsChanged: [],
-      service: "lambda",
-      resourceNames: [],
-      apply: async (_sdk) => {
-      }
-    });
-  }
   return ret;
 }
 async function evaluateLambdaFunctionProps(hotswappablePropChanges, runtime, evaluateCfnTemplate) {
@@ -5023,40 +5654,54 @@ function determineCodeFileExtFromRuntime(runtime) {
 async function versionsAndAliases(logicalId, evaluateCfnTemplate) {
   const versionsReferencingFunction = evaluateCfnTemplate.findReferencesTo(logicalId).filter((r) => r.Type === "AWS::Lambda::Version");
   const aliasesReferencingVersions = flatMap(versionsReferencingFunction, (v) => evaluateCfnTemplate.findReferencesTo(v.LogicalId));
-  const aliasesNames = await Promise.all(aliasesReferencingVersions.map((a) => evaluateCfnTemplate.evaluateCfnExpression(a.Properties?.Name)));
-  return { versionsReferencingFunction, aliasesNames };
-}
-async function renderAliases(logicalId, evaluateCfnTemplate, callbackfn) {
-  const aliasesNames = (await versionsAndAliases(logicalId, evaluateCfnTemplate)).aliasesNames;
-  return Promise.all(aliasesNames.map(callbackfn));
+  return { versionsReferencingFunction, aliasesReferencingVersions };
 }
-async function renderVersions(logicalId, evaluateCfnTemplate, versionString) {
-  const versions = (await versionsAndAliases(logicalId, evaluateCfnTemplate)).versionsReferencingFunction;
-  return versions.length > 0 ? versionString : [];
+async function dependantResources(logicalId, functionName, evaluateCfnTemplate) {
+  const candidates = await versionsAndAliases(logicalId, evaluateCfnTemplate);
+  const aliases = await Promise.all(candidates.aliasesReferencingVersions.map(async (a) => {
+    const name = await evaluateCfnTemplate.evaluateCfnExpression(a.Properties?.Name);
+    return {
+      logicalId: a.LogicalId,
+      physicalName: name,
+      resourceType: "AWS::Lambda::Alias",
+      description: `Lambda Alias '${name}' for Function '${functionName}'`
+    };
+  }));
+  const versions = candidates.versionsReferencingFunction.map((v) => ({
+    logicalId: v.LogicalId,
+    resourceType: v.Type,
+    description: `Lambda Version for Function '${functionName}'`
+  }));
+  return [
+    ...versions,
+    ...aliases
+  ];
 }
 
 // ../../aws-cdk/lib/api/hotswap/s3-bucket-deployments.ts
 var REQUIRED_BY_CFN = "required-to-be-present-by-cfn";
+var CDK_BUCKET_DEPLOYMENT_CFN_TYPE = "Custom::CDKBucketDeployment";
 async function isHotswappableS3BucketDeploymentChange(_logicalId, change, evaluateCfnTemplate) {
   const ret = [];
-  if (change.newValue.Type !== "Custom::CDKBucketDeployment") {
+  if (change.newValue.Type !== CDK_BUCKET_DEPLOYMENT_CFN_TYPE) {
     return [];
   }
   const customResourceProperties = await evaluateCfnTemplate.evaluateCfnExpression({
     ...change.newValue.Properties,
     ServiceToken: void 0
   });
+  const functionName = await evaluateCfnTemplate.evaluateCfnExpression(change.newValue.Properties?.ServiceToken);
+  if (!functionName) {
+    return ret;
+  }
   ret.push({
+    change: {
+      cause: change
+    },
     hotswappable: true,
-    resourceType: change.newValue.Type,
-    propsChanged: ["*"],
     service: "custom-s3-deployment",
     resourceNames: [`Contents of S3 Bucket '${customResourceProperties.DestinationBucketName}'`],
     apply: async (sdk) => {
-      const functionName = await evaluateCfnTemplate.evaluateCfnExpression(change.newValue.Properties?.ServiceToken);
-      if (!functionName) {
-        return;
-      }
       await sdk.lambda().invokeCommand({
         FunctionName: functionName,
         // Lambda refuses to take a direct JSON object and requires it to be stringify()'d
@@ -5134,16 +5779,17 @@ async function isHotswappableStateMachineChange(logicalId, change, evaluateCfnTe
     const stateMachineArn = stateMachineNameInCfnTemplate ? await evaluateCfnTemplate.evaluateCfnExpression({
       "Fn::Sub": "arn:${AWS::Partition}:states:${AWS::Region}:${AWS::AccountId}:stateMachine:" + stateMachineNameInCfnTemplate
     }) : await evaluateCfnTemplate.findPhysicalNameFor(logicalId);
+    if (!stateMachineArn) {
+      return ret;
+    }
     ret.push({
+      change: {
+        cause: change
+      },
       hotswappable: true,
-      resourceType: change.newValue.Type,
-      propsChanged: namesOfHotswappableChanges,
       service: "stepfunctions-service",
       resourceNames: [`${change.newValue.Type} '${stateMachineArn?.split(":")[6]}'`],
       apply: async (sdk) => {
-        if (!stateMachineArn) {
-          return;
-        }
         await sdk.stepFunctions().updateStateMachine({
           stateMachineArn,
           definition: await evaluateCfnTemplate.evaluateCfnExpression(change.propertyUpdates.DefinitionString.newValue)
@@ -5178,13 +5824,36 @@ var RESOURCE_DETECTORS = {
   },
   "AWS::CDK::Metadata": async () => []
 };
-async function tryHotswapDeployment(sdkProvider, { ioHost, action }, assetParams, cloudFormationStack, stackArtifact, hotswapMode, hotswapPropertyOverrides) {
-  const resolvedEnv = await sdkProvider.resolveEnvironment(stackArtifact.environment);
+async function tryHotswapDeployment(sdkProvider, ioHelper, assetParams, cloudFormationStack, stackArtifact, hotswapMode, hotswapPropertyOverrides) {
+  const hotswapSpan = await ioHelper.span(SPAN.HOTSWAP).begin({
+    stack: stackArtifact,
+    mode: hotswapMode
+  });
+  const result2 = await hotswapDeployment(
+    sdkProvider,
+    hotswapSpan,
+    assetParams,
+    stackArtifact,
+    hotswapMode,
+    hotswapPropertyOverrides
+  );
+  await hotswapSpan.end();
+  if (result2?.hotswapped === true) {
+    return {
+      type: "did-deploy-stack",
+      noOp: result2.hotswappableChanges.length === 0,
+      stackArn: cloudFormationStack.stackId,
+      outputs: cloudFormationStack.outputs
+    };
+  }
+  return void 0;
+}
+async function hotswapDeployment(sdkProvider, ioSpan, assetParams, stack, hotswapMode, hotswapPropertyOverrides) {
+  const resolvedEnv = await sdkProvider.resolveEnvironment(stack.environment);
   const sdk = (await sdkProvider.forEnvironment(resolvedEnv, 1 /* ForWriting */)).sdk;
-  const currentTemplate = await loadCurrentTemplateWithNestedStacks(stackArtifact, sdk);
+  const currentTemplate = await loadCurrentTemplateWithNestedStacks(stack, sdk);
   const evaluateCfnTemplate = new EvaluateCloudFormationTemplate({
-    stackName: stackArtifact.stackName,
-    template: stackArtifact.template,
+    stackArtifact: stack,
     parameters: assetParams,
     account: resolvedEnv.account,
     region: resolvedEnv.region,
@@ -5192,7 +5861,7 @@ async function tryHotswapDeployment(sdkProvider, { ioHost, action }, assetParams
     sdk,
     nestedStacks: currentTemplate.nestedStacks
   });
-  const stackChanges = cfn_diff.fullDiff(currentTemplate.deployedRootTemplate, stackArtifact.template);
+  const stackChanges = cfn_diff.fullDiff(currentTemplate.deployedRootTemplate, stack.template);
   const { hotswappableChanges, nonHotswappableChanges } = await classifyResourceChanges(
     stackChanges,
     evaluateCfnTemplate,
@@ -5200,18 +5869,23 @@ async function tryHotswapDeployment(sdkProvider, { ioHost, action }, assetParams
     currentTemplate.nestedStacks,
     hotswapPropertyOverrides
   );
-  await logNonHotswappableChanges({ ioHost, action }, nonHotswappableChanges, hotswapMode);
-  if (hotswapMode === "fall-back" /* FALL_BACK */) {
+  await logNonHotswappableChanges(ioSpan, nonHotswappableChanges, hotswapMode);
+  if (hotswapMode === "fall-back") {
     if (nonHotswappableChanges.length > 0) {
-      return void 0;
+      return {
+        stack,
+        hotswapped: false,
+        hotswappableChanges,
+        nonHotswappableChanges
+      };
     }
   }
-  await applyAllHotswappableChanges(sdk, { ioHost, action }, hotswappableChanges);
+  await applyAllHotswappableChanges(sdk, ioSpan, hotswappableChanges);
   return {
-    type: "did-deploy-stack",
-    noOp: hotswappableChanges.length === 0,
-    stackArn: cloudFormationStack.stackId,
-    outputs: cloudFormationStack.outputs
+    stack,
+    hotswapped: true,
+    hotswappableChanges,
+    nonHotswappableChanges
   };
 }
 async function classifyResourceChanges(stackChanges, evaluateCfnTemplate, sdk, nestedStackNames, hotswapPropertyOverrides) {
@@ -5397,62 +6071,62 @@ function isCandidateForHotswapping(change, logicalId) {
     propertyUpdates: change.propertyUpdates
   };
 }
-async function applyAllHotswappableChanges(sdk, { ioHost, action }, hotswappableChanges) {
+async function applyAllHotswappableChanges(sdk, ioSpan, hotswappableChanges) {
   if (hotswappableChanges.length > 0) {
-    await ioHost.notify(info2(action, `
+    await ioSpan.notify(IO.DEFAULT_TOOLKIT_INFO.msg(`
 ${ICON} hotswapping resources:`));
   }
   const limit = pLimit(10);
   return Promise.all(hotswappableChanges.map((hotswapOperation) => limit(() => {
-    return applyHotswappableChange(sdk, { ioHost, action }, hotswapOperation);
+    return applyHotswappableChange(sdk, ioSpan, hotswapOperation);
   })));
 }
-async function applyHotswappableChange(sdk, { ioHost, action }, hotswapOperation) {
+async function applyHotswappableChange(sdk, ioSpan, hotswapOperation) {
   const customUserAgent = `cdk-hotswap/success-${hotswapOperation.service}`;
   sdk.appendCustomUserAgent(customUserAgent);
   for (const name of hotswapOperation.resourceNames) {
-    await ioHost.notify(info2(action, (0, import_util23.format)(`   ${ICON} %s`, chalk8.bold(name))));
+    await ioSpan.notify(IO.DEFAULT_TOOLKIT_INFO.msg((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_util23.format)(`${ICON} %s %s`, chalk8.bold(name), chalk8.green("hotswapped!"))));
+    await ioSpan.notify(IO.DEFAULT_TOOLKIT_INFO.msg((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(ioSpan, nonHotswappableChanges, hotswapMode) {
   if (nonHotswappableChanges.length === 0) {
     return;
   }
-  if (hotswapMode === "hotswap-only" /* HOTSWAP_ONLY */) {
+  if (hotswapMode === "hotswap-only") {
     nonHotswappableChanges = nonHotswappableChanges.filter((change) => change.hotswapOnlyVisible === true);
     if (nonHotswappableChanges.length === 0) {
       return;
     }
   }
   const messages = [""];
-  if (hotswapMode === "hotswap-only" /* HOTSWAP_ONLY */) {
+  if (hotswapMode === "hotswap-only") {
     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_util23.format)("%s %s", chalk8.red("\u26A0\uFE0F"), chalk8.red("The following non-hotswappable changes were found:")));
@@ -5476,11 +6150,11 @@ async function logNonHotswappableChanges({ ioHost, action }, nonHotswappableChan
     }
   }
   messages.push("");
-  await ioHost.notify(info2(action, messages.join("\n")));
+  await ioSpan.notify(IO.DEFAULT_TOOLKIT_INFO.msg(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);
@@ -5488,12 +6162,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(IO.DEFAULT_TOOLKIT_DEBUG.msg(
       `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})`
@@ -5503,7 +6176,7 @@ async function deployStack(options, { ioHost, action }) {
   }
   const legacyAssets = new AssetManifestBuilder();
   const assetParams = await addMetadataAssetsToManifest(
-    { ioHost, action },
+    ioHelper,
     stackArtifact,
     legacyAssets,
     options.envResources,
@@ -5514,11 +6187,10 @@ 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(IO.DEFAULT_TOOLKIT_DEBUG.msg(`${deployName}: skipping deployment (use --force to override)`));
     if (hotswapMode !== "full-deployment" /* FULL_DEPLOYMENT */) {
-      await ioHost.notify(info2(
-        action,
+      await ioHelper.notify(IO.DEFAULT_TOOLKIT_INFO.msg(
         (0, import_util25.format)(
           `
  ${ICON} %s
@@ -5534,7 +6206,7 @@ async function deployStack(options, { ioHost, action }) {
       stackArn: cloudFormationStack.stackId
     };
   } else {
-    await ioHost.notify(debug2(action, `${deployName}: deploying...`));
+    await ioHelper.notify(IO.DEFAULT_TOOLKIT_DEBUG.msg(`${deployName}: deploying...`));
   }
   const bodyParameter = await makeBodyParameter(
     stackArtifact,
@@ -5547,17 +6219,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(IO.DEFAULT_TOOLKIT_DEBUG.msg(`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,
@@ -5567,7 +6239,7 @@ async function deployStack(options, { ioHost, action }) {
       if (hotswapDeploymentResult) {
         return hotswapDeploymentResult;
       }
-      await ioHost.notify(info2(action, (0, import_util25.format)(
+      await ioHelper.notify(IO.DEFAULT_TOOLKIT_INFO.msg((0, import_util25.format)(
         "Could not perform a hotswap deployment, as the stack %s contains non-Asset changes",
         stackArtifact.displayName
       )));
@@ -5575,13 +6247,13 @@ async function deployStack(options, { ioHost, action }) {
       if (!(e instanceof CfnEvaluationException)) {
         throw e;
       }
-      await ioHost.notify(info2(action, (0, import_util25.format)(
+      await ioHelper.notify(IO.DEFAULT_TOOLKIT_INFO.msg((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(IO.DEFAULT_TOOLKIT_INFO.msg("Falling back to doing a full deployment"));
       options.sdk.appendCustomUserAgent("cdk-hotswap/fallback");
     } else {
       return {
@@ -5598,25 +6270,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 ?? {
@@ -5639,17 +6309,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_util25.format)("No changes are to be performed on %s.", this.stackName)));
+      await this.ioHelper.notify(IO.DEFAULT_TOOLKIT_DEBUG.msg((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_util25.format)("Deleting empty change set %s", changeSetDescription.ChangeSetId)));
+        await this.ioHelper.notify(IO.DEFAULT_TOOLKIT_DEBUG.msg((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(IO.DEFAULT_TOOLKIT_WARN.msg(
           [
             "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.",
@@ -5667,7 +6336,7 @@ var FullCloudFormationDeployment = class {
       };
     }
     if (!execute) {
-      await this.ioHost.notify(info2(this.action, (0, import_util25.format)(
+      await this.ioHelper.notify(IO.DEFAULT_TOOLKIT_INFO.msg((0, import_util25.format)(
         "Changeset %s created and waiting in review for manual execution (--no-execute)",
         changeSetDescription.ChangeSetId
       )));
@@ -5694,8 +6363,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_util25.format)("%s: creating CloudFormation changeset...", chalk9.bold(this.stackName))));
+    await this.ioHelper.notify(IO.DEFAULT_TOOLKIT_DEBUG.msg(`Attempting to create ChangeSet with name ${changeSetName} to ${this.verb} stack ${this.stackName}`));
+    await this.ioHelper.notify(IO.DEFAULT_TOOLKIT_INFO.msg((0, import_util25.format)("%s: creating CloudFormation changeset...", chalk9.bold(this.stackName))));
     const changeSet = await this.cfn.createChangeSet({
       StackName: this.stackName,
       ChangeSetName: changeSetName,
@@ -5706,21 +6375,20 @@ var FullCloudFormationDeployment = class {
       ImportExistingResources: importExistingResources,
       ...this.commonPrepareOptions()
     });
-    await this.ioHost.notify(debug2(this.action, (0, import_util25.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(IO.DEFAULT_TOOLKIT_DEBUG.msg((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_util25.format)("Initiating execution of changeset %s on stack %s", changeSet.ChangeSetId, this.stackName)));
+    await this.ioHelper.notify(IO.DEFAULT_TOOLKIT_DEBUG.msg((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,
+    await this.ioHelper.notify(IO.DEFAULT_TOOLKIT_DEBUG.msg(
       (0, import_util25.format)(
         "Execution of changeset %s on stack %s has started; waiting for the update to complete...",
         changeSet.ChangeSetId,
@@ -5732,7 +6400,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(IO.DEFAULT_TOOLKIT_DEBUG.msg(`Removing existing change set with name ${changeSetName} if it exists`));
       await this.cfn.deleteChangeSet({
         StackName: this.stackName,
         ChangeSetName: changeSetName
@@ -5742,8 +6410,7 @@ var FullCloudFormationDeployment = class {
   async updateTerminationProtection() {
     const terminationProtection = this.stackArtifact.terminationProtection ?? false;
     if (!!this.cloudFormationStack.terminationProtection !== terminationProtection) {
-      await this.ioHost.notify(debug2(
-        this.action,
+      await this.ioHelper.notify(IO.DEFAULT_TOOLKIT_DEBUG.msg(
         (0, import_util25.format)(
           "Updating termination protection from %s to %s for stack %s",
           this.cloudFormationStack.terminationProtection,
@@ -5755,11 +6422,11 @@ var FullCloudFormationDeployment = class {
         StackName: this.stackName,
         EnableTerminationProtection: terminationProtection
       });
-      await this.ioHost.notify(debug2(this.action, (0, import_util25.format)("Termination protection updated to %s for stack %s", terminationProtection, this.stackName)));
+      await this.ioHelper.notify(IO.DEFAULT_TOOLKIT_DEBUG.msg((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_util25.format)("%s: %s stack...", chalk9.bold(this.stackName), this.update ? "updating" : "creating")));
+    await this.ioHelper.notify(IO.DEFAULT_TOOLKIT_INFO.msg((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();
@@ -5772,7 +6439,7 @@ var FullCloudFormationDeployment = class {
         });
       } catch (err) {
         if (err.message === "No updates are to be performed.") {
-          await this.ioHost.notify(debug2(this.action, (0, import_util25.format)("No updates are to be performed for stack %s", this.stackName)));
+          await this.ioHelper.notify(IO.DEFAULT_TOOLKIT_DEBUG.msg((0, import_util25.format)("No updates are to be performed for stack %s", this.stackName)));
           return {
             type: "did-deploy-stack",
             noOp: true,
@@ -5801,14 +6468,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)");
       }
@@ -5818,7 +6484,7 @@ var FullCloudFormationDeployment = class {
     } finally {
       await monitor.stop();
     }
-    debug2(this.action, (0, import_util25.format)("Stack %s has completed updating", this.stackName));
+    await this.ioHelper.notify(IO.DEFAULT_TOOLKIT_DEBUG.msg((0, import_util25.format)("Stack %s has completed updating", this.stackName)));
     return {
       type: "did-deploy-stack",
       noOp: false,
@@ -5854,7 +6520,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);
@@ -5865,13 +6531,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}`);
     }
@@ -5883,47 +6548,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(IO.DEFAULT_TOOLKIT_DEBUG.msg(`${deployName}: checking if we can skip deploy`));
   if (deployStackOptions.force) {
-    await ioHost.notify(debug2(action, `${deployName}: forced deployment`));
+    await ioHelper.notify(IO.DEFAULT_TOOLKIT_DEBUG.msg(`${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(IO.DEFAULT_TOOLKIT_DEBUG.msg(`${deployName}: --no-execute, always creating change set`));
     return false;
   }
   if (!cloudFormationStack.exists) {
-    await ioHost.notify(debug2(action, `${deployName}: no existing stack`));
+    await ioHelper.notify(IO.DEFAULT_TOOLKIT_DEBUG.msg(`${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(IO.DEFAULT_TOOLKIT_DEBUG.msg(`${deployName}: template has changed`));
     return false;
   }
   if (!compareTags(cloudFormationStack.tags, deployStackOptions.tags ?? [])) {
-    await ioHost.notify(debug2(action, `${deployName}: tags have changed`));
+    await ioHelper.notify(IO.DEFAULT_TOOLKIT_DEBUG.msg(`${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(IO.DEFAULT_TOOLKIT_DEBUG.msg(`${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(IO.DEFAULT_TOOLKIT_DEBUG.msg(`${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(IO.DEFAULT_TOOLKIT_DEBUG.msg(`${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(IO.DEFAULT_TOOLKIT_DEBUG.msg(`${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(IO.DEFAULT_TOOLKIT_DEBUG.msg(`${deployName}: stack is in a failure state`));
     return false;
   }
   return true;
@@ -6015,7 +6680,7 @@ function loadTree(assembly) {
     const fileName = assembly.tree()?.file;
     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;
   }
 }
@@ -6023,25 +6688,28 @@ function loadTreeFromDir(outdir) {
   try {
     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 = path10.join(cdkCacheDir(), "notices.json");
-var NoticesFilter = class _NoticesFilter {
-  static filter(options) {
+var NoticesFilter = class {
+  constructor(ioMessages) {
+    this.ioMessages = ioMessages;
+  }
+  filter(options) {
     const components = [
-      ..._NoticesFilter.constructTreeComponents(options.outDir),
-      ..._NoticesFilter.otherComponents(options)
+      ...this.constructTreeComponents(options.outDir),
+      ...this.otherComponents(options)
     ];
-    return _NoticesFilter.findForNamedComponents(options.data, components);
+    return this.findForNamedComponents(options.data, components);
   }
   /**
    * From a set of input options, return the notices components we are searching for
    */
-  static otherComponents(options) {
+  otherComponents(options) {
     return [
       // CLI
       {
@@ -6059,7 +6727,7 @@ var NoticesFilter = class _NoticesFilter {
       ...options.bootstrappedEnvironments.flatMap((env) => {
         const semverBootstrapVersion = semver4.coerce(env.bootstrapStackVersion);
         if (!semverBootstrapVersion) {
-          warning(`While filtering notices, could not coerce bootstrap version '${env.bootstrapStackVersion}' into semver`);
+          this.ioMessages.warning(`While filtering notices, could not coerce bootstrap version '${env.bootstrapStackVersion}' into semver`);
           return [];
         }
         return [{
@@ -6074,14 +6742,14 @@ var NoticesFilter = class _NoticesFilter {
   /**
    * Based on a set of component names, find all notices that match one of the given components
    */
-  static findForNamedComponents(data, actualComponents) {
+  findForNamedComponents(data, actualComponents) {
     return data.flatMap((notice) => {
       const ors = this.resolveAliases(normalizeComponents(notice.components));
       for (const ands of ors) {
-        const matched = ands.map((affected) => actualComponents.filter((actual) => _NoticesFilter.componentNameMatches(affected, actual) && semver4.satisfies(actual.version, affected.version, { includePrerelease: true })));
+        const matched = ands.map((affected) => actualComponents.filter((actual) => this.componentNameMatches(affected, actual) && semver4.satisfies(actual.version, affected.version, { includePrerelease: true })));
         if (matched.every((xs) => xs.length > 0)) {
           const ret = new FilteredNotice(notice);
-          _NoticesFilter.addDynamicValues(matched.flatMap((x) => x), ret);
+          this.addDynamicValues(matched.flatMap((x) => x), ret);
           return [ret];
         }
       }
@@ -6094,7 +6762,7 @@ var NoticesFilter = class _NoticesFilter {
    * The name matches if the name is exactly the same, or the name in the notice
    * is a prefix of the node name when the query ends in '.'.
    */
-  static componentNameMatches(pattern, actual) {
+  componentNameMatches(pattern, actual) {
     return pattern.name.endsWith(".") ? actual.name.startsWith(pattern.name) : pattern.name === actual.name;
   }
   /**
@@ -6103,7 +6771,7 @@ var NoticesFilter = class _NoticesFilter {
    * If there are multiple components with the same dynamic name, they are joined
    * by a comma.
    */
-  static addDynamicValues(comps, notice) {
+  addDynamicValues(comps, notice) {
     const dynamicValues = {};
     for (const comp of comps) {
       if (comp.dynamicName) {
@@ -6121,7 +6789,7 @@ var NoticesFilter = class _NoticesFilter {
    * Because it's EITHER `aws-cdk-lib` or `@aws-cdk/core`, we need to add multiple
    * arrays at the top level.
    */
-  static resolveAliases(ors) {
+  resolveAliases(ors) {
     return ors.flatMap((ands) => {
       const hasFramework = ands.find((c) => c.name === "framework");
       if (!hasFramework) {
@@ -6136,7 +6804,7 @@ var NoticesFilter = class _NoticesFilter {
   /**
    * Load the construct tree from the given directory and return its components
    */
-  static constructTreeComponents(manifestDir) {
+  constructTreeComponents(manifestDir) {
     const tree = loadTreeFromDir(manifestDir);
     if (!tree) {
       return [];
@@ -6166,8 +6834,12 @@ var Notices = class _Notices {
     this.acknowledgedIssueNumbers = new Set(this.context.get("acknowledged-issue-numbers") ?? []);
     this.includeAcknowlegded = props.includeAcknowledged ?? false;
     this.output = props.output ?? "cdk.out";
-    this.shouldDisplay = props.shouldDisplay ?? true;
     this.httpOptions = props.httpOptions ?? {};
+    this.ioMessages = new IoDefaultMessages(asIoHelper(
+      props.ioHost,
+      "notices"
+      /* forcing a CliAction to a ToolkitAction */
+    ));
   }
   /**
    * Create an instance. Note that this replaces the singleton.
@@ -6203,54 +6875,54 @@ var Notices = class _Notices {
    * If context is configured to not display notices, this will no-op.
    */
   async refresh(options = {}) {
-    if (!this.shouldDisplay) {
-      return;
-    }
     try {
-      const underlyingDataSource = options.dataSource ?? new WebsiteNoticeDataSource(this.httpOptions);
-      const dataSource = new CachedDataSource(CACHE_FILE_PATH, underlyingDataSource, options.force ?? false);
+      const underlyingDataSource = options.dataSource ?? new WebsiteNoticeDataSource(this.ioMessages, this.httpOptions);
+      const dataSource = new CachedDataSource(this.ioMessages, CACHE_FILE_PATH, underlyingDataSource, options.force ?? false);
       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}`);
+      this.ioMessages.debug(`Could not refresh notices: ${e}`);
     }
   }
   /**
    * Display the relevant notices (unless context dictates we shouldn't).
    */
   display(options = {}) {
-    if (!this.shouldDisplay) {
-      return;
-    }
-    const filteredNotices = NoticesFilter.filter({
+    const filteredNotices = new NoticesFilter(this.ioMessages).filter({
       data: Array.from(this.data),
       cliVersion: versionNumber(),
       outDir: this.output,
       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("");
+      void this.ioMessages.notify(IO.CDK_TOOLKIT_I0100.msg([
+        "",
+        "NOTICES         (What's this? https://github.com/aws/aws-cdk/wiki/CLI-Notices)",
+        ""
+      ].join("\n")));
       for (const filtered of filteredNotices) {
-        const formatted = filtered.format();
+        const formatted = filtered.format() + "\n";
         switch (filtered.notice.severity) {
           case "warning":
-            warning(formatted);
+            void this.ioMessages.notify(IO.CDK_TOOLKIT_W0101.msg(formatted));
             break;
           case "error":
-            error(formatted);
+            void this.ioMessages.notify(IO.CDK_TOOLKIT_E0101.msg(formatted));
             break;
           default:
-            info(formatted);
+            void this.ioMessages.notify(IO.CDK_TOOLKIT_I0101.msg(formatted));
+            break;
         }
-        info("");
       }
-      info(`If you don\u2019t want to see a notice anymore, use "cdk acknowledge <id>". For example, "cdk acknowledge ${filteredNotices[0].notice.issueNumber}".`);
+      void this.ioMessages.notify(IO.CDK_TOOLKIT_I0100.msg(
+        `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).`);
+      void this.ioMessages.notify(IO.CDK_TOOLKIT_I0100.msg(
+        `
+There are ${filteredNotices.length} unacknowledged notice(s).`
+      ));
     }
   }
 };
@@ -6291,7 +6963,8 @@ var FilteredNotice = class {
   }
 };
 var WebsiteNoticeDataSource = class {
-  constructor(options = {}) {
+  constructor(ioMessages, options = {}) {
+    this.ioMessages = ioMessages;
     this.options = options;
   }
   fetch() {
@@ -6324,7 +6997,7 @@ var WebsiteNoticeDataSource = class {
                   if (!data) {
                     throw new ToolkitError("'notices' key is missing");
                   }
-                  debug("Notices refreshed");
+                  this.ioMessages.debug("Notices refreshed");
                   resolve3(data ?? []);
                 } catch (e) {
                   reject(new ToolkitError(`Failed to parse notices: ${formatErrorMessage(e)}`));
@@ -6348,7 +7021,8 @@ var WebsiteNoticeDataSource = class {
 var TIME_TO_LIVE_SUCCESS = 60 * 60 * 1e3;
 var TIME_TO_LIVE_ERROR = 1 * 60 * 1e3;
 var CachedDataSource = class {
-  constructor(fileName, dataSource, skipCache) {
+  constructor(ioMessages, fileName, dataSource, skipCache) {
+    this.ioMessages = ioMessages;
     this.fileName = fileName;
     this.dataSource = dataSource;
     this.skipCache = skipCache;
@@ -6362,7 +7036,7 @@ var CachedDataSource = class {
       await this.save(freshData);
       return freshData.notices;
     } else {
-      debug(`Reading cached notices from ${this.fileName}`);
+      this.ioMessages.debug(`Reading cached notices from ${this.fileName}`);
       return data;
     }
   }
@@ -6373,7 +7047,7 @@ var CachedDataSource = class {
         notices: await this.dataSource.fetch()
       };
     } catch (e) {
-      debug(`Could not refresh notices: ${e}`);
+      this.ioMessages.debug(`Could not refresh notices: ${e}`);
       return {
         expiration: Date.now() + TIME_TO_LIVE_ERROR,
         notices: []
@@ -6388,7 +7062,7 @@ var CachedDataSource = class {
     try {
       return fs11.existsSync(this.fileName) ? await fs11.readJSON(this.fileName) : defaultValue;
     } catch (e) {
-      debug(`Failed to load notices from cache: ${e}`);
+      this.ioMessages.debug(`Failed to load notices from cache: ${e}`);
       return defaultValue;
     }
   }
@@ -6396,7 +7070,7 @@ var CachedDataSource = class {
     try {
       await fs11.writeJSON(this.fileName, cached2);
     } catch (e) {
-      debug(`Failed to store notices in the cache: ${e}`);
+      this.ioMessages.debug(`Failed to store notices in the cache: ${e}`);
     }
   }
 };
@@ -6420,14 +7094,13 @@ 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,
+        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,
@@ -6438,8 +7111,7 @@ var ToolkitInfo = class _ToolkitInfo {
         return _ToolkitInfo.bootstrapStackNotFoundInfo(stackName);
       }
       if (stack.stackStatus.isCreationFailure) {
-        await ioHost.notify(debug2(
-          action,
+        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,
@@ -6551,21 +7223,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;
   }
@@ -6574,7 +7246,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;
   }
@@ -6602,8 +7274,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);
@@ -6638,10 +7309,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;
@@ -6660,7 +7331,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]
       });
@@ -6673,7 +7344,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,
@@ -6683,7 +7354,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 }
@@ -6692,8 +7363,8 @@ var EnvironmentResources = class {
   }
 };
 var NoBootstrapStackEnvironmentResources = class extends EnvironmentResources {
-  constructor(environment, sdk, msg) {
-    super(environment, sdk, msg, emptyCache());
+  constructor(environment, sdk, ioHelper) {
+    super(environment, sdk, ioHelper, emptyCache());
   }
   /**
    * Look up the toolkit for a given environment, using a given SDK
@@ -6726,12 +7397,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.
@@ -6810,7 +7480,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;
   }
@@ -6832,7 +7502,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 */);
   }
@@ -6873,7 +7543,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,
@@ -6914,12 +7584,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
     );
   }
   /**
@@ -6933,12 +7602,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);
@@ -6960,7 +7629,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 ?? [];
   }
@@ -7008,7 +7677,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 ?? [];
@@ -7032,10 +7701,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,
@@ -7054,7 +7723,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)(),
@@ -7063,8 +7732,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 };
@@ -7075,14 +7743,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)");
         }
@@ -7118,7 +7785,7 @@ var Deployments = class {
       roleArn: executionRoleArn,
       stack: options.stack,
       deployName: options.deployName
-    }, { ioHost: this.ioHost, action: this.action });
+    }, this.ioHelper);
   }
   async stackExists(options) {
     let env;
@@ -7161,7 +7828,10 @@ 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.displayName(true)}`);
     }
@@ -7169,10 +7839,7 @@ var Deployments = class {
   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;
   }
@@ -7206,15 +7873,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) {
@@ -7247,8 +7914,7 @@ 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
@@ -7276,17 +7942,17 @@ var ResourceImporter = class {
       const descr = this.describeResource(resource.logicalId);
       const idProps = contents[resource.logicalId];
       if (idProps) {
-        await this.ioHost.notify(info2(this.action, (0, import_util34.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_util34.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;
   }
@@ -7316,18 +7982,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_util34.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_util34.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;
     }
   }
@@ -7346,7 +8012,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)`);
       }
@@ -7419,7 +8085,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];
@@ -7436,7 +8102,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})`;
@@ -7449,7 +8115,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 = {};
@@ -7473,7 +8139,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;
   }
   /**
@@ -7528,8 +8194,7 @@ 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
@@ -7541,16 +8206,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);
       fs13.rmSync("migrate.json");
-      await this.ioHost.notify(info2(this.action, `${chalk14.bold(stack.displayName)}: applying CDKMetadata and Outputs to stack (if applicable)...`));
+      await this.ioHelper.notify(info3(`${chalk14.bold(stack.displayName)}: applying CDKMetadata and Outputs to stack (if applicable)...`));
     }
   }
   /**
@@ -7566,7 +8230,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
@@ -7588,24 +8252,37 @@ var ResourceMigrator = class {
 };
 
 // ../../aws-cdk/lib/api/logs/logs-monitor.ts
-var util7 = __toESM(require("util"));
+var util8 = __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
@@ -7616,9 +8293,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();
   }
   /**
@@ -7645,22 +8327,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
@@ -7678,15 +8369,16 @@ var CloudWatchLogEventMonitor = class {
   /**
    * Print out a cloudwatch event
    */
-  print(event) {
-    info(
-      util7.format(
+  async print(event) {
+    await this.ioHelper.notify(IO.CDK_TOOLKIT_I5033.msg(
+      util8.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
@@ -7736,19 +8428,18 @@ 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);
   const evaluateCfnTemplate = new EvaluateCloudFormationTemplate({
-    stackName: stackArtifact.stackName,
-    template: stackArtifact.template,
+    stackArtifact,
     parameters: {},
     account: resolvedEnv.account,
     region: resolvedEnv.region,
@@ -7810,12 +8501,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) {
@@ -7972,8 +8662,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);
@@ -8018,7 +8708,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,
@@ -8028,7 +8718,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);
@@ -8046,7 +8736,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)`);
     }
   }
@@ -8139,12 +8829,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 {
     /**
@@ -8238,7 +8927,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);
@@ -8295,24 +8984,24 @@ 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_schema2 = require("@aws-cdk/cloud-assembly-schema");
+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, msg) {
+  constructor(sdkProvider, sdk, resolvedEnvironment, toolkitStackName, currentToolkitInfo, ioHelper) {
     this.sdkProvider = sdkProvider;
     this.sdk = sdk;
     this.resolvedEnvironment = resolvedEnvironment;
     this.toolkitStackName = toolkitStackName;
     this.currentToolkitInfo = currentToolkitInfo;
-    this.msg = msg;
+    this.ioHelper = ioHelper;
   }
-  static async lookup(sdkProvider, environment, toolkitStackName, msg) {
+  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, msg, toolkitStackName);
-    return new _BootstrapStack(sdkProvider, sdk, resolvedEnvironment, toolkitStackName, currentToolkitInfo, msg);
+    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 : {};
@@ -8337,8 +9026,7 @@ var BootstrapStack = class _BootstrapStack {
       const currentVariant = this.currentToolkitInfo.variant;
       const newVariant = bootstrapVariantFromTemplate(template);
       if (currentVariant !== newVariant) {
-        await this.msg.ioHost.notify(warn(
-          this.msg.action,
+        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;
@@ -8346,13 +9034,11 @@ var BootstrapStack = class _BootstrapStack {
       const newVersion = bootstrapVersionFromTemplate(template);
       const currentVersion = this.currentToolkitInfo.version;
       if (newVersion < currentVersion) {
-        await this.msg.ioHost.notify(warn(
-          this.msg.action,
+        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.msg.ioHost.notify(warn(
-            this.msg.action,
+          await this.ioHelper.notify(warn2(
             "(Did you set the '@aws-cdk/core:newStyleStackSynthesis' feature flag in cdk.json?)"
           ));
         }
@@ -8366,7 +9052,7 @@ var BootstrapStack = class _BootstrapStack {
       spaces: 2
     });
     builder.addArtifact(this.toolkitStackName, {
-      type: import_cloud_assembly_schema2.ArtifactType.AWS_CLOUDFORMATION_STACK,
+      type: import_cloud_assembly_schema3.ArtifactType.AWS_CLOUDFORMATION_STACK,
       environment: import_cx_api6.EnvironmentUtils.format(this.resolvedEnvironment.account, this.resolvedEnvironment.region),
       properties: {
         templateFile,
@@ -8386,8 +9072,8 @@ var BootstrapStack = class _BootstrapStack {
       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.msg)
-    }, this.msg);
+      envResources: new NoBootstrapStackEnvironmentResources(this.resolvedEnvironment, this.sdk, this.ioHelper)
+    }, this.ioHelper);
     assertIsSuccessfulDeployStackResult(ret);
     return ret;
   }
@@ -8492,9 +9178,9 @@ function legacyBootstrapTemplate(params) {
 
 // ../../aws-cdk/lib/api/bootstrap/bootstrap-environment.ts
 var Bootstrapper = class {
-  constructor(source = { source: "default" }, msg) {
+  constructor(source = { source: "default" }, ioHelper) {
     this.source = source;
-    this.msg = msg;
+    this.ioHelper = ioHelper;
   }
   bootstrapEnvironment(environment, sdkProvider, options = {}) {
     switch (this.source.source) {
@@ -8530,7 +9216,7 @@ var Bootstrapper = class {
       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.msg);
+    const current = await BootstrapStack.lookup(sdkProvider, environment, toolkitStackName, this.ioHelper);
     return current.update(
       await this.loadTemplate(params),
       {},
@@ -8548,7 +9234,7 @@ var Bootstrapper = class {
     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.msg);
+    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(
@@ -8575,8 +9261,7 @@ var Bootstrapper = class {
     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.msg.ioHost.notify(warn(
-        this.msg.action,
+      await this.ioHelper.notify(warn2(
         `Using default execution policy of '${implicitPolicy}'. Pass '--cloudformation-execution-policies' to customize.`
       ));
     } else if (cloudFormationExecutionPolicies.length === 0) {
@@ -8597,18 +9282,15 @@ var Bootstrapper = class {
     }
     if (currentPermissionsBoundary !== policyName) {
       if (!currentPermissionsBoundary) {
-        await this.msg.ioHost.notify(warn(
-          this.msg.action,
+        await this.ioHelper.notify(warn2(
           `Adding new permissions boundary ${policyName}`
         ));
       } else if (!policyName) {
-        await this.msg.ioHost.notify(warn(
-          this.msg.action,
+        await this.ioHelper.notify(warn2(
           `Removing existing permissions boundary ${currentPermissionsBoundary}`
         ));
       } else {
-        await this.msg.ioHost.notify(warn(
-          this.msg.action,
+        await this.ioHelper.notify(warn2(
           `Changing permissions boundary from ${currentPermissionsBoundary} to ${policyName}`
         ));
       }
@@ -8708,11 +9390,11 @@ var Bootstrapper = class {
         }
       ]
     };
-    const request = {
+    const request2 = {
       PolicyName: policyName,
       PolicyDocument: JSON.stringify(policyDoc)
     };
-    const createPolicyResponse = await iam.createPolicy(request);
+    const createPolicyResponse = await iam.createPolicy(request2);
     if (createPolicyResponse.Policy?.Arn) {
       return createPolicyResponse.Policy.Arn;
     } else {
@@ -8777,8 +9459,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,
@@ -8792,7 +9474,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;
   }
 };
@@ -8810,7 +9492,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) {
@@ -8837,8 +9519,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) {
@@ -8863,14 +9545,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}.`);
@@ -8890,10 +9572,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 ?? "");
@@ -8933,17 +9615,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;
   }
 };
@@ -8960,7 +9642,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) {
@@ -8979,9 +9661,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 {
@@ -8992,7 +9674,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)) {
@@ -9020,7 +9702,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 {
@@ -9047,7 +9729,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
     };
@@ -9275,7 +9957,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;
@@ -9324,7 +10006,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) {
@@ -9337,7 +10019,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 || [];
@@ -9619,7 +10301,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) {
@@ -9957,36 +10639,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) {
+      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_api9.SynthesisMessageLevel.ERROR:
             errors = true;
-            await logger("error", message);
+            await logger("error", message2);
             break;
           case import_cx_api9.SynthesisMessageLevel.INFO:
-            await logger("info", message);
+            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();
@@ -10002,7 +10684,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) {
@@ -10021,7 +10703,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) {
@@ -10036,7 +10718,7 @@ var cxschema4 = __toESM(require("@aws-cdk/cloud-assembly-schema"));
 var cxapi5 = __toESM(require("@aws-cdk/cx-api"));
 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]);
@@ -10073,7 +10755,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) {
@@ -10092,7 +10774,7 @@ async function guessExecutable(app) {
     try {
       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 & fs16.constants.X_OK) !== 0;
@@ -10131,7 +10813,6 @@ function spaceAvailableForContext(env, limit) {
   WorkGraphBuilder,
   contextproviders,
   findCloudWatchLogGroups,
-  formatSdkLoggerContent,
   guessExecutable,
   loadTree,
   prepareContext,