@aws-cdk/toolkit-lib 0.1.5 → 0.1.6

package/lib/api/aws-cdk.js

@@ -98,11 +98,10 @@ 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"));
@@ -214,6 +213,7 @@ var ContextProviderError = class _ContextProviderError extends ToolkitError {
 };
 
 // ../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
@@ -401,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] = {};
     }
@@ -409,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];
@@ -578,6 +588,123 @@ 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",
@@ -639,7 +766,7 @@ var confirm = (details) => request("info", {
 
 // ../tmp-toolkit-helpers/src/api/io/private/messages.ts
 var IO = {
-  // Defaults
+  // Defaults (0000)
   DEFAULT_TOOLKIT_INFO: info({
     code: "CDK_TOOLKIT_I0000",
     description: "Default info messages emitted from the Toolkit"
@@ -652,7 +779,15 @@ var IO = {
     code: "CDK_TOOLKIT_W0000",
     description: "Default warning messages emitted from the Toolkit"
   }),
-  // 1: Synth
+  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.",
@@ -673,7 +808,7 @@ var IO = {
     description: "Successfully deployed stacks",
     interface: "AssemblyData"
   }),
-  // 2: List
+  // 2: List (2xxx)
   CDK_TOOLKIT_I2901: result({
     code: "CDK_TOOLKIT_I2901",
     description: "Provides details on the selected stacks and their dependencies",
@@ -684,8 +819,8 @@ var IO = {
     code: "CDK_TOOLKIT_E3900",
     description: "Resource import failed"
   }),
-  // 4: Diff
-  // 5: Deploy & Watch
+  // 4: Diff (4xxx)
+  // 5: Deploy & Watch (5xxx)
   CDK_TOOLKIT_I5000: info({
     code: "CDK_TOOLKIT_I5000",
     description: "Provides deployment times",
@@ -747,7 +882,7 @@ var IO = {
     description: "Stack deploy progress",
     interface: "StackDeployProgress"
   }),
-  // Assets
+  // Assets (52xx)
   CDK_TOOLKIT_I5210: trace({
     code: "CDK_TOOLKIT_I5210",
     description: "Started building a specific asset",
@@ -768,7 +903,7 @@ var IO = {
     description: "Publishing the asset has completed",
     interface: "Duration"
   }),
-  // Watch
+  // Watch (53xx)
   CDK_TOOLKIT_I5310: debug({
     code: "CDK_TOOLKIT_I5310",
     description: "The computed settings used for file watching",
@@ -797,7 +932,18 @@ var IO = {
     code: "CDK_TOOLKIT_I5315",
     description: "Queued watch deployment started"
   }),
-  // Stack Monitor
+  // 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",
@@ -813,7 +959,7 @@ var IO = {
     description: "Stack Monitoring: Finished monitoring of a single stack",
     interface: "StackMonitoringControlEvent"
   }),
-  // Success
+  // Success (59xx)
   CDK_TOOLKIT_I5900: result({
     code: "CDK_TOOLKIT_I5900",
     description: "Deployment results on success",
@@ -837,7 +983,7 @@ var IO = {
     description: "Stack Monitoring error",
     interface: "ErrorPayload"
   }),
-  // 6: Rollback
+  // 6: Rollback (6xxx)
   CDK_TOOLKIT_I6000: info({
     code: "CDK_TOOLKIT_I6000",
     description: "Provides rollback times",
@@ -857,7 +1003,7 @@ var IO = {
     description: "Rollback failed",
     interface: "ErrorPayload"
   }),
-  // 7: Destroy
+  // 7: Destroy (7xxx)
   CDK_TOOLKIT_I7000: info({
     code: "CDK_TOOLKIT_I7000",
     description: "Provides destroy times",
@@ -897,7 +1043,7 @@ var IO = {
     description: "Stack deletion failed",
     interface: "ErrorPayload"
   }),
-  // 9: Bootstrap
+  // 9: Bootstrap (9xxx)
   CDK_TOOLKIT_I9000: info({
     code: "CDK_TOOLKIT_I9000",
     description: "Provides bootstrap times",
@@ -918,6 +1064,23 @@ var IO = {
     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",
@@ -1034,6 +1197,57 @@ var SPAN = {
     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));
   }
 };
 
@@ -1142,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) {
@@ -1202,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} | ` : "",
@@ -1227,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(", "))
@@ -1254,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
@@ -1338,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))),
@@ -1358,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)),
@@ -1429,6 +1643,13 @@ function shorten(maxWidth, p) {
 // ../../aws-cdk/lib/toolkit/cli-io-host.ts
 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;
@@ -1532,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.
@@ -1566,10 +1787,19 @@ var CliIoHost = class _CliIoHost {
         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;
@@ -1640,7 +1870,7 @@ var CliIoHost = class _CliIoHost {
    */
   makeActivityPrinter() {
     const props = {
-      stream: this.selectStream("info")
+      stream: this.selectStreamFromLevel("info")
     };
     switch (this.stackProgress) {
       case "events" /* EVENTS */:
@@ -1659,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)
   };
 }
@@ -1674,41 +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: message2, code = getDefaultCode(level) } = typeof input === "object" ? input : { message: input };
-  const formattedMessage = args.length > 0 ? util4.format(message2, ...args) : message2;
-  const finalMessage = style ? style(formattedMessage) : formattedMessage;
-  const ioHost = CliIoHost.instance();
-  const ioMessage = {
-    time: /* @__PURE__ */ new Date(),
-    action: ioHost.currentAction,
-    level,
-    message: finalMessage,
-    code,
-    data: void 0
-  };
-  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 error2 = (input, ...args) => {
-  return formatMessageAndLog("error", input, void 0, ...args);
+  return formatMessageAndLog("error", input, ...args);
 };
 var warning = (input, ...args) => {
-  return formatMessageAndLog("warn", input, void 0, ...args);
+  return formatMessageAndLog("warn", input, ...args);
 };
 var info2 = (input, ...args) => {
-  return formatMessageAndLog("info", input, void 0, ...args);
+  return formatMessageAndLog("info", input, ...args);
 };
 var debug2 = (input, ...args) => {
-  return formatMessageAndLog("debug", input, void 0, ...args);
+  return formatMessageAndLog("debug", input, ...args);
 };
 var trace2 = (input, ...args) => {
-  return formatMessageAndLog("trace", input, void 0, ...args);
+  return formatMessageAndLog("trace", input, ...args);
 };
 
 // ../../aws-cdk/lib/api/aws-auth/account-cache.ts
@@ -3135,8 +3374,7 @@ var trace3 = (message2, code, payload) => {
 };
 
 // ../../aws-cdk/lib/api/stack-events/stack-activity-monitor.ts
-var util6 = __toESM(require("util"));
-var import_cloud_assembly_schema2 = require("@aws-cdk/cloud-assembly-schema");
+var util7 = __toESM(require("util"));
 var uuid2 = __toESM(require("uuid"));
 
 // ../../aws-cdk/lib/api/stack-events/stack-event-poller.ts
@@ -3249,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) {
     /**
@@ -3299,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())
@@ -3399,7 +3666,7 @@ var StackActivityMonitor = class {
       }
     } catch (e) {
       await this.ioHelper.notify(error3(
-        util6.format("Error occurred while monitoring stack: %s", e),
+        util7.format("Error occurred while monitoring stack: %s", e),
         "CDK_TOOLKIT_E5500",
         { error: e }
       ));
@@ -3411,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_schema2.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
@@ -3463,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} | ` : "",
@@ -3485,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
@@ -4337,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,
@@ -4357,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,
@@ -4485,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;
@@ -4893,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,
@@ -5022,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];
@@ -5067,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 [];
@@ -5076,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) {
@@ -5089,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,
@@ -5103,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}'`,
@@ -5195,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);
@@ -5221,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) {
@@ -5278,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
                   })
                 );
@@ -5308,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) {
@@ -5424,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 };
+  return { versionsReferencingFunction, aliasesReferencingVersions };
 }
-async function renderAliases(logicalId, evaluateCfnTemplate, callbackfn) {
-  const aliasesNames = (await versionsAndAliases(logicalId, evaluateCfnTemplate)).aliasesNames;
-  return Promise.all(aliasesNames.map(callbackfn));
-}
-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
@@ -5535,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)
@@ -5580,12 +5825,35 @@ var RESOURCE_DETECTORS = {
   "AWS::CDK::Metadata": async () => []
 };
 async function tryHotswapDeployment(sdkProvider, ioHelper, assetParams, cloudFormationStack, stackArtifact, hotswapMode, hotswapPropertyOverrides) {
-  const resolvedEnv = await sdkProvider.resolveEnvironment(stackArtifact.environment);
+  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,
@@ -5593,7 +5861,7 @@ async function tryHotswapDeployment(sdkProvider, ioHelper, assetParams, cloudFor
     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,
@@ -5601,18 +5869,23 @@ async function tryHotswapDeployment(sdkProvider, ioHelper, assetParams, cloudFor
     currentTemplate.nestedStacks,
     hotswapPropertyOverrides
   );
-  await logNonHotswappableChanges(ioHelper, 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, ioHelper, 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) {
@@ -5798,21 +6071,21 @@ function isCandidateForHotswapping(change, logicalId) {
     propertyUpdates: change.propertyUpdates
   };
 }
-async function applyAllHotswappableChanges(sdk, ioHelper, hotswappableChanges) {
+async function applyAllHotswappableChanges(sdk, ioSpan, hotswappableChanges) {
   if (hotswappableChanges.length > 0) {
-    await ioHelper.notify(info3(`
+    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, ioHelper, hotswapOperation);
+    return applyHotswappableChange(sdk, ioSpan, hotswapOperation);
   })));
 }
-async function applyHotswappableChange(sdk, ioHelper, hotswapOperation) {
+async function applyHotswappableChange(sdk, ioSpan, hotswapOperation) {
   const customUserAgent = `cdk-hotswap/success-${hotswapOperation.service}`;
   sdk.appendCustomUserAgent(customUserAgent);
   for (const name of hotswapOperation.resourceNames) {
-    await ioHelper.notify(info3((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);
@@ -5826,7 +6099,7 @@ async function applyHotswappableChange(sdk, ioHelper, hotswapOperation) {
     throw e;
   }
   for (const name of hotswapOperation.resourceNames) {
-    await ioHelper.notify(info3((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);
 }
@@ -5842,18 +6115,18 @@ ${observedResponses}`;
   }
   return main;
 }
-async function logNonHotswappableChanges(ioHelper, 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:")));
@@ -5877,7 +6150,7 @@ async function logNonHotswappableChanges(ioHelper, nonHotswappableChanges, hotsw
     }
   }
   messages.push("");
-  await ioHelper.notify(info3(messages.join("\n")));
+  await ioSpan.notify(IO.DEFAULT_TOOLKIT_INFO.msg(messages.join("\n")));
 }
 
 // ../../aws-cdk/lib/api/deployments/deploy-stack.ts
@@ -5889,7 +6162,7 @@ async function deployStack(options, ioHelper) {
   const deployName = options.deployName || stackArtifact.stackName;
   let cloudFormationStack = await CloudFormationStack.lookup(cfn, deployName);
   if (cloudFormationStack.stackStatus.isCreationFailure) {
-    await ioHelper.notify(debug3(
+    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 });
@@ -5915,9 +6188,9 @@ async function deployStack(options, ioHelper) {
   const hotswapMode = options.hotswap ?? "full-deployment" /* FULL_DEPLOYMENT */;
   const hotswapPropertyOverrides = options.hotswapPropertyOverrides ?? new HotswapPropertyOverrides();
   if (await canSkipDeploy(options, cloudFormationStack, stackParams.hasChanges(cloudFormationStack.parameters), ioHelper)) {
-    await ioHelper.notify(debug3(`${deployName}: skipping deployment (use --force to override)`));
+    await ioHelper.notify(IO.DEFAULT_TOOLKIT_DEBUG.msg(`${deployName}: skipping deployment (use --force to override)`));
     if (hotswapMode !== "full-deployment" /* FULL_DEPLOYMENT */) {
-      await ioHelper.notify(info3(
+      await ioHelper.notify(IO.DEFAULT_TOOLKIT_INFO.msg(
         (0, import_util25.format)(
           `
  ${ICON} %s
@@ -5933,7 +6206,7 @@ async function deployStack(options, ioHelper) {
       stackArn: cloudFormationStack.stackId
     };
   } else {
-    await ioHelper.notify(debug3(`${deployName}: deploying...`));
+    await ioHelper.notify(IO.DEFAULT_TOOLKIT_DEBUG.msg(`${deployName}: deploying...`));
   }
   const bodyParameter = await makeBodyParameter(
     stackArtifact,
@@ -5946,7 +6219,7 @@ async function deployStack(options, ioHelper) {
   try {
     bootstrapStackName = (await options.envResources.lookupToolkit()).stackName;
   } catch (e) {
-    await ioHelper.notify(debug3(`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,
@@ -5966,7 +6239,7 @@ async function deployStack(options, ioHelper) {
       if (hotswapDeploymentResult) {
         return hotswapDeploymentResult;
       }
-      await ioHelper.notify(info3((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
       )));
@@ -5974,13 +6247,13 @@ async function deployStack(options, ioHelper) {
       if (!(e instanceof CfnEvaluationException)) {
         throw e;
       }
-      await ioHelper.notify(info3((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 ioHelper.notify(info3("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 {
@@ -6036,16 +6309,16 @@ var FullCloudFormationDeployment = class {
     const changeSetDescription = await this.createChangeSet(changeSetName, execute, importExistingResources);
     await this.updateTerminationProtection();
     if (changeSetHasNoChanges(changeSetDescription)) {
-      await this.ioHelper.notify(debug3((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.ioHelper.notify(debug3((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.ioHelper.notify(warn2(
+        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.",
@@ -6063,7 +6336,7 @@ var FullCloudFormationDeployment = class {
       };
     }
     if (!execute) {
-      await this.ioHelper.notify(info3((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
       )));
@@ -6090,8 +6363,8 @@ var FullCloudFormationDeployment = class {
   }
   async createChangeSet(changeSetName, willExecute, importExistingResources) {
     await this.cleanupOldChangeset(changeSetName);
-    await this.ioHelper.notify(debug3(`Attempting to create ChangeSet with name ${changeSetName} to ${this.verb} stack ${this.stackName}`));
-    await this.ioHelper.notify(info3((0, import_util25.format)("%s: creating CloudFormation changeset...", chalk9.bold(this.stackName))));
+    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,
@@ -6102,20 +6375,20 @@ var FullCloudFormationDeployment = class {
       ImportExistingResources: importExistingResources,
       ...this.commonPrepareOptions()
     });
-    await this.ioHelper.notify(debug3((0, import_util25.format)("Initiated creation of changeset: %s; waiting for it to finish creating...", changeSet.Id)));
+    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.ioHelper.notify(debug3((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.ioHelper.notify(debug3(
+    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,
@@ -6127,7 +6400,7 @@ var FullCloudFormationDeployment = class {
   }
   async cleanupOldChangeset(changeSetName) {
     if (this.cloudFormationStack.exists) {
-      await this.ioHelper.notify(debug3(`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
@@ -6137,7 +6410,7 @@ var FullCloudFormationDeployment = class {
   async updateTerminationProtection() {
     const terminationProtection = this.stackArtifact.terminationProtection ?? false;
     if (!!this.cloudFormationStack.terminationProtection !== terminationProtection) {
-      await this.ioHelper.notify(debug3(
+      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,
@@ -6149,11 +6422,11 @@ var FullCloudFormationDeployment = class {
         StackName: this.stackName,
         EnableTerminationProtection: terminationProtection
       });
-      await this.ioHelper.notify(debug3((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.ioHelper.notify(info3((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();
@@ -6166,7 +6439,7 @@ var FullCloudFormationDeployment = class {
         });
       } catch (err) {
         if (err.message === "No updates are to be performed.") {
-          await this.ioHelper.notify(debug3((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,
@@ -6211,7 +6484,7 @@ var FullCloudFormationDeployment = class {
     } finally {
       await monitor.stop();
     }
-    debug3((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,
@@ -6277,45 +6550,45 @@ async function destroyStack(options, ioHelper) {
 }
 async function canSkipDeploy(deployStackOptions, cloudFormationStack, parameterChanges, ioHelper) {
   const deployName = deployStackOptions.deployName || deployStackOptions.stack.stackName;
-  await ioHelper.notify(debug3(`${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 ioHelper.notify(debug3(`${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 ioHelper.notify(debug3(`${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 ioHelper.notify(debug3(`${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 ioHelper.notify(debug3(`${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 ioHelper.notify(debug3(`${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 ioHelper.notify(debug3(`${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 ioHelper.notify(debug3(`${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 ioHelper.notify(debug3(`${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 ioHelper.notify(debug3(`${deployName}: parameters have changed`));
+      await ioHelper.notify(IO.DEFAULT_TOOLKIT_DEBUG.msg(`${deployName}: parameters have changed`));
     }
     return false;
   }
   if (cloudFormationStack.stackStatus.isFailure) {
-    await ioHelper.notify(debug3(`${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;
@@ -6422,18 +6695,21 @@ function loadTreeFromDir(outdir) {
 
 // ../../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
       {
@@ -6451,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 [{
@@ -6466,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];
         }
       }
@@ -6486,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;
   }
   /**
@@ -6495,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) {
@@ -6513,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) {
@@ -6528,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 [];
@@ -6558,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.
@@ -6595,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) {
-      debug2(`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) {
-      info2("");
-      info2("NOTICES         (What's this? https://github.com/aws/aws-cdk/wiki/CLI-Notices)");
-      info2("");
+      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":
-            error2(formatted);
+            void this.ioMessages.notify(IO.CDK_TOOLKIT_E0101.msg(formatted));
             break;
           default:
-            info2(formatted);
+            void this.ioMessages.notify(IO.CDK_TOOLKIT_I0101.msg(formatted));
+            break;
         }
-        info2("");
       }
-      info2(`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) {
-      info2("");
-      info2(`There are ${filteredNotices.length} unacknowledged notice(s).`);
+      void this.ioMessages.notify(IO.CDK_TOOLKIT_I0100.msg(
+        `
+There are ${filteredNotices.length} unacknowledged notice(s).`
+      ));
     }
   }
 };
@@ -6683,7 +6963,8 @@ var FilteredNotice = class {
   }
 };
 var WebsiteNoticeDataSource = class {
-  constructor(options = {}) {
+  constructor(ioMessages, options = {}) {
+    this.ioMessages = ioMessages;
     this.options = options;
   }
   fetch() {
@@ -6716,7 +6997,7 @@ var WebsiteNoticeDataSource = class {
                   if (!data) {
                     throw new ToolkitError("'notices' key is missing");
                   }
-                  debug2("Notices refreshed");
+                  this.ioMessages.debug("Notices refreshed");
                   resolve3(data ?? []);
                 } catch (e) {
                   reject(new ToolkitError(`Failed to parse notices: ${formatErrorMessage(e)}`));
@@ -6740,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;
@@ -6754,7 +7036,7 @@ var CachedDataSource = class {
       await this.save(freshData);
       return freshData.notices;
     } else {
-      debug2(`Reading cached notices from ${this.fileName}`);
+      this.ioMessages.debug(`Reading cached notices from ${this.fileName}`);
       return data;
     }
   }
@@ -6765,7 +7047,7 @@ var CachedDataSource = class {
         notices: await this.dataSource.fetch()
       };
     } catch (e) {
-      debug2(`Could not refresh notices: ${e}`);
+      this.ioMessages.debug(`Could not refresh notices: ${e}`);
       return {
         expiration: Date.now() + TIME_TO_LIVE_ERROR,
         notices: []
@@ -6780,7 +7062,7 @@ var CachedDataSource = class {
     try {
       return fs11.existsSync(this.fileName) ? await fs11.readJSON(this.fileName) : defaultValue;
     } catch (e) {
-      debug2(`Failed to load notices from cache: ${e}`);
+      this.ioMessages.debug(`Failed to load notices from cache: ${e}`);
       return defaultValue;
     }
   }
@@ -6788,7 +7070,7 @@ var CachedDataSource = class {
     try {
       await fs11.writeJSON(this.fileName, cached2);
     } catch (e) {
-      debug2(`Failed to store notices in the cache: ${e}`);
+      this.ioMessages.debug(`Failed to store notices in the cache: ${e}`);
     }
   }
 };
@@ -7970,7 +8252,7 @@ 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 uuid4 = __toESM(require("uuid"));
 var CloudWatchLogEventMonitor = class {
@@ -8089,7 +8371,7 @@ var CloudWatchLogEventMonitor = class {
    */
   async print(event) {
     await this.ioHelper.notify(IO.CDK_TOOLKIT_I5033.msg(
-      util7.format(
+      util8.format(
         "[%s] %s %s",
         chalk15.blue(event.logGroupName),
         chalk15.yellow(event.timestamp.toLocaleTimeString()),
@@ -8157,8 +8439,7 @@ async function findCloudWatchLogGroups(sdkProvider, ioHelper, stackArtifact) {
   }
   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,