@aws-cdk/toolkit-lib 0.1.4 → 0.1.5

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,
@@ -104,14 +103,15 @@ var chalk4 = __toESM(require("chalk"));
 
 // ../../aws-cdk/lib/toolkit/cli-io-host.ts
 var util3 = __toESM(require("node:util"));
+var import_cloud_assembly_schema = require("@aws-cdk/cloud-assembly-schema");
 var chalk3 = __toESM(require("chalk"));
 var promptly = __toESM(require("promptly"));
 
 // ../tmp-toolkit-helpers/src/api/toolkit-error.ts
-var TOOLKIT_ERROR_SYMBOL = Symbol.for("@aws-cdk/toolkit.ToolkitError");
-var AUTHENTICATION_ERROR_SYMBOL = Symbol.for("@aws-cdk/toolkit.AuthenticationError");
-var ASSEMBLY_ERROR_SYMBOL = Symbol.for("@aws-cdk/toolkit.AssemblyError");
-var CONTEXT_PROVIDER_ERROR_SYMBOL = Symbol.for("@aws-cdk/toolkit.ContextProviderError");
+var TOOLKIT_ERROR_SYMBOL = Symbol.for("@aws-cdk/toolkit-lib.ToolkitError");
+var AUTHENTICATION_ERROR_SYMBOL = Symbol.for("@aws-cdk/toolkit-lib.AuthenticationError");
+var ASSEMBLY_ERROR_SYMBOL = Symbol.for("@aws-cdk/toolkit-lib.AssemblyError");
+var CONTEXT_PROVIDER_ERROR_SYMBOL = Symbol.for("@aws-cdk/toolkit-lib.ContextProviderError");
 var ToolkitError = class _ToolkitError extends Error {
   /**
    * Determines if a given error is an instance of ToolkitError.
@@ -141,46 +141,91 @@ 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 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";
@@ -412,20 +445,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 +467,10 @@ async function parallelPromises(n, promises) {
     }
     function start(fn) {
       count += 1;
-      fn().then((result) => {
-        ret.push(result);
+      fn().then((result2) => {
+        ret.push(result2);
       }).catch((e) => {
-        error3 = e;
+        error4 = e;
       }).finally(() => {
         count -= 1;
         tick();
@@ -524,15 +557,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 +578,465 @@ function millisecondsToSeconds(num) {
 // ../tmp-toolkit-helpers/src/util/version-range.ts
 var semver = __toESM(require("semver"));
 
+// ../tmp-toolkit-helpers/src/api/io/private/level-priority.ts
+var levels = [
+  "trace",
+  "debug",
+  "info",
+  "warn",
+  "result",
+  "error"
+];
+var orderedLevels = Object.fromEntries(Object.entries(levels).map((a) => a.reverse()));
+function compareFn(a, b) {
+  return orderedLevels[a] - orderedLevels[b];
+}
+function isMessageRelevantForLevel(msg, level) {
+  return compareFn(msg.level, level) >= 0;
+}
+
+// ../tmp-toolkit-helpers/src/api/io/private/message-maker.ts
+function message(level, details) {
+  const maker = (text, data) => ({
+    time: /* @__PURE__ */ new Date(),
+    level,
+    code: details.code,
+    message: text,
+    data
+  });
+  return {
+    ...details,
+    level,
+    msg: maker,
+    is: (m) => m.code === details.code
+  };
+}
+var trace = (details) => message("trace", details);
+var debug = (details) => message("debug", details);
+var info = (details) => message("info", details);
+var warn = (details) => message("warn", details);
+var error = (details) => message("error", details);
+var result = (details) => message("result", details);
+function request(level, details) {
+  const maker = (text, data) => ({
+    time: /* @__PURE__ */ new Date(),
+    level,
+    code: details.code,
+    message: text,
+    data,
+    defaultResponse: details.defaultResponse
+  });
+  return {
+    ...details,
+    level,
+    req: maker
+  };
+}
+var confirm = (details) => request("info", {
+  ...details,
+  defaultResponse: true
+});
+
+// ../tmp-toolkit-helpers/src/api/io/private/messages.ts
+var IO = {
+  // Defaults
+  DEFAULT_TOOLKIT_INFO: info({
+    code: "CDK_TOOLKIT_I0000",
+    description: "Default info messages emitted from the Toolkit"
+  }),
+  DEFAULT_TOOLKIT_DEBUG: debug({
+    code: "CDK_TOOLKIT_I0000",
+    description: "Default debug messages emitted from the Toolkit"
+  }),
+  DEFAULT_TOOLKIT_WARN: warn({
+    code: "CDK_TOOLKIT_W0000",
+    description: "Default warning messages emitted from the Toolkit"
+  }),
+  // 1: Synth
+  CDK_TOOLKIT_I1000: info({
+    code: "CDK_TOOLKIT_I1000",
+    description: "Provides synthesis times.",
+    interface: "Duration"
+  }),
+  CDK_TOOLKIT_I1001: trace({
+    code: "CDK_TOOLKIT_I1001",
+    description: "Cloud Assembly synthesis is starting",
+    interface: "StackSelectionDetails"
+  }),
+  CDK_TOOLKIT_I1901: result({
+    code: "CDK_TOOLKIT_I1901",
+    description: "Provides stack data",
+    interface: "StackAndAssemblyData"
+  }),
+  CDK_TOOLKIT_I1902: result({
+    code: "CDK_TOOLKIT_I1902",
+    description: "Successfully deployed stacks",
+    interface: "AssemblyData"
+  }),
+  // 2: List
+  CDK_TOOLKIT_I2901: result({
+    code: "CDK_TOOLKIT_I2901",
+    description: "Provides details on the selected stacks and their dependencies",
+    interface: "StackDetailsPayload"
+  }),
+  // 3: Import & Migrate
+  CDK_TOOLKIT_E3900: error({
+    code: "CDK_TOOLKIT_E3900",
+    description: "Resource import failed"
+  }),
+  // 4: Diff
+  // 5: Deploy & Watch
+  CDK_TOOLKIT_I5000: info({
+    code: "CDK_TOOLKIT_I5000",
+    description: "Provides deployment times",
+    interface: "Duration"
+  }),
+  CDK_TOOLKIT_I5001: info({
+    code: "CDK_TOOLKIT_I5001",
+    description: "Provides total time in deploy action, including synth and rollback",
+    interface: "Duration"
+  }),
+  CDK_TOOLKIT_I5002: info({
+    code: "CDK_TOOLKIT_I5002",
+    description: "Provides time for resource migration"
+  }),
+  CDK_TOOLKIT_W5021: warn({
+    code: "CDK_TOOLKIT_W5021",
+    description: "Empty non-existent stack, deployment is skipped"
+  }),
+  CDK_TOOLKIT_W5022: warn({
+    code: "CDK_TOOLKIT_W5022",
+    description: "Empty existing stack, stack will be destroyed"
+  }),
+  CDK_TOOLKIT_I5031: info({
+    code: "CDK_TOOLKIT_I5031",
+    description: "Informs about any log groups that are traced as part of the deployment"
+  }),
+  CDK_TOOLKIT_I5032: debug({
+    code: "CDK_TOOLKIT_I5032",
+    description: "Start monitoring log groups",
+    interface: "CloudWatchLogMonitorControlEvent"
+  }),
+  CDK_TOOLKIT_I5033: info({
+    code: "CDK_TOOLKIT_I5033",
+    description: "A log event received from Cloud Watch",
+    interface: "CloudWatchLogEvent"
+  }),
+  CDK_TOOLKIT_I5034: debug({
+    code: "CDK_TOOLKIT_I5034",
+    description: "Stop monitoring log groups",
+    interface: "CloudWatchLogMonitorControlEvent"
+  }),
+  CDK_TOOLKIT_E5035: error({
+    code: "CDK_TOOLKIT_E5035",
+    description: "A log monitoring error",
+    interface: "ErrorPayload"
+  }),
+  CDK_TOOLKIT_I5050: confirm({
+    code: "CDK_TOOLKIT_I5050",
+    description: "Confirm rollback during deployment",
+    interface: "ConfirmationRequest"
+  }),
+  CDK_TOOLKIT_I5060: confirm({
+    code: "CDK_TOOLKIT_I5060",
+    description: "Confirm deploy security sensitive changes",
+    interface: "DeployConfirmationRequest"
+  }),
+  CDK_TOOLKIT_I5100: info({
+    code: "CDK_TOOLKIT_I5100",
+    description: "Stack deploy progress",
+    interface: "StackDeployProgress"
+  }),
+  // Assets
+  CDK_TOOLKIT_I5210: trace({
+    code: "CDK_TOOLKIT_I5210",
+    description: "Started building a specific asset",
+    interface: "BuildAsset"
+  }),
+  CDK_TOOLKIT_I5211: trace({
+    code: "CDK_TOOLKIT_I5211",
+    description: "Building the asset has completed",
+    interface: "Duration"
+  }),
+  CDK_TOOLKIT_I5220: trace({
+    code: "CDK_TOOLKIT_I5220",
+    description: "Started publishing a specific asset",
+    interface: "PublishAsset"
+  }),
+  CDK_TOOLKIT_I5221: trace({
+    code: "CDK_TOOLKIT_I5221",
+    description: "Publishing the asset has completed",
+    interface: "Duration"
+  }),
+  // Watch
+  CDK_TOOLKIT_I5310: debug({
+    code: "CDK_TOOLKIT_I5310",
+    description: "The computed settings used for file watching",
+    interface: "WatchSettings"
+  }),
+  CDK_TOOLKIT_I5311: info({
+    code: "CDK_TOOLKIT_I5311",
+    description: "File watching started",
+    interface: "FileWatchEvent"
+  }),
+  CDK_TOOLKIT_I5312: info({
+    code: "CDK_TOOLKIT_I5312",
+    description: "File event detected, starting deployment",
+    interface: "FileWatchEvent"
+  }),
+  CDK_TOOLKIT_I5313: info({
+    code: "CDK_TOOLKIT_I5313",
+    description: "File event detected during active deployment, changes are queued",
+    interface: "FileWatchEvent"
+  }),
+  CDK_TOOLKIT_I5314: info({
+    code: "CDK_TOOLKIT_I5314",
+    description: "Initial watch deployment started"
+  }),
+  CDK_TOOLKIT_I5315: info({
+    code: "CDK_TOOLKIT_I5315",
+    description: "Queued watch deployment started"
+  }),
+  // Stack Monitor
+  CDK_TOOLKIT_I5501: info({
+    code: "CDK_TOOLKIT_I5501",
+    description: "Stack Monitoring: Start monitoring of a single stack",
+    interface: "StackMonitoringControlEvent"
+  }),
+  CDK_TOOLKIT_I5502: info({
+    code: "CDK_TOOLKIT_I5502",
+    description: "Stack Monitoring: Activity event for a single stack",
+    interface: "StackActivity"
+  }),
+  CDK_TOOLKIT_I5503: info({
+    code: "CDK_TOOLKIT_I5503",
+    description: "Stack Monitoring: Finished monitoring of a single stack",
+    interface: "StackMonitoringControlEvent"
+  }),
+  // Success
+  CDK_TOOLKIT_I5900: result({
+    code: "CDK_TOOLKIT_I5900",
+    description: "Deployment results on success",
+    interface: "SuccessfulDeployStackResult"
+  }),
+  CDK_TOOLKIT_I5901: info({
+    code: "CDK_TOOLKIT_I5901",
+    description: "Generic deployment success messages"
+  }),
+  CDK_TOOLKIT_W5400: warn({
+    code: "CDK_TOOLKIT_W5400",
+    description: "Hotswap disclosure message"
+  }),
+  // errors
+  CDK_TOOLKIT_E5001: error({
+    code: "CDK_TOOLKIT_E5001",
+    description: "No stacks found"
+  }),
+  CDK_TOOLKIT_E5500: error({
+    code: "CDK_TOOLKIT_E5500",
+    description: "Stack Monitoring error",
+    interface: "ErrorPayload"
+  }),
+  // 6: Rollback
+  CDK_TOOLKIT_I6000: info({
+    code: "CDK_TOOLKIT_I6000",
+    description: "Provides rollback times",
+    interface: "Duration"
+  }),
+  CDK_TOOLKIT_I6100: info({
+    code: "CDK_TOOLKIT_I6100",
+    description: "Stack rollback progress",
+    interface: "StackRollbackProgress"
+  }),
+  CDK_TOOLKIT_E6001: error({
+    code: "CDK_TOOLKIT_E6001",
+    description: "No stacks found"
+  }),
+  CDK_TOOLKIT_E6900: error({
+    code: "CDK_TOOLKIT_E6900",
+    description: "Rollback failed",
+    interface: "ErrorPayload"
+  }),
+  // 7: Destroy
+  CDK_TOOLKIT_I7000: info({
+    code: "CDK_TOOLKIT_I7000",
+    description: "Provides destroy times",
+    interface: "Duration"
+  }),
+  CDK_TOOLKIT_I7001: trace({
+    code: "CDK_TOOLKIT_I7001",
+    description: "Provides destroy time for a single stack",
+    interface: "Duration"
+  }),
+  CDK_TOOLKIT_I7010: confirm({
+    code: "CDK_TOOLKIT_I7010",
+    description: "Confirm destroy stacks",
+    interface: "ConfirmationRequest"
+  }),
+  CDK_TOOLKIT_I7100: info({
+    code: "CDK_TOOLKIT_I7100",
+    description: "Stack destroy progress",
+    interface: "StackDestroyProgress"
+  }),
+  CDK_TOOLKIT_I7101: trace({
+    code: "CDK_TOOLKIT_I7101",
+    description: "Start stack destroying",
+    interface: "StackDestroy"
+  }),
+  CDK_TOOLKIT_I7900: result({
+    code: "CDK_TOOLKIT_I7900",
+    description: "Stack deletion succeeded",
+    interface: "cxapi.CloudFormationStackArtifact"
+  }),
+  CDK_TOOLKIT_E7010: error({
+    code: "CDK_TOOLKIT_E7010",
+    description: "Action was aborted due to negative confirmation of request"
+  }),
+  CDK_TOOLKIT_E7900: error({
+    code: "CDK_TOOLKIT_E7900",
+    description: "Stack deletion failed",
+    interface: "ErrorPayload"
+  }),
+  // 9: Bootstrap
+  CDK_TOOLKIT_I9000: info({
+    code: "CDK_TOOLKIT_I9000",
+    description: "Provides bootstrap times",
+    interface: "Duration"
+  }),
+  CDK_TOOLKIT_I9100: info({
+    code: "CDK_TOOLKIT_I9100",
+    description: "Bootstrap progress",
+    interface: "BootstrapEnvironmentProgress"
+  }),
+  CDK_TOOLKIT_I9900: result({
+    code: "CDK_TOOLKIT_I9900",
+    description: "Bootstrap results on success",
+    interface: "cxapi.Environment"
+  }),
+  CDK_TOOLKIT_E9900: error({
+    code: "CDK_TOOLKIT_E9900",
+    description: "Bootstrap failed",
+    interface: "ErrorPayload"
+  }),
+  // Assembly codes
+  CDK_ASSEMBLY_I0010: debug({
+    code: "CDK_ASSEMBLY_I0010",
+    description: "Generic environment preparation debug messages"
+  }),
+  CDK_ASSEMBLY_W0010: warn({
+    code: "CDK_ASSEMBLY_W0010",
+    description: "Emitted if the found framework version does not support context overflow"
+  }),
+  CDK_ASSEMBLY_I0042: debug({
+    code: "CDK_ASSEMBLY_I0042",
+    description: "Writing updated context",
+    interface: "UpdatedContext"
+  }),
+  CDK_ASSEMBLY_I0240: debug({
+    code: "CDK_ASSEMBLY_I0240",
+    description: "Context lookup was stopped as no further progress was made. ",
+    interface: "MissingContext"
+  }),
+  CDK_ASSEMBLY_I0241: debug({
+    code: "CDK_ASSEMBLY_I0241",
+    description: "Fetching missing context. This is an iterative message that may appear multiple times with different missing keys.",
+    interface: "MissingContext"
+  }),
+  CDK_ASSEMBLY_I1000: debug({
+    code: "CDK_ASSEMBLY_I1000",
+    description: "Cloud assembly output starts"
+  }),
+  CDK_ASSEMBLY_I1001: info({
+    code: "CDK_ASSEMBLY_I1001",
+    description: "Output lines emitted by the cloud assembly to stdout"
+  }),
+  CDK_ASSEMBLY_E1002: error({
+    code: "CDK_ASSEMBLY_E1002",
+    description: "Output lines emitted by the cloud assembly to stderr"
+  }),
+  CDK_ASSEMBLY_I1003: info({
+    code: "CDK_ASSEMBLY_I1003",
+    description: "Cloud assembly output finished"
+  }),
+  CDK_ASSEMBLY_E1111: error({
+    code: "CDK_ASSEMBLY_E1111",
+    description: "Incompatible CDK CLI version. Upgrade needed.",
+    interface: "ErrorPayload"
+  }),
+  CDK_ASSEMBLY_I0150: debug({
+    code: "CDK_ASSEMBLY_I0150",
+    description: "Indicates the use of a pre-synthesized cloud assembly directory"
+  }),
+  // Assembly Annotations
+  CDK_ASSEMBLY_I9999: info({
+    code: "CDK_ASSEMBLY_I9999",
+    description: "Annotations emitted by the cloud assembly",
+    interface: "cxapi.SynthesisMessage"
+  }),
+  CDK_ASSEMBLY_W9999: warn({
+    code: "CDK_ASSEMBLY_W9999",
+    description: "Warnings emitted by the cloud assembly",
+    interface: "cxapi.SynthesisMessage"
+  }),
+  CDK_ASSEMBLY_E9999: error({
+    code: "CDK_ASSEMBLY_E9999",
+    description: "Errors emitted by the cloud assembly",
+    interface: "cxapi.SynthesisMessage"
+  }),
+  // SDK codes
+  CDK_SDK_I0000: trace({
+    code: "CDK_SDK_I0000",
+    description: "An SDK message."
+  }),
+  CDK_SDK_I0100: trace({
+    code: "CDK_SDK_I0100",
+    description: "An SDK trace. SDK traces are emitted as traces to the IoHost, but contain the original SDK logging level.",
+    interface: "SdkTrace"
+  })
+};
+var SPAN = {
+  SYNTH_ASSEMBLY: {
+    name: "Synthesis",
+    start: IO.CDK_TOOLKIT_I1001,
+    end: IO.CDK_TOOLKIT_I1000
+  },
+  DEPLOY_STACK: {
+    name: "Deployment",
+    start: IO.CDK_TOOLKIT_I5100,
+    end: IO.CDK_TOOLKIT_I5001
+  },
+  ROLLBACK_STACK: {
+    name: "Rollback",
+    start: IO.CDK_TOOLKIT_I6100,
+    end: IO.CDK_TOOLKIT_I6000
+  },
+  DESTROY_STACK: {
+    name: "Destroy",
+    start: IO.CDK_TOOLKIT_I7100,
+    end: IO.CDK_TOOLKIT_I7001
+  },
+  DESTROY_ACTION: {
+    name: "Destroy",
+    start: IO.CDK_TOOLKIT_I7101,
+    end: IO.CDK_TOOLKIT_I7000
+  },
+  BOOTSTRAP_SINGLE: {
+    name: "Bootstrap",
+    start: IO.CDK_TOOLKIT_I9100,
+    end: IO.CDK_TOOLKIT_I9000
+  },
+  BUILD_ASSET: {
+    name: "Build Asset",
+    start: IO.CDK_TOOLKIT_I5210,
+    end: IO.CDK_TOOLKIT_I5211
+  },
+  PUBLISH_ASSET: {
+    name: "Publish Asset",
+    start: IO.CDK_TOOLKIT_I5220,
+    end: IO.CDK_TOOLKIT_I5221
+  }
+};
+
 // ../../aws-cdk/lib/cli/activity-printer/base.ts
 var ActivityPrinterBase = class {
   constructor(props) {
@@ -581,14 +1064,14 @@ var ActivityPrinterBase = class {
    * Receive a stack activity message
    */
   notify(msg) {
-    switch (msg.code) {
-      case "CDK_TOOLKIT_I5501":
+    switch (true) {
+      case IO.CDK_TOOLKIT_I5501.is(msg):
         this.start(msg.data);
         break;
-      case "CDK_TOOLKIT_I5502":
+      case IO.CDK_TOOLKIT_I5502.is(msg):
         this.activity(msg.data);
         break;
-      case "CDK_TOOLKIT_I5503":
+      case IO.CDK_TOOLKIT_I5503.is(msg):
         this.stop();
         break;
       default:
@@ -884,9 +1367,9 @@ var CurrentActivityPrinter = class _CurrentActivityPrinter extends ActivityPrint
           this.failureReasonOnNextLine(failure)
         )
       );
-      const trace3 = failure.metadata?.entry?.trace;
-      if (trace3) {
-        lines.push(chalk2.red(`	${trace3.join("\n	\\_ ")}
+      const trace4 = failure.metadata?.entry?.trace;
+      if (trace4) {
+        lines.push(chalk2.red(`	${trace4.join("\n	\\_ ")}
 `));
       }
     }
@@ -944,24 +1427,17 @@ function shorten(maxWidth, p) {
 }
 
 // ../../aws-cdk/lib/toolkit/cli-io-host.ts
-var levelPriority = {
-  error: 0,
-  result: 1,
-  warn: 2,
-  info: 3,
-  debug: 4,
-  trace: 5
-};
 var CliIoHost = class _CliIoHost {
   constructor(props = {}) {
     this._progress = "bar" /* BAR */;
     // Corked Logging
     this.corkedCounter = 0;
     this.corkedLoggingBuffer = [];
-    this._currentAction = props.currentAction ?? "none";
-    this._isTTY = props.isTTY ?? process.stdout.isTTY ?? false;
-    this._logLevel = props.logLevel ?? "info";
-    this._isCI = props.isCI ?? isCI();
+    this.currentAction = props.currentAction ?? "none";
+    this.isTTY = props.isTTY ?? process.stdout.isTTY ?? false;
+    this.logLevel = props.logLevel ?? "info";
+    this.isCI = props.isCI ?? isCI();
+    this.requireDeployApproval = props.requireDeployApproval ?? import_cloud_assembly_schema.RequireApproval.BROADENING;
     this.stackProgress = props.stackProgress ?? "bar" /* BAR */;
   }
   /**
@@ -997,7 +1473,7 @@ var CliIoHost = class _CliIoHost {
     if (this._progress === "events" /* EVENTS */) {
       return this._progress;
     }
-    const verboseLogging = levelPriority[this.logLevel] > levelPriority.info;
+    const verboseLogging = isMessageRelevantForLevel({ level: "debug" }, this.logLevel);
     if (verboseLogging) {
       return "events" /* EVENTS */;
     }
@@ -1011,60 +1487,6 @@ var CliIoHost = class _CliIoHost {
     }
     return this._progress;
   }
-  /**
-   * The current action being performed by the CLI.
-   */
-  get currentAction() {
-    return this._currentAction;
-  }
-  /**
-   * Sets the current action being performed by the CLI.
-   *
-   * @param action The action being performed by the CLI.
-   */
-  set currentAction(action) {
-    this._currentAction = action;
-  }
-  /**
-   * Whether the host can use interactions and message styling.
-   */
-  get isTTY() {
-    return this._isTTY;
-  }
-  /**
-   * Set TTY mode, i.e can the host use interactions and message styling.
-   *
-   * @param value set TTY mode
-   */
-  set isTTY(value) {
-    this._isTTY = value;
-  }
-  /**
-   * Whether the CliIoHost is running in CI mode. In CI mode, all non-error output goes to stdout instead of stderr.
-   */
-  get isCI() {
-    return this._isCI;
-  }
-  /**
-   * Set the CI mode. In CI mode, all non-error output goes to stdout instead of stderr.
-   * @param value set the CI mode
-   */
-  set isCI(value) {
-    this._isCI = value;
-  }
-  /**
-   * The current threshold. Messages with a lower priority level will be ignored.
-   */
-  get logLevel() {
-    return this._logLevel;
-  }
-  /**
-   * Sets the current threshold. Messages with a lower priority level will be ignored.
-   * @param level The new log level threshold
-   */
-  set logLevel(level) {
-    this._logLevel = level;
-  }
   /**
    * Executes a block of code with corked logging. All log messages during execution
    * are buffered and only written when all nested cork blocks complete (when CORK_COUNTER reaches 0).
@@ -1102,7 +1524,7 @@ var CliIoHost = class _CliIoHost {
       await this.activityPrinter.notify(msg);
       return;
     }
-    if (levelPriority[msg.level] > levelPriority[this.logLevel]) {
+    if (!isMessageRelevantForLevel(msg, this.logLevel)) {
       return;
     }
     if (this.corkedCounter > 0) {
@@ -1123,6 +1545,27 @@ var CliIoHost = class _CliIoHost {
       "CDK_TOOLKIT_I5503"
     ].includes(msg.code);
   }
+  /**
+   * Detect special messages encode information about whether or not
+   * they require approval
+   */
+  skipApprovalStep(msg) {
+    const approvalToolkitCodes = ["CDK_TOOLKIT_I5060"];
+    if (!approvalToolkitCodes.includes(msg.code)) {
+      false;
+    }
+    switch (this.requireDeployApproval) {
+      // Never require approval
+      case import_cloud_assembly_schema.RequireApproval.NEVER:
+        return true;
+      // Always require approval
+      case import_cloud_assembly_schema.RequireApproval.ANYCHANGE:
+        return false;
+      // Require approval if changes include broadening permissions
+      case import_cloud_assembly_schema.RequireApproval.BROADENING:
+        return ["none", "non-broadening"].includes(msg.data?.permissionChangeType);
+    }
+  }
   /**
    * Determines the output stream, based on message level and configuration.
    */
@@ -1160,6 +1603,9 @@ var CliIoHost = class _CliIoHost {
       if (concurrency > 1) {
         throw new ToolkitError(`${motivation}, but concurrency is greater than 1 so we are unable to get a confirmation from the user`);
       }
+      if (this.skipApprovalStep(msg)) {
+        return true;
+      }
       if (isConfirmationPrompt(msg)) {
         const confirmed = await promptly.confirm(`${chalk3.cyan(msg.message)} (y/n)`);
         if (!confirmed) {
@@ -1179,7 +1625,7 @@ var CliIoHost = class _CliIoHost {
    * Formats a message for console output with optional color support
    */
   formatMessage(msg) {
-    let message_text = this._isTTY ? styleMap[msg.level](msg.message) : msg.message;
+    let message_text = this.isTTY ? styleMap[msg.level](msg.message) : msg.message;
     return (msg.level === "debug" || msg.level === "trace" ? `[${this.formatTime(msg.time)}] ${message_text}` : message_text) + "\n";
   }
   /**
@@ -1231,8 +1677,8 @@ function isCI() {
 
 // ../../aws-cdk/lib/logging.ts
 function formatMessageAndLog(level, input, style, ...args) {
-  const { message, code = getDefaultCode(level) } = typeof input === "object" ? input : { message: input };
-  const formattedMessage = args.length > 0 ? util4.format(message, ...args) : message;
+  const { message: message2, code = getDefaultCode(level) } = typeof input === "object" ? input : { message: input };
+  const formattedMessage = args.length > 0 ? util4.format(message2, ...args) : message2;
   const finalMessage = style ? style(formattedMessage) : formattedMessage;
   const ioHost = CliIoHost.instance();
   const ioMessage = {
@@ -1240,7 +1686,8 @@ function formatMessageAndLog(level, input, style, ...args) {
     action: ioHost.currentAction,
     level,
     message: finalMessage,
-    code
+    code,
+    data: void 0
   };
   void ioHost.notify(ioMessage);
 }
@@ -1248,19 +1695,19 @@ function getDefaultCode(level, category = "TOOLKIT") {
   const levelIndicator = level === "error" ? "E" : level === "warn" ? "W" : "I";
   return `CDK_${category}_${levelIndicator}0000`;
 }
-var error = (input, ...args) => {
+var error2 = (input, ...args) => {
   return formatMessageAndLog("error", input, void 0, ...args);
 };
 var warning = (input, ...args) => {
   return formatMessageAndLog("warn", input, void 0, ...args);
 };
-var info = (input, ...args) => {
+var info2 = (input, ...args) => {
   return formatMessageAndLog("info", input, void 0, ...args);
 };
-var debug = (input, ...args) => {
+var debug2 = (input, ...args) => {
   return formatMessageAndLog("debug", input, void 0, ...args);
 };
-var trace = (input, ...args) => {
+var trace2 = (input, ...args) => {
   return formatMessageAndLog("trace", input, void 0, ...args);
 };
 
@@ -1292,7 +1739,7 @@ var AccountAccessKeyCache = class _AccountAccessKeyCache {
   async fetch(accessKeyId, resolver) {
     const cached2 = await this.get(accessKeyId);
     if (cached2) {
-      debug(`Retrieved account ID ${cached2.accountId} from disk cache`);
+      debug2(`Retrieved account ID ${cached2.accountId} from disk cache`);
       return cached2;
     }
     const account = await resolver();
@@ -1408,7 +1855,7 @@ function readIfPossible(filename) {
     }
     return fs4.readFileSync(filename, { encoding: "utf-8" });
   } catch (e) {
-    debug(e);
+    debug2(e);
     return void 0;
   }
 }
@@ -1721,19 +2168,19 @@ var SDK = class {
     return cachedAsync(this, CURRENT_ACCOUNT_KEY, async () => {
       const creds = await this.credProvider();
       return SDK.accountCache.fetch(creds.accessKeyId, async () => {
-        debug("Looking up default account ID from STS");
+        debug2("Looking up default account ID from STS");
         const client = new import_client_sts.STSClient({
           ...this.config,
           retryStrategy: this.stsRetryStrategy
         });
         const command = new import_client_sts.GetCallerIdentityCommand({});
-        const result = await client.send(command);
-        const accountId = result.Account;
-        const partition = result.Arn.split(":")[1];
+        const result2 = await client.send(command);
+        const accountId = result2.Account;
+        const partition = result2.Arn.split(":")[1];
         if (!accountId) {
           throw new AuthenticationError("STS didn't return an account ID");
         }
-        debug("Default account ID:", accountId);
+        debug2("Default account ID:", accountId);
         this._credentialsValidated = true;
         return { accountId, partition };
       });
@@ -1858,7 +2305,7 @@ var AwsCliCompatible = class _AwsCliCompatible {
     const region = process.env.AWS_REGION || process.env.AMAZON_REGION || process.env.AWS_DEFAULT_REGION || process.env.AMAZON_DEFAULT_REGION || await getRegionFromIni(profile) || await regionFromMetadataService();
     if (!region) {
       const usedProfile = !profile ? "" : ` (profile: "${profile}")`;
-      debug(
+      debug2(
         `Unable to determine AWS region from environment or AWS configuration${usedProfile}, defaulting to '${defaultRegion}'`
       );
       return defaultRegion;
@@ -1876,7 +2323,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 +2352,7 @@ function shouldPrioritizeEnv() {
   return false;
 }
 async function regionFromMetadataService() {
-  debug("Looking up AWS region in the EC2 Instance Metadata Service (IMDS).");
+  debug2("Looking up AWS region in the EC2 Instance Metadata Service (IMDS).");
   try {
     const metadataService = new import_ec2_metadata_service.MetadataService({
       httpOptions: {
@@ -1916,20 +2363,20 @@ async function regionFromMetadataService() {
     const document = await metadataService.request("/latest/dynamic/instance-identity/document", {});
     return JSON.parse(document).region;
   } catch (e) {
-    debug(`Unable to retrieve AWS region from IMDS: ${e}`);
+    debug2(`Unable to retrieve AWS region from IMDS: ${e}`);
   }
 }
 async function tokenCodeFn(serialArn) {
-  debug("Require MFA token for serial ARN", serialArn);
+  debug2("Require MFA token for serial ARN", serialArn);
   try {
     const token = await promptly2.prompt(`MFA token for ${serialArn}: `, {
       trim: true,
       default: ""
     });
-    debug("Successfully got MFA token from user");
+    debug2("Successfully got MFA token from user");
     return token;
   } catch (err) {
-    debug("Failed to get MFA token", err);
+    debug2("Failed to get MFA token", err);
     const e = new AuthenticationError(`Error fetching MFA token: ${err.message ?? err}`);
     e.name = "SharedIniFileCredentialsProviderFailure";
     throw e;
@@ -1937,10 +2384,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 +2421,14 @@ var PluginHost = class _PluginHost {
     try {
       const plugin = require(moduleSpec);
       if (!isPlugin(plugin)) {
-        error(`Module ${chalk5.green(moduleSpec)} is not a valid plug-in, or has an unsupported version.`);
+        error2(`Module ${chalk5.green(moduleSpec)} is not a valid plug-in, or has an unsupported version.`);
         throw new ToolkitError(`Module ${moduleSpec} does not define a valid plug-in.`);
       }
       if (plugin.init) {
         plugin.init(this);
       }
     } catch (e) {
-      error(`Unable to load ${chalk5.green(moduleSpec)}: ${e.stack}`);
+      error2(`Unable to load ${chalk5.green(moduleSpec)}: ${e.stack}`);
       throw new ToolkitError(`Unable to load plug-in: ${moduleSpec}: ${e}`);
     }
     function isPlugin(x) {
@@ -2030,7 +2477,7 @@ var PluginHost = class _PluginHost {
    */
   registerContextProviderAlpha(pluginProviderName, provider) {
     if (!isContextProviderPlugin(provider)) {
-      throw new ToolkitError(`Object you gave me does not look like a ContextProviderPlugin: ${(0, import_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 +2510,7 @@ var CredentialPlugins = class {
         available = false;
       }
       if (!available) {
-        debug("Credentials source %s is not available, ignoring it.", source.name);
+        debug2("Credentials source %s is not available, ignoring it.", source.name);
         continue;
       }
       triedSources.push(source);
@@ -2077,7 +2524,7 @@ var CredentialPlugins = class {
       if (!canProvide) {
         continue;
       }
-      debug(`Using ${source.name} credentials for account ${awsAccountId}`);
+      debug2(`Using ${source.name} credentials for account ${awsAccountId}`);
       return {
         credentials: await v3ProviderFromPlugin(() => source.getProvider(awsAccountId, mode, {
           supportsV3Providers: true
@@ -2099,7 +2546,7 @@ async function v3ProviderFromPlugin(producer) {
   } else if (isV2Credentials(initial)) {
     return v3ProviderFromV2Credentials(initial);
   } else {
-    throw new AuthenticationError(`Plugin returned a value that doesn't resemble AWS credentials: ${(0, import_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 +2565,7 @@ function refreshFromPluginProvider(current, producer) {
     if (credentialsAboutToExpire(current)) {
       const newCreds = await producer();
       if (!isV3Credentials(newCreds)) {
-        throw new AuthenticationError(`Plugin initially returned static V3 credentials but now returned something else: ${(0, import_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 +2642,8 @@ var SdkProvider = class {
         throw err;
       }
       if (baseCreds.source === "correctDefault" || baseCreds.source === "plugin") {
-        debug(err.message);
-        const logger = quiet ? debug : warning;
+        debug2(err.message);
+        const logger = quiet ? debug2 : warning;
         logger(
           `${fmtObtainedCredentials(baseCreds)} could not be used to assume '${options.assumeRoleArn}', but are for the right account. Proceeding anyway.`
         );
@@ -2269,7 +2716,7 @@ var SdkProvider = class {
           );
           return void 0;
         }
-        debug(`Unable to determine the default AWS account (${e.name}): ${formatErrorMessage(e)}`);
+        debug2(`Unable to determine the default AWS account (${e.name}): ${formatErrorMessage(e)}`);
         return void 0;
       }
     });
@@ -2316,7 +2763,7 @@ var SdkProvider = class {
    * otherwise it will be the current credentials.
    */
   async withAssumedRole(mainCredentials, roleArn, externalId, additionalOptions, region) {
-    debug(`Assuming role '${roleArn}'.`);
+    debug2(`Assuming role '${roleArn}'.`);
     region = region ?? this.defaultRegion;
     const sourceDescription = fmtObtainedCredentials(mainCredentials);
     try {
@@ -2343,7 +2790,7 @@ var SdkProvider = class {
       if (err.name === "ExpiredToken") {
         throw err;
       }
-      debug(`Assuming role failed: ${err.message}`);
+      debug2(`Assuming role failed: ${err.message}`);
       throw new AuthenticationError(
         [
           "Could not assume role in target account",
@@ -2406,42 +2853,6 @@ async function initContextProviderSdk(aws, options) {
   return (await aws.forEnvironment(import_cx_api.EnvironmentUtils.make(account, region), 0 /* ForReading */, creds)).sdk;
 }
 
-// ../../aws-cdk/lib/api/aws-auth/sdk-logger.ts
-var import_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 +3084,6 @@ function formatMessage(msg, category = "TOOLKIT") {
   return {
     time: /* @__PURE__ */ new Date(),
     level: msg.level,
-    action: msg.action,
     code: msg.code ?? defaultMessageCode(msg.level, category),
     message: msg.message,
     data: msg.data
@@ -2683,56 +3093,51 @@ function defaultMessageCode(level, category = "TOOLKIT") {
   const levelIndicator = level === "error" ? "E" : level === "warn" ? "W" : "I";
   return `CDK_${category}_${levelIndicator}0000`;
 }
-var error2 = (action, message, code, payload) => {
+var error3 = (message2, code, payload) => {
   return formatMessage({
     level: "error",
-    action,
     code,
-    message,
+    message: message2,
     data: payload
   });
 };
-var warn = (action, message, code, payload) => {
+var warn2 = (message2, code, payload) => {
   return formatMessage({
     level: "warn",
-    action,
     code,
-    message,
+    message: message2,
     data: payload
   });
 };
-var info2 = (action, message, code, payload) => {
+var info3 = (message2, code, payload) => {
   return formatMessage({
     level: "info",
-    action,
     code,
-    message,
+    message: message2,
     data: payload
   });
 };
-var debug2 = (action, message, code, payload) => {
+var debug3 = (message2, code, payload) => {
   return formatMessage({
     level: "debug",
-    action,
     code,
-    message,
+    message: message2,
     data: payload
   });
 };
-var trace2 = (action, message, code, payload) => {
+var trace3 = (message2, code, payload) => {
   return formatMessage({
     level: "trace",
-    action,
     code,
-    message,
+    message: message2,
     data: payload
   });
 };
 
 // ../../aws-cdk/lib/api/stack-events/stack-activity-monitor.ts
 var util6 = __toESM(require("util"));
-var import_cloud_assembly_schema = require("@aws-cdk/cloud-assembly-schema");
-var uuid = __toESM(require("uuid"));
+var import_cloud_assembly_schema2 = require("@aws-cdk/cloud-assembly-schema");
+var uuid2 = __toESM(require("uuid"));
 
 // ../../aws-cdk/lib/api/stack-events/stack-event-poller.ts
 var StackEventPoller = class _StackEventPoller {
@@ -2932,8 +3337,7 @@ var StackProgressMonitor = class {
 var StackActivityMonitor = class {
   constructor({
     cfn,
-    ioHost,
-    action,
+    ioHelper,
     stack,
     stackName,
     resourcesTotal,
@@ -2941,8 +3345,7 @@ var StackActivityMonitor = class {
     pollingInterval = 2e3
   }) {
     this.errors = [];
-    this.ioHost = ioHost;
-    this.action = action;
+    this.ioHelper = ioHelper;
     this.stack = stack;
     this.stackName = stackName;
     this.progressMonitor = new StackProgressMonitor(resourcesTotal);
@@ -2953,8 +3356,8 @@ var StackActivityMonitor = class {
     });
   }
   async start() {
-    this.monitorId = uuid.v4();
-    await this.ioHost.notify(debug2(this.action, `Deploying ${this.stackName}`, "CDK_TOOLKIT_I5501", {
+    this.monitorId = uuid2.v4();
+    await this.ioHelper.notify(debug3(`Deploying ${this.stackName}`, "CDK_TOOLKIT_I5501", {
       deployment: this.monitorId,
       stack: this.stack,
       stackName: this.stackName,
@@ -2970,7 +3373,7 @@ var StackActivityMonitor = class {
       clearTimeout(this.tickTimer);
     }
     await this.finalPollToEnd(oldMonitorId);
-    await this.ioHost.notify(debug2(this.action, `Completed ${this.stackName}`, "CDK_TOOLKIT_I5503", {
+    await this.ioHelper.notify(debug3(`Completed ${this.stackName}`, "CDK_TOOLKIT_I5503", {
       deployment: oldMonitorId,
       stack: this.stack,
       stackName: this.stackName,
@@ -2995,8 +3398,7 @@ var StackActivityMonitor = class {
         return;
       }
     } catch (e) {
-      await this.ioHost.notify(error2(
-        this.action,
+      await this.ioHelper.notify(error3(
         util6.format("Error occurred while monitoring stack: %s", e),
         "CDK_TOOLKIT_E5500",
         { error: e }
@@ -3010,7 +3412,7 @@ var StackActivityMonitor = class {
       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);
+      const entry = metadata[path15].filter((e) => e.type === import_cloud_assembly_schema2.ArtifactMetadataEntryType.LOGICAL_ID).find((e) => e.data === logicalId);
       if (entry) {
         return {
           entry,
@@ -3038,7 +3440,7 @@ var StackActivityMonitor = class {
         progress: this.progressMonitor.progress
       };
       this.checkForErrors(activity);
-      await this.ioHost.notify(info2(this.action, this.formatActivity(activity, true), "CDK_TOOLKIT_I5502", activity));
+      await this.ioHelper.notify(info3(this.formatActivity(activity, true), "CDK_TOOLKIT_I5502", activity));
     }
   }
   /**
@@ -3173,7 +3575,7 @@ async function makeBodyParameter(stack, resolvedEnvironment, assetManifest, reso
   }
   const toolkitInfo = await resources.lookupToolkit();
   if (!toolkitInfo.found) {
-    error(
+    error2(
       `The template for stack "${stack.displayName}" is ${Math.round(templateJson.length / 1024)}KiB. Templates larger than ${LARGE_TEMPLATE_SIZE_KB}KiB must be uploaded to S3.
 Run the following command in order to setup an S3 bucket in this environment, and then re-deploy:
 
@@ -3202,7 +3604,7 @@ Run the following command in order to setup an S3 bucket in this environment, an
     }
   );
   const templateURL = `${toolkitInfo.bucketUrl}/${key}`;
-  debug("Storing template in S3 at:", templateURL);
+  debug2("Storing template in S3 at:", templateURL);
   return { TemplateURL: templateURL };
 }
 async function restUrlFromManifest(url, environment) {
@@ -3306,11 +3708,11 @@ var CloudFormationStack = class _CloudFormationStack {
     if (!this.exists) {
       return {};
     }
-    const result = {};
+    const result2 = {};
     (this.stack.Outputs || []).forEach((output) => {
-      result[output.OutputKey] = output.OutputValue;
+      result2[output.OutputKey] = output.OutputValue;
     });
-    return result;
+    return result2;
   }
   /**
    * The stack's status
@@ -3394,23 +3796,23 @@ async function describeChangeSet(cfn, stackName, changeSetName, { fetchAll }) {
 }
 async function waitFor(valueProvider, timeout = 5e3) {
   while (true) {
-    const result = await valueProvider();
-    if (result === null) {
+    const result2 = await valueProvider();
+    if (result2 === null) {
       return void 0;
-    } else if (result !== void 0) {
-      return result;
+    } else if (result2 !== void 0) {
+      return result2;
     }
     await new Promise((cb) => setTimeout(cb, timeout));
   }
 }
-async function waitForChangeSet(cfn, { ioHost, action }, stackName, changeSetName, { fetchAll }) {
-  await ioHost.notify(debug2(action, (0, import_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 +3866,8 @@ function changeSetHasNoChanges(description) {
   ];
   return description.Status === "FAILED" && noChangeErrorPrefixes.some((p) => (description.StatusReason ?? "").startsWith(p));
 }
-async function waitForStackDelete(cfn, { ioHost, action }, stackName) {
-  const stack = await stabilizeStack(cfn, { ioHost, action }, stackName);
+async function waitForStackDelete(cfn, ioHelper, stackName) {
+  const stack = await stabilizeStack(cfn, ioHelper, stackName);
   if (!stack) {
     return void 0;
   }
@@ -3479,8 +3881,8 @@ async function waitForStackDelete(cfn, { ioHost, action }, stackName) {
   }
   return stack;
 }
-async function waitForStackDeploy(cfn, { ioHost, action }, stackName) {
-  const stack = await stabilizeStack(cfn, { ioHost, action }, stackName);
+async function waitForStackDeploy(cfn, ioHelper, stackName) {
+  const stack = await stabilizeStack(cfn, ioHelper, stackName);
   if (!stack) {
     return void 0;
   }
@@ -3494,20 +3896,20 @@ async function waitForStackDeploy(cfn, { ioHost, action }, stackName) {
   }
   return stack;
 }
-async function stabilizeStack(cfn, { ioHost, action }, stackName) {
-  await ioHost.notify(debug2(action, (0, import_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 +4006,13 @@ var chalk12 = __toESM(require("chalk"));
 // ../../aws-cdk/lib/api/deployments/asset-publishing.ts
 var import_cx_api4 = require("@aws-cdk/cx-api");
 var import_cdk_assets3 = require("cdk-assets");
-async function publishAssets(manifest, sdk, targetEnv, options, { ioHost, action }) {
+async function publishAssets(manifest, sdk, targetEnv, options, ioHelper) {
   if (targetEnv.account === void 0 || targetEnv.account === import_cx_api4.UNKNOWN_ACCOUNT || targetEnv.region === void 0 || targetEnv.account === import_cx_api4.UNKNOWN_REGION) {
     throw new ToolkitError(`Asset publishing requires resolved account and region, got ${JSON.stringify(targetEnv)}`);
   }
   const publisher = new import_cdk_assets3.AssetPublishing(manifest, {
     aws: new PublishingAws(sdk, targetEnv),
-    progressListener: new PublishingProgressListener({ ioHost, action }),
+    progressListener: new PublishingProgressListener(ioHelper),
     throwOnError: false,
     publishInParallel: options.parallel ?? true,
     buildAssets: true,
@@ -3707,18 +4109,17 @@ var EVENT_TO_LEVEL = {
   shell_close: false
 };
 var BasePublishProgressListener = class {
-  constructor({ ioHost, action }) {
-    this.ioHost = ioHost;
-    this.action = action;
+  constructor(ioHelper) {
+    this.ioHelper = ioHelper;
   }
   onPublishEvent(type, event) {
     const level = EVENT_TO_LEVEL[type];
     if (level) {
-      void this.ioHost.notify(
+      void this.ioHelper.notify(
         formatMessage({
           level,
-          action: this.action,
-          message: this.getMessage(type, event)
+          message: this.getMessage(type, event),
+          data: void 0
         })
       );
     }
@@ -3731,7 +4132,7 @@ var PublishingProgressListener = class extends BasePublishProgressListener {
 };
 
 // ../../aws-cdk/lib/api/deployments/checks.ts
-async function determineAllowCrossAccountAssetPublishing(sdk, { ioHost, action }, customStackName) {
+async function determineAllowCrossAccountAssetPublishing(sdk, ioHelper, customStackName) {
   try {
     const stackName = customStackName || "CDKToolkit";
     const stackInfo = await getBootstrapStackInfo(sdk, stackName);
@@ -3743,8 +4144,8 @@ async function determineAllowCrossAccountAssetPublishing(sdk, { ioHost, action }
     }
     return false;
   } catch (e) {
-    await ioHost.notify(debug2(action, `Error determining cross account asset publishing: ${e}`));
-    await ioHost.notify(debug2(action, "Defaulting to allowing cross account asset publishing"));
+    await ioHelper.notify(debug3(`Error determining cross account asset publishing: ${e}`));
+    await ioHelper.notify(debug3("Defaulting to allowing cross account asset publishing"));
     return true;
   }
 }
@@ -3778,14 +4179,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 +4200,23 @@ async function addMetadataAssetsToManifest({ ioHost, action }, stack, assetManif
   for (const asset of assets) {
     const reuseAsset = reuse.indexOf(asset.id) > -1;
     if (reuseAsset) {
-      await ioHost.notify(debug2(action, `Reusing asset ${asset.id}: ${JSON.stringify(asset)}`));
+      await ioHelper.notify(debug3(`Reusing asset ${asset.id}: ${JSON.stringify(asset)}`));
       continue;
     }
-    await ioHost.notify(debug2(action, `Preparing asset ${asset.id}: ${JSON.stringify(asset)}`));
+    await ioHelper.notify(debug3(`Preparing asset ${asset.id}: ${JSON.stringify(asset)}`));
     if (!stack.assembly) {
       throw new ToolkitError("Unexpected: stack assembly is required in order to find assets in assembly directory");
     }
-    Object.assign(params, await prepareAsset({ ioHost, action }, asset, assetManifest, envResources, toolkitInfo));
+    Object.assign(params, await prepareAsset(ioHelper, asset, assetManifest, envResources, toolkitInfo));
   }
   return params;
 }
-async function prepareAsset({ ioHost, action }, asset, assetManifest, envResources, toolkitInfo) {
+async function prepareAsset(ioHelper, asset, assetManifest, envResources, toolkitInfo) {
   switch (asset.packaging) {
     case "zip":
     case "file":
       return prepareFileAsset(
-        { ioHost, action },
+        ioHelper,
         asset,
         assetManifest,
         toolkitInfo,
@@ -3827,13 +4228,13 @@ async function prepareAsset({ ioHost, action }, asset, assetManifest, envResourc
       throw new ToolkitError(`Unsupported packaging type: ${asset.packaging}. You might need to upgrade your aws-cdk toolkit to support this asset type.`);
   }
 }
-async function prepareFileAsset({ ioHost, action }, asset, assetManifest, toolkitInfo, packaging) {
+async function prepareFileAsset(ioHelper, asset, assetManifest, toolkitInfo, packaging) {
   const extension = packaging === cxschema2.FileAssetPackaging.ZIP_DIRECTORY ? ".zip" : path5.extname(asset.path);
   const baseName = `${asset.sourceHash}${extension}`;
   const s3Prefix = asset.id === asset.sourceHash ? "assets/" : `assets/${asset.id}/`;
   const key = `${s3Prefix}${baseName}`;
   const s3url = `s3://${toolkitInfo.bucketName}/${key}`;
-  await ioHost.notify(debug2(action, `Storing asset ${asset.path} at ${s3url}`));
+  await ioHelper.notify(debug3(`Storing asset ${asset.path} at ${s3url}`));
   assetManifest.addFileAsset(asset.sourceHash, {
     path: asset.path,
     packaging
@@ -4592,12 +4993,12 @@ async function fetchFileFromS3(s3Url, sdk) {
 async function exponentialBackOffRetry(fn, numOfRetries, backOff, errorCodeToRetry) {
   try {
     await fn();
-  } catch (error3) {
-    if (error3 && error3.name === errorCodeToRetry && numOfRetries > 0) {
+  } catch (error4) {
+    if (error4 && error4.name === errorCodeToRetry && numOfRetries > 0) {
       await sleep(backOff);
       await exponentialBackOffRetry(fn, numOfRetries - 1, backOff * 2, errorCodeToRetry);
     } else {
-      throw error3;
+      throw error4;
     }
   }
 }
@@ -5178,7 +5579,7 @@ var RESOURCE_DETECTORS = {
   },
   "AWS::CDK::Metadata": async () => []
 };
-async function tryHotswapDeployment(sdkProvider, { ioHost, action }, assetParams, cloudFormationStack, stackArtifact, hotswapMode, hotswapPropertyOverrides) {
+async function tryHotswapDeployment(sdkProvider, ioHelper, assetParams, cloudFormationStack, stackArtifact, hotswapMode, hotswapPropertyOverrides) {
   const resolvedEnv = await sdkProvider.resolveEnvironment(stackArtifact.environment);
   const sdk = (await sdkProvider.forEnvironment(resolvedEnv, 1 /* ForWriting */)).sdk;
   const currentTemplate = await loadCurrentTemplateWithNestedStacks(stackArtifact, sdk);
@@ -5200,13 +5601,13 @@ async function tryHotswapDeployment(sdkProvider, { ioHost, action }, assetParams
     currentTemplate.nestedStacks,
     hotswapPropertyOverrides
   );
-  await logNonHotswappableChanges({ ioHost, action }, nonHotswappableChanges, hotswapMode);
+  await logNonHotswappableChanges(ioHelper, nonHotswappableChanges, hotswapMode);
   if (hotswapMode === "fall-back" /* FALL_BACK */) {
     if (nonHotswappableChanges.length > 0) {
       return void 0;
     }
   }
-  await applyAllHotswappableChanges(sdk, { ioHost, action }, hotswappableChanges);
+  await applyAllHotswappableChanges(sdk, ioHelper, hotswappableChanges);
   return {
     type: "did-deploy-stack",
     noOp: hotswappableChanges.length === 0,
@@ -5397,51 +5798,51 @@ function isCandidateForHotswapping(change, logicalId) {
     propertyUpdates: change.propertyUpdates
   };
 }
-async function applyAllHotswappableChanges(sdk, { ioHost, action }, hotswappableChanges) {
+async function applyAllHotswappableChanges(sdk, ioHelper, hotswappableChanges) {
   if (hotswappableChanges.length > 0) {
-    await ioHost.notify(info2(action, `
+    await ioHelper.notify(info3(`
 ${ICON} hotswapping resources:`));
   }
   const limit = pLimit(10);
   return Promise.all(hotswappableChanges.map((hotswapOperation) => limit(() => {
-    return applyHotswappableChange(sdk, { ioHost, action }, hotswapOperation);
+    return applyHotswappableChange(sdk, ioHelper, hotswapOperation);
   })));
 }
-async function applyHotswappableChange(sdk, { ioHost, action }, hotswapOperation) {
+async function applyHotswappableChange(sdk, ioHelper, hotswapOperation) {
   const customUserAgent = `cdk-hotswap/success-${hotswapOperation.service}`;
   sdk.appendCustomUserAgent(customUserAgent);
   for (const name of hotswapOperation.resourceNames) {
-    await ioHost.notify(info2(action, (0, import_util23.format)(`   ${ICON} %s`, chalk8.bold(name))));
+    await ioHelper.notify(info3((0, import_util23.format)(`   ${ICON} %s`, chalk8.bold(name))));
   }
   try {
     await hotswapOperation.apply(sdk);
   } catch (e) {
     if (e.name === "TimeoutError" || e.name === "AbortError") {
-      const result = JSON.parse(formatErrorMessage(e));
-      const error3 = new ToolkitError(formatWaiterErrorResult(result));
-      error3.name = e.name;
-      throw error3;
+      const result2 = JSON.parse(formatErrorMessage(e));
+      const error4 = new ToolkitError(formatWaiterErrorResult(result2));
+      error4.name = e.name;
+      throw error4;
     }
     throw e;
   }
   for (const name of hotswapOperation.resourceNames) {
-    await ioHost.notify(info2(action, (0, import_util23.format)(`${ICON} %s %s`, chalk8.bold(name), chalk8.green("hotswapped!"))));
+    await ioHelper.notify(info3((0, import_util23.format)(`${ICON} %s %s`, chalk8.bold(name), chalk8.green("hotswapped!"))));
   }
   sdk.removeCustomUserAgent(customUserAgent);
 }
-function formatWaiterErrorResult(result) {
+function formatWaiterErrorResult(result2) {
   const main = [
-    `Resource is not in the expected state due to waiter status: ${result.state}`,
-    result.reason ? `${result.reason}.` : ""
+    `Resource is not in the expected state due to waiter status: ${result2.state}`,
+    result2.reason ? `${result2.reason}.` : ""
   ].join(". ");
-  if (result.observedResponses != null) {
-    const observedResponses = Object.entries(result.observedResponses).map(([msg, count]) => `  - ${msg} (${count})`).join("\n");
+  if (result2.observedResponses != null) {
+    const observedResponses = Object.entries(result2.observedResponses).map(([msg, count]) => `  - ${msg} (${count})`).join("\n");
     return `${main} Observed responses:
 ${observedResponses}`;
   }
   return main;
 }
-async function logNonHotswappableChanges({ ioHost, action }, nonHotswappableChanges, hotswapMode) {
+async function logNonHotswappableChanges(ioHelper, nonHotswappableChanges, hotswapMode) {
   if (nonHotswappableChanges.length === 0) {
     return;
   }
@@ -5476,11 +5877,11 @@ async function logNonHotswappableChanges({ ioHost, action }, nonHotswappableChan
     }
   }
   messages.push("");
-  await ioHost.notify(info2(action, messages.join("\n")));
+  await ioHelper.notify(info3(messages.join("\n")));
 }
 
 // ../../aws-cdk/lib/api/deployments/deploy-stack.ts
-async function deployStack(options, { ioHost, action }) {
+async function deployStack(options, ioHelper) {
   const stackArtifact = options.stack;
   const stackEnv = options.resolvedEnvironment;
   options.sdk.appendCustomUserAgent(options.extraUserAgent);
@@ -5488,12 +5889,11 @@ async function deployStack(options, { ioHost, action }) {
   const deployName = options.deployName || stackArtifact.stackName;
   let cloudFormationStack = await CloudFormationStack.lookup(cfn, deployName);
   if (cloudFormationStack.stackStatus.isCreationFailure) {
-    await ioHost.notify(debug2(
-      action,
+    await ioHelper.notify(debug3(
       `Found existing stack ${deployName} that had previously failed creation. Deleting it before attempting to re-create it.`
     ));
     await cfn.deleteStack({ StackName: deployName });
-    const deletedStack = await waitForStackDelete(cfn, { ioHost, action }, deployName);
+    const deletedStack = await waitForStackDelete(cfn, ioHelper, deployName);
     if (deletedStack && deletedStack.stackStatus.name !== "DELETE_COMPLETE") {
       throw new ToolkitError(
         `Failed deleting stack ${deployName} that had previously failed creation (current state: ${deletedStack.stackStatus})`
@@ -5503,7 +5903,7 @@ async function deployStack(options, { ioHost, action }) {
   }
   const legacyAssets = new AssetManifestBuilder();
   const assetParams = await addMetadataAssetsToManifest(
-    { ioHost, action },
+    ioHelper,
     stackArtifact,
     legacyAssets,
     options.envResources,
@@ -5514,11 +5914,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(debug3(`${deployName}: skipping deployment (use --force to override)`));
     if (hotswapMode !== "full-deployment" /* FULL_DEPLOYMENT */) {
-      await ioHost.notify(info2(
-        action,
+      await ioHelper.notify(info3(
         (0, import_util25.format)(
           `
  ${ICON} %s
@@ -5534,7 +5933,7 @@ async function deployStack(options, { ioHost, action }) {
       stackArn: cloudFormationStack.stackId
     };
   } else {
-    await ioHost.notify(debug2(action, `${deployName}: deploying...`));
+    await ioHelper.notify(debug3(`${deployName}: deploying...`));
   }
   const bodyParameter = await makeBodyParameter(
     stackArtifact,
@@ -5547,17 +5946,17 @@ async function deployStack(options, { ioHost, action }) {
   try {
     bootstrapStackName = (await options.envResources.lookupToolkit()).stackName;
   } catch (e) {
-    await ioHost.notify(debug2(action, `Could not determine the bootstrap stack name: ${e}`));
+    await ioHelper.notify(debug3(`Could not determine the bootstrap stack name: ${e}`));
   }
   await publishAssets(legacyAssets.toManifest(stackArtifact.assembly.directory), options.sdkProvider, stackEnv, {
     parallel: options.assetParallelism,
-    allowCrossAccount: await determineAllowCrossAccountAssetPublishing(options.sdk, { ioHost, action }, bootstrapStackName)
-  }, { ioHost, action });
+    allowCrossAccount: await determineAllowCrossAccountAssetPublishing(options.sdk, ioHelper, bootstrapStackName)
+  }, ioHelper);
   if (hotswapMode !== "full-deployment" /* FULL_DEPLOYMENT */) {
     try {
       const hotswapDeploymentResult = await tryHotswapDeployment(
         options.sdkProvider,
-        { ioHost, action },
+        ioHelper,
         stackParams.values,
         cloudFormationStack,
         stackArtifact,
@@ -5567,7 +5966,7 @@ async function deployStack(options, { ioHost, action }) {
       if (hotswapDeploymentResult) {
         return hotswapDeploymentResult;
       }
-      await ioHost.notify(info2(action, (0, import_util25.format)(
+      await ioHelper.notify(info3((0, import_util25.format)(
         "Could not perform a hotswap deployment, as the stack %s contains non-Asset changes",
         stackArtifact.displayName
       )));
@@ -5575,13 +5974,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(info3((0, import_util25.format)(
         "Could not perform a hotswap deployment, because the CloudFormation template could not be resolved: %s",
         formatErrorMessage(e)
       )));
     }
     if (hotswapMode === "fall-back" /* FALL_BACK */) {
-      await ioHost.notify(info2(action, "Falling back to doing a full deployment"));
+      await ioHelper.notify(info3("Falling back to doing a full deployment"));
       options.sdk.appendCustomUserAgent("cdk-hotswap/fallback");
     } else {
       return {
@@ -5598,25 +5997,23 @@ async function deployStack(options, { ioHost, action }) {
     stackArtifact,
     stackParams,
     bodyParameter,
-    ioHost,
-    action
+    ioHelper
   );
   return fullDeployment.performDeployment();
 }
 var FullCloudFormationDeployment = class {
-  constructor(options, cloudFormationStack, stackArtifact, stackParams, bodyParameter, ioHost, action) {
+  constructor(options, cloudFormationStack, stackArtifact, stackParams, bodyParameter, ioHelper) {
     this.options = options;
     this.cloudFormationStack = cloudFormationStack;
     this.stackArtifact = stackArtifact;
     this.stackParams = stackParams;
     this.bodyParameter = bodyParameter;
-    this.ioHost = ioHost;
-    this.action = action;
+    this.ioHelper = ioHelper;
     this.cfn = options.sdk.cloudFormation();
     this.stackName = options.deployName ?? stackArtifact.stackName;
     this.update = cloudFormationStack.exists && cloudFormationStack.stackStatus.name !== "REVIEW_IN_PROGRESS";
     this.verb = this.update ? "update" : "create";
-    this.uuid = uuid2.v4();
+    this.uuid = uuid3.v4();
   }
   async performDeployment() {
     const deploymentMethod = this.options.deploymentMethod ?? {
@@ -5639,17 +6036,16 @@ var FullCloudFormationDeployment = class {
     const changeSetDescription = await this.createChangeSet(changeSetName, execute, importExistingResources);
     await this.updateTerminationProtection();
     if (changeSetHasNoChanges(changeSetDescription)) {
-      await this.ioHost.notify(debug2(this.action, (0, import_util25.format)("No changes are to be performed on %s.", this.stackName)));
+      await this.ioHelper.notify(debug3((0, import_util25.format)("No changes are to be performed on %s.", this.stackName)));
       if (execute) {
-        await this.ioHost.notify(debug2(this.action, (0, import_util25.format)("Deleting empty change set %s", changeSetDescription.ChangeSetId)));
+        await this.ioHelper.notify(debug3((0, import_util25.format)("Deleting empty change set %s", changeSetDescription.ChangeSetId)));
         await this.cfn.deleteChangeSet({
           StackName: this.stackName,
           ChangeSetName: changeSetName
         });
       }
       if (this.options.force) {
-        await this.ioHost.notify(warn(
-          this.action,
+        await this.ioHelper.notify(warn2(
           [
             "You used the --force flag, but CloudFormation reported that the deployment would not make any changes.",
             "According to CloudFormation, all resources are already up-to-date with the state in your CDK app.",
@@ -5667,7 +6063,7 @@ var FullCloudFormationDeployment = class {
       };
     }
     if (!execute) {
-      await this.ioHost.notify(info2(this.action, (0, import_util25.format)(
+      await this.ioHelper.notify(info3((0, import_util25.format)(
         "Changeset %s created and waiting in review for manual execution (--no-execute)",
         changeSetDescription.ChangeSetId
       )));
@@ -5694,8 +6090,8 @@ var FullCloudFormationDeployment = class {
   }
   async createChangeSet(changeSetName, willExecute, importExistingResources) {
     await this.cleanupOldChangeset(changeSetName);
-    await this.ioHost.notify(debug2(this.action, `Attempting to create ChangeSet with name ${changeSetName} to ${this.verb} stack ${this.stackName}`));
-    await this.ioHost.notify(info2(this.action, (0, import_util25.format)("%s: creating CloudFormation changeset...", chalk9.bold(this.stackName))));
+    await this.ioHelper.notify(debug3(`Attempting to create ChangeSet with name ${changeSetName} to ${this.verb} stack ${this.stackName}`));
+    await this.ioHelper.notify(info3((0, import_util25.format)("%s: creating CloudFormation changeset...", chalk9.bold(this.stackName))));
     const changeSet = await this.cfn.createChangeSet({
       StackName: this.stackName,
       ChangeSetName: changeSetName,
@@ -5706,21 +6102,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(debug3((0, import_util25.format)("Initiated creation of changeset: %s; waiting for it to finish creating...", changeSet.Id)));
+    return waitForChangeSet(this.cfn, this.ioHelper, this.stackName, changeSetName, {
       fetchAll: willExecute
     });
   }
   async executeChangeSet(changeSet) {
-    await this.ioHost.notify(debug2(this.action, (0, import_util25.format)("Initiating execution of changeset %s on stack %s", changeSet.ChangeSetId, this.stackName)));
+    await this.ioHelper.notify(debug3((0, import_util25.format)("Initiating execution of changeset %s on stack %s", changeSet.ChangeSetId, this.stackName)));
     await this.cfn.executeChangeSet({
       StackName: this.stackName,
       ChangeSetName: changeSet.ChangeSetName,
       ClientRequestToken: `exec${this.uuid}`,
       ...this.commonExecuteOptions()
     });
-    await this.ioHost.notify(debug2(
-      this.action,
+    await this.ioHelper.notify(debug3(
       (0, import_util25.format)(
         "Execution of changeset %s on stack %s has started; waiting for the update to complete...",
         changeSet.ChangeSetId,
@@ -5732,7 +6127,7 @@ var FullCloudFormationDeployment = class {
   }
   async cleanupOldChangeset(changeSetName) {
     if (this.cloudFormationStack.exists) {
-      await this.ioHost.notify(debug2(this.action, `Removing existing change set with name ${changeSetName} if it exists`));
+      await this.ioHelper.notify(debug3(`Removing existing change set with name ${changeSetName} if it exists`));
       await this.cfn.deleteChangeSet({
         StackName: this.stackName,
         ChangeSetName: changeSetName
@@ -5742,8 +6137,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(debug3(
         (0, import_util25.format)(
           "Updating termination protection from %s to %s for stack %s",
           this.cloudFormationStack.terminationProtection,
@@ -5755,11 +6149,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(debug3((0, import_util25.format)("Termination protection updated to %s for stack %s", terminationProtection, this.stackName)));
     }
   }
   async directDeployment() {
-    await this.ioHost.notify(info2(this.action, (0, import_util25.format)("%s: %s stack...", chalk9.bold(this.stackName), this.update ? "updating" : "creating")));
+    await this.ioHelper.notify(info3((0, import_util25.format)("%s: %s stack...", chalk9.bold(this.stackName), this.update ? "updating" : "creating")));
     const startTime = /* @__PURE__ */ new Date();
     if (this.update) {
       await this.updateTerminationProtection();
@@ -5772,7 +6166,7 @@ var FullCloudFormationDeployment = class {
         });
       } catch (err) {
         if (err.message === "No updates are to be performed.") {
-          await this.ioHost.notify(debug2(this.action, (0, import_util25.format)("No updates are to be performed for stack %s", this.stackName)));
+          await this.ioHelper.notify(debug3((0, import_util25.format)("No updates are to be performed for stack %s", this.stackName)));
           return {
             type: "did-deploy-stack",
             noOp: true,
@@ -5801,14 +6195,13 @@ var FullCloudFormationDeployment = class {
       stack: this.stackArtifact,
       stackName: this.stackName,
       resourcesTotal: expectedChanges,
-      ioHost: this.ioHost,
-      action: this.action,
+      ioHelper: this.ioHelper,
       changeSetCreationTime: startTime
     });
     await monitor.start();
     let finalState = this.cloudFormationStack;
     try {
-      const successStack = await waitForStackDeploy(this.cfn, { ioHost: this.ioHost, action: this.action }, this.stackName);
+      const successStack = await waitForStackDeploy(this.cfn, this.ioHelper, this.stackName);
       if (!successStack) {
         throw new ToolkitError("Stack deploy failed (the stack disappeared while we were deploying it)");
       }
@@ -5818,7 +6211,7 @@ var FullCloudFormationDeployment = class {
     } finally {
       await monitor.stop();
     }
-    debug2(this.action, (0, import_util25.format)("Stack %s has completed updating", this.stackName));
+    debug3((0, import_util25.format)("Stack %s has completed updating", this.stackName));
     return {
       type: "did-deploy-stack",
       noOp: false,
@@ -5854,7 +6247,7 @@ var FullCloudFormationDeployment = class {
     };
   }
 };
-async function destroyStack(options, { ioHost, action }) {
+async function destroyStack(options, ioHelper) {
   const deployName = options.deployName || options.stack.stackName;
   const cfn = options.sdk.cloudFormation();
   const currentStack = await CloudFormationStack.lookup(cfn, deployName);
@@ -5865,13 +6258,12 @@ async function destroyStack(options, { ioHost, action }) {
     cfn,
     stack: options.stack,
     stackName: deployName,
-    ioHost,
-    action
+    ioHelper
   });
   await monitor.start();
   try {
     await cfn.deleteStack({ StackName: deployName, RoleARN: options.roleArn });
-    const destroyedStack = await waitForStackDelete(cfn, { ioHost, action }, deployName);
+    const destroyedStack = await waitForStackDelete(cfn, ioHelper, deployName);
     if (destroyedStack && destroyedStack.stackStatus.name !== "DELETE_COMPLETE") {
       throw new ToolkitError(`Failed to destroy ${deployName}: ${destroyedStack.stackStatus}`);
     }
@@ -5883,47 +6275,47 @@ async function destroyStack(options, { ioHost, action }) {
     }
   }
 }
-async function canSkipDeploy(deployStackOptions, cloudFormationStack, parameterChanges, { ioHost, action }) {
+async function canSkipDeploy(deployStackOptions, cloudFormationStack, parameterChanges, ioHelper) {
   const deployName = deployStackOptions.deployName || deployStackOptions.stack.stackName;
-  await ioHost.notify(debug2(action, `${deployName}: checking if we can skip deploy`));
+  await ioHelper.notify(debug3(`${deployName}: checking if we can skip deploy`));
   if (deployStackOptions.force) {
-    await ioHost.notify(debug2(action, `${deployName}: forced deployment`));
+    await ioHelper.notify(debug3(`${deployName}: forced deployment`));
     return false;
   }
   if (deployStackOptions.deploymentMethod?.method === "change-set" && deployStackOptions.deploymentMethod.execute === false) {
-    await ioHost.notify(debug2(action, `${deployName}: --no-execute, always creating change set`));
+    await ioHelper.notify(debug3(`${deployName}: --no-execute, always creating change set`));
     return false;
   }
   if (!cloudFormationStack.exists) {
-    await ioHost.notify(debug2(action, `${deployName}: no existing stack`));
+    await ioHelper.notify(debug3(`${deployName}: no existing stack`));
     return false;
   }
   if (JSON.stringify(deployStackOptions.stack.template) !== JSON.stringify(await cloudFormationStack.template())) {
-    await ioHost.notify(debug2(action, `${deployName}: template has changed`));
+    await ioHelper.notify(debug3(`${deployName}: template has changed`));
     return false;
   }
   if (!compareTags(cloudFormationStack.tags, deployStackOptions.tags ?? [])) {
-    await ioHost.notify(debug2(action, `${deployName}: tags have changed`));
+    await ioHelper.notify(debug3(`${deployName}: tags have changed`));
     return false;
   }
   if (!arrayEquals(cloudFormationStack.notificationArns, deployStackOptions.notificationArns ?? [])) {
-    await ioHost.notify(debug2(action, `${deployName}: notification arns have changed`));
+    await ioHelper.notify(debug3(`${deployName}: notification arns have changed`));
     return false;
   }
   if (!!deployStackOptions.stack.terminationProtection !== !!cloudFormationStack.terminationProtection) {
-    await ioHost.notify(debug2(action, `${deployName}: termination protection has been updated`));
+    await ioHelper.notify(debug3(`${deployName}: termination protection has been updated`));
     return false;
   }
   if (parameterChanges) {
     if (parameterChanges === "ssm") {
-      await ioHost.notify(debug2(action, `${deployName}: some parameters come from SSM so we have to assume they may have changed`));
+      await ioHelper.notify(debug3(`${deployName}: some parameters come from SSM so we have to assume they may have changed`));
     } else {
-      await ioHost.notify(debug2(action, `${deployName}: parameters have changed`));
+      await ioHelper.notify(debug3(`${deployName}: parameters have changed`));
     }
     return false;
   }
   if (cloudFormationStack.stackStatus.isFailure) {
-    await ioHost.notify(debug2(action, `${deployName}: stack is in a failure state`));
+    await ioHelper.notify(debug3(`${deployName}: stack is in a failure state`));
     return false;
   }
   return true;
@@ -6015,7 +6407,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,7 +6415,7 @@ 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;
   }
 }
@@ -6212,7 +6604,7 @@ var Notices = class _Notices {
       const notices = await dataSource.fetch();
       this.data = new Set(this.includeAcknowlegded ? notices : notices.filter((n) => !this.acknowledgedIssueNumbers.has(n.issueNumber)));
     } catch (e) {
-      debug(`Could not refresh notices: ${e}`);
+      debug2(`Could not refresh notices: ${e}`);
     }
   }
   /**
@@ -6229,9 +6621,9 @@ var Notices = class _Notices {
       bootstrappedEnvironments: Array.from(this.bootstrappedEnvironments.values())
     });
     if (filteredNotices.length > 0) {
-      info("");
-      info("NOTICES         (What's this? https://github.com/aws/aws-cdk/wiki/CLI-Notices)");
-      info("");
+      info2("");
+      info2("NOTICES         (What's this? https://github.com/aws/aws-cdk/wiki/CLI-Notices)");
+      info2("");
       for (const filtered of filteredNotices) {
         const formatted = filtered.format();
         switch (filtered.notice.severity) {
@@ -6239,18 +6631,18 @@ var Notices = class _Notices {
             warning(formatted);
             break;
           case "error":
-            error(formatted);
+            error2(formatted);
             break;
           default:
-            info(formatted);
+            info2(formatted);
         }
-        info("");
+        info2("");
       }
-      info(`If you don\u2019t want to see a notice anymore, use "cdk acknowledge <id>". For example, "cdk acknowledge ${filteredNotices[0].notice.issueNumber}".`);
+      info2(`If you don\u2019t want to see a notice anymore, use "cdk acknowledge <id>". For example, "cdk acknowledge ${filteredNotices[0].notice.issueNumber}".`);
     }
     if (options.showTotal ?? false) {
-      info("");
-      info(`There are ${filteredNotices.length} unacknowledged notice(s).`);
+      info2("");
+      info2(`There are ${filteredNotices.length} unacknowledged notice(s).`);
     }
   }
 };
@@ -6324,7 +6716,7 @@ var WebsiteNoticeDataSource = class {
                   if (!data) {
                     throw new ToolkitError("'notices' key is missing");
                   }
-                  debug("Notices refreshed");
+                  debug2("Notices refreshed");
                   resolve3(data ?? []);
                 } catch (e) {
                   reject(new ToolkitError(`Failed to parse notices: ${formatErrorMessage(e)}`));
@@ -6362,7 +6754,7 @@ var CachedDataSource = class {
       await this.save(freshData);
       return freshData.notices;
     } else {
-      debug(`Reading cached notices from ${this.fileName}`);
+      debug2(`Reading cached notices from ${this.fileName}`);
       return data;
     }
   }
@@ -6373,7 +6765,7 @@ var CachedDataSource = class {
         notices: await this.dataSource.fetch()
       };
     } catch (e) {
-      debug(`Could not refresh notices: ${e}`);
+      debug2(`Could not refresh notices: ${e}`);
       return {
         expiration: Date.now() + TIME_TO_LIVE_ERROR,
         notices: []
@@ -6388,7 +6780,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}`);
+      debug2(`Failed to load notices from cache: ${e}`);
       return defaultValue;
     }
   }
@@ -6396,7 +6788,7 @@ var CachedDataSource = class {
     try {
       await fs11.writeJSON(this.fileName, cached2);
     } catch (e) {
-      debug(`Failed to store notices in the cache: ${e}`);
+      debug2(`Failed to store notices in the cache: ${e}`);
     }
   }
 };
@@ -6420,14 +6812,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 +6829,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 +6941,21 @@ var EnvironmentResourcesRegistry = class {
     this.toolkitStackName = toolkitStackName;
     this.cache = /* @__PURE__ */ new Map();
   }
-  for(resolvedEnvironment, sdk, msg) {
+  for(resolvedEnvironment, sdk, ioHelper) {
     const key = `${resolvedEnvironment.account}:${resolvedEnvironment.region}`;
     let envCache = this.cache.get(key);
     if (!envCache) {
       envCache = emptyCache();
       this.cache.set(key, envCache);
     }
-    return new EnvironmentResources(resolvedEnvironment, sdk, msg, envCache, this.toolkitStackName);
+    return new EnvironmentResources(resolvedEnvironment, sdk, ioHelper, envCache, this.toolkitStackName);
   }
 };
 var EnvironmentResources = class {
-  constructor(environment, sdk, msg, cache, toolkitStackName) {
+  constructor(environment, sdk, ioHelper, cache, toolkitStackName) {
     this.environment = environment;
     this.sdk = sdk;
-    this.msg = msg;
+    this.ioHelper = ioHelper;
     this.cache = cache;
     this.toolkitStackName = toolkitStackName;
   }
@@ -6574,7 +6964,7 @@ var EnvironmentResources = class {
    */
   async lookupToolkit() {
     if (!this.cache.toolkitInfo) {
-      this.cache.toolkitInfo = await ToolkitInfo.lookup(this.environment, this.sdk, this.msg, this.toolkitStackName);
+      this.cache.toolkitInfo = await ToolkitInfo.lookup(this.environment, this.sdk, this.ioHelper, this.toolkitStackName);
     }
     return this.cache.toolkitInfo;
   }
@@ -6602,8 +6992,7 @@ var EnvironmentResources = class {
         }
         const bootstrapStack2 = await this.lookupToolkit();
         if (bootstrapStack2.found && bootstrapStack2.version < BOOTSTRAP_TEMPLATE_VERSION_INTRODUCING_GETPARAMETER) {
-          await this.msg.ioHost.notify(warn(
-            this.msg.action,
+          await this.ioHelper.notify(warn2(
             `Could not read SSM parameter ${ssmParameterName}: ${formatErrorMessage(e)}, falling back to version from ${bootstrapStack2}`
           ));
           doValidate(bootstrapStack2.version, this.environment);
@@ -6638,10 +7027,10 @@ var EnvironmentResources = class {
     }
     const ssm = this.sdk.ssm();
     try {
-      const result = await ssm.getParameter({ Name: parameterName });
-      const asNumber = parseInt(`${result.Parameter?.Value}`, 10);
+      const result2 = await ssm.getParameter({ Name: parameterName });
+      const asNumber = parseInt(`${result2.Parameter?.Value}`, 10);
       if (isNaN(asNumber)) {
-        throw new ToolkitError(`SSM parameter ${parameterName} not a number: ${result.Parameter?.Value}`);
+        throw new ToolkitError(`SSM parameter ${parameterName} not a number: ${result2.Parameter?.Value}`);
       }
       this.cache.ssmParameters.set(parameterName, asNumber);
       return asNumber;
@@ -6660,7 +7049,7 @@ var EnvironmentResources = class {
     }
     const ecr = this.sdk.ecr();
     try {
-      await this.msg.ioHost.notify(debug2(this.msg.action, `${repositoryName}: checking if ECR repository already exists`));
+      await this.ioHelper.notify(debug3(`${repositoryName}: checking if ECR repository already exists`));
       const describeResponse = await ecr.describeRepositories({
         repositoryNames: [repositoryName]
       });
@@ -6673,7 +7062,7 @@ var EnvironmentResources = class {
         throw e;
       }
     }
-    await this.msg.ioHost.notify(debug2(this.msg.action, `${repositoryName}: creating ECR repository`));
+    await this.ioHelper.notify(debug3(`${repositoryName}: creating ECR repository`));
     const assetTag = { Key: "awscdk:asset", Value: "true" };
     const response = await ecr.createRepository({
       repositoryName,
@@ -6683,7 +7072,7 @@ var EnvironmentResources = class {
     if (!repositoryUri) {
       throw new ToolkitError(`CreateRepository did not return a repository URI for ${repositoryUri}`);
     }
-    await this.msg.ioHost.notify(debug2(this.msg.action, `${repositoryName}: enable image scanning`));
+    await this.ioHelper.notify(debug3(`${repositoryName}: enable image scanning`));
     await ecr.putImageScanningConfiguration({
       repositoryName,
       imageScanningConfiguration: { scanOnPush: true }
@@ -6692,8 +7081,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 +7115,11 @@ async function replaceEnvPlaceholders(object, env, sdkProvider) {
 
 // ../../aws-cdk/lib/api/environment/environment-access.ts
 var EnvironmentAccess = class {
-  constructor(sdkProvider, toolkitStackName, { ioHost, action }) {
+  constructor(sdkProvider, toolkitStackName, ioHelper) {
     this.sdkProvider = sdkProvider;
     this.sdkCache = /* @__PURE__ */ new Map();
     this.environmentResources = new EnvironmentResourcesRegistry(toolkitStackName);
-    this.ioHost = ioHost;
-    this.action = action;
+    this.ioHelper = ioHelper;
   }
   /**
    * Resolves the environment for a stack.
@@ -6810,7 +7198,7 @@ var EnvironmentAccess = class {
     }
     if (lookupEnv.isFallbackCredentials) {
       const arn = await lookupEnv.replacePlaceholders(stack.lookupRole?.arn);
-      await this.ioHost.notify(warn(this.action, `Lookup role ${arn} was not assumed. Proceeding with default credentials.`));
+      await this.ioHelper.notify(warn2(`Lookup role ${arn} was not assumed. Proceeding with default credentials.`));
     }
     return lookupEnv;
   }
@@ -6832,7 +7220,7 @@ var EnvironmentAccess = class {
     try {
       return await this.accessStackForLookup(stack);
     } catch (e) {
-      await this.ioHost.notify(warn(this.action, `${formatErrorMessage(e)}`));
+      await this.ioHelper.notify(warn2(`${formatErrorMessage(e)}`));
     }
     return this.accessStackForStackOperations(stack, 0 /* ForReading */);
   }
@@ -6873,7 +7261,7 @@ var EnvironmentAccess = class {
     return {
       sdk: stackSdk.sdk,
       resolvedEnvironment,
-      resources: this.environmentResources.for(resolvedEnvironment, stackSdk.sdk, { ioHost: this.ioHost, action: this.action }),
+      resources: this.environmentResources.for(resolvedEnvironment, stackSdk.sdk, this.ioHelper),
       // If we asked for a role, did not successfully assume it, and yet got here without an exception: that
       // means we must have fallback credentials.
       isFallbackCredentials: !stackSdk.didAssumeRole && !!assumeRoleArn,
@@ -6914,12 +7302,11 @@ var Deployments = class {
     this.publisherCache = /* @__PURE__ */ new Map();
     this.assetSdkProvider = props.sdkProvider;
     this.deployStackSdkProvider = props.sdkProvider;
-    this.ioHost = props.ioHost;
-    this.action = props.action;
+    this.ioHelper = props.ioHelper;
     this.envs = new EnvironmentAccess(
       props.sdkProvider,
       props.toolkitStackName ?? DEFAULT_TOOLKIT_STACK_NAME,
-      { ioHost: this.ioHost, action: this.action }
+      this.ioHelper
     );
   }
   /**
@@ -6933,12 +7320,12 @@ var Deployments = class {
     return loadCurrentTemplateWithNestedStacks(rootStackArtifact, env.sdk, retrieveProcessedTemplate);
   }
   async readCurrentTemplate(stackArtifact) {
-    await this.ioHost.notify(debug2(this.action, `Reading existing template for stack ${stackArtifact.displayName}.`));
+    await this.ioHelper.notify(debug3(`Reading existing template for stack ${stackArtifact.displayName}.`));
     const env = await this.envs.accessStackForLookupBestEffort(stackArtifact);
     return loadCurrentTemplate(stackArtifact, env.sdk);
   }
   async resourceIdentifierSummaries(stackArtifact) {
-    await this.ioHost.notify(debug2(this.action, `Retrieving template summary for stack ${stackArtifact.displayName}.`));
+    await this.ioHelper.notify(debug3(`Retrieving template summary for stack ${stackArtifact.displayName}.`));
     const env = await this.envs.accessStackForReadOnlyStackOperations(stackArtifact);
     const cfn = env.sdk.cloudFormation();
     await uploadStackTemplateAssets(stackArtifact, this);
@@ -6960,7 +7347,7 @@ var Deployments = class {
     }
     const response = await cfn.getTemplateSummary(cfnParam);
     if (!response.ResourceIdentifierSummaries) {
-      await this.ioHost.notify(debug2(this.action, 'GetTemplateSummary API call did not return "ResourceIdentifierSummaries"'));
+      await this.ioHelper.notify(debug3('GetTemplateSummary API call did not return "ResourceIdentifierSummaries"'));
     }
     return response.ResourceIdentifierSummaries ?? [];
   }
@@ -7008,7 +7395,7 @@ var Deployments = class {
       resourcesToImport: options.resourcesToImport,
       overrideTemplate: options.overrideTemplate,
       assetParallelism: options.assetParallelism
-    }, { ioHost: this.ioHost, action: this.action });
+    }, this.ioHelper);
   }
   async rollbackStack(options) {
     let resourcesToSkip = options.orphanLogicalIds ?? [];
@@ -7032,10 +7419,10 @@ var Deployments = class {
       const executionRoleArn = await env.replacePlaceholders(options.roleArn ?? options.stack.cloudFormationExecutionRoleArn);
       switch (cloudFormationStack.stackStatus.rollbackChoice) {
         case 3 /* NONE */:
-          await this.ioHost.notify(warn(this.action, `Stack ${deployName} does not need a rollback: ${cloudFormationStack.stackStatus}`));
+          await this.ioHelper.notify(warn2(`Stack ${deployName} does not need a rollback: ${cloudFormationStack.stackStatus}`));
           return { notInRollbackableState: true };
         case 0 /* START_ROLLBACK */:
-          await this.ioHost.notify(debug2(this.action, `Initiating rollback of stack ${deployName}`));
+          await this.ioHelper.notify(debug3(`Initiating rollback of stack ${deployName}`));
           await cfn.rollbackStack({
             StackName: deployName,
             RoleARN: executionRoleArn,
@@ -7054,7 +7441,7 @@ var Deployments = class {
             resourcesToSkip = poller.resourceErrors.filter((r) => !r.isStackEvent && r.parentStackLogicalIds.length === 0).map((r) => r.event.LogicalResourceId ?? "");
           }
           const skipDescription = resourcesToSkip.length > 0 ? ` (orphaning: ${resourcesToSkip.join(", ")})` : "";
-          await this.ioHost.notify(warn(this.action, `Continuing rollback of stack ${deployName}${skipDescription}`));
+          await this.ioHelper.notify(warn2(`Continuing rollback of stack ${deployName}${skipDescription}`));
           await cfn.continueUpdateRollback({
             StackName: deployName,
             ClientRequestToken: (0, import_crypto.randomUUID)(),
@@ -7063,8 +7450,7 @@ var Deployments = class {
           });
           break;
         case 2 /* ROLLBACK_FAILED */:
-          await this.ioHost.notify(warn(
-            this.action,
+          await this.ioHelper.notify(warn2(
             `Stack ${deployName} failed creation and rollback. This state cannot be rolled back. You can recreate this stack by running 'cdk deploy'.`
           ));
           return { notInRollbackableState: true };
@@ -7075,14 +7461,13 @@ var Deployments = class {
         cfn,
         stack: options.stack,
         stackName: deployName,
-        ioHost: this.ioHost,
-        action: this.action
+        ioHelper: this.ioHelper
       });
       await monitor.start();
       let stackErrorMessage = void 0;
       let finalStackState = cloudFormationStack;
       try {
-        const successStack = await stabilizeStack(cfn, { ioHost: this.ioHost, action: this.action }, deployName);
+        const successStack = await stabilizeStack(cfn, this.ioHelper, deployName);
         if (!successStack) {
           throw new ToolkitError("Stack deploy failed (the stack disappeared while we were rolling it back)");
         }
@@ -7118,7 +7503,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 +7546,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 +7557,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 +7591,15 @@ var Deployments = class {
       // The AssetPublishing class takes care of role assuming etc, so it's okay to
       // give it a direct `SdkProvider`.
       aws: new PublishingAws(this.assetSdkProvider, env),
-      progressListener: new ParallelSafeAssetProgress(prefix, { ioHost: this.ioHost, action: this.action })
+      progressListener: new ParallelSafeAssetProgress(prefix, this.ioHelper)
     });
     this.publisherCache.set(assetManifest, publisher);
     return publisher;
   }
 };
 var ParallelSafeAssetProgress = class extends BasePublishProgressListener {
-  constructor(prefix, { ioHost, action }) {
-    super({ ioHost, action });
+  constructor(prefix, ioHelper) {
+    super(ioHelper);
     this.prefix = prefix;
   }
   getMessage(type, event) {
@@ -7247,8 +7632,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 +7660,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 +7700,18 @@ var ResourceImporter = class {
   }
   async importResources(overrideTemplate, resourcesToImport, options) {
     try {
-      const result = await this.cfn.deployStack({
+      const result2 = await this.cfn.deployStack({
         stack: this.stack,
         deployName: this.stack.stackName,
         ...options,
         overrideTemplate,
         resourcesToImport
       });
-      assertIsSuccessfulDeployStackResult(result);
-      const message = result.noOp ? " \u2705  %s (no changes)" : " \u2705  %s";
-      await this.ioHost.notify(info2(this.action, "\n" + chalk13.green((0, import_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 +7730,7 @@ var ResourceImporter = class {
     if (nonAdditions.length) {
       const offendingResources = nonAdditions.map(([logId, _]) => this.describeResource(logId));
       if (allowNonAdditions) {
-        await this.ioHost.notify(warn(this.action, `Ignoring updated/deleted resources (--force): ${offendingResources.join(", ")}`));
+        await this.ioHelper.notify(warn2(`Ignoring updated/deleted resources (--force): ${offendingResources.join(", ")}`));
       } else {
         throw new ToolkitError(`No resource updates or deletes are allowed on import operation. Make sure to resolve pending changes to existing resources, before attempting an import. Updated/deleted resources: ${offendingResources.join(", ")} (--force to override)`);
       }
@@ -7419,7 +7803,7 @@ var ResourceImporter = class {
     const resourceName = this.describeResource(chg.logicalId);
     const resourceType = chg.resourceDiff.newResourceType;
     if (resourceType === void 0 || !(resourceType in resourceIdentifiers)) {
-      await this.ioHost.notify(warn(this.action, `${resourceName}: unsupported resource type ${resourceType}, skipping import.`));
+      await this.ioHelper.notify(warn2(`${resourceName}: unsupported resource type ${resourceType}, skipping import.`));
       return void 0;
     }
     const idPropSets = resourceIdentifiers[resourceType];
@@ -7436,7 +7820,7 @@ var ResourceImporter = class {
       }
     }
     if (satisfiedPropSets.length > 0) {
-      await this.ioHost.notify(info2(this.action, chalk13.grey(`Skipping import of ${resourceName}`)));
+      await this.ioHelper.notify(info3(chalk13.grey(`Skipping import of ${resourceName}`)));
       return void 0;
     }
     const prefix = `${chalk13.blue(resourceName)} (${resourceType})`;
@@ -7449,7 +7833,7 @@ var ResourceImporter = class {
       promptPattern = `${prefix}: enter %`;
     }
     if (preamble) {
-      await this.ioHost.notify(info2(this.action, preamble));
+      await this.ioHelper.notify(info3(preamble));
     }
     for (const idProps of idPropSets) {
       const input = {};
@@ -7473,7 +7857,7 @@ var ResourceImporter = class {
         return input;
       }
     }
-    await this.ioHost.notify(info2(this.action, chalk13.grey(`Skipping import of ${resourceName}`)));
+    await this.ioHelper.notify(info3(chalk13.grey(`Skipping import of ${resourceName}`)));
     return void 0;
   }
   /**
@@ -7528,8 +7912,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 +7924,15 @@ var ResourceMigrator = class {
     const stack = stacks.stackArtifacts[0];
     const migrateDeployment = new ResourceImporter(stack, {
       deployments: this.props.deployments,
-      ioHost: this.ioHost,
-      action: this.action
+      ioHelper: this.ioHelper
     });
     const resourcesToImport = await this.tryGetResources(await migrateDeployment.resolveEnvironment());
     if (resourcesToImport) {
-      await this.ioHost.notify(info2(this.action, `${chalk14.bold(stack.displayName)}: creating stack for resource migration...`));
-      await this.ioHost.notify(info2(this.action, `${chalk14.bold(stack.displayName)}: importing resources into stack...`));
+      await this.ioHelper.notify(info3(`${chalk14.bold(stack.displayName)}: creating stack for resource migration...`));
+      await this.ioHelper.notify(info3(`${chalk14.bold(stack.displayName)}: importing resources into stack...`));
       await this.performResourceMigration(migrateDeployment, resourcesToImport, options);
       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 +7948,7 @@ var ResourceMigrator = class {
       rollback: options.rollback
     });
     elapsedDeployTime = (/* @__PURE__ */ new Date()).getTime() - startDeployTime;
-    await this.ioHost.notify(info2(this.action, `'
+    await this.ioHelper.notify(info3(`'
 \u2728  Resource migration time: ${formatTime(elapsedDeployTime)}s
 '`, "CDK_TOOLKIT_I5002", {
       duration: elapsedDeployTime
@@ -7590,22 +7972,35 @@ var ResourceMigrator = class {
 // ../../aws-cdk/lib/api/logs/logs-monitor.ts
 var util7 = __toESM(require("util"));
 var chalk15 = __toESM(require("chalk"));
-var SLEEP = 2e3;
+var uuid4 = __toESM(require("uuid"));
 var CloudWatchLogEventMonitor = class {
-  constructor(startTime) {
+  constructor(props) {
     /**
      * Map of environment (account:region) to LogGroupsAccessSettings
      */
     this.envsLogGroupsAccessSettings = /* @__PURE__ */ new Map();
-    this.active = false;
-    this.startTime = startTime?.getTime() ?? Date.now();
+    /**
+     * After reading events from all CloudWatch log groups
+     * how long should we wait to read more events.
+     *
+     * If there is some error with reading events (i.e. Throttle)
+     * then this is also how long we wait until we try again
+     */
+    this.pollingInterval = 2e3;
+    this.startTime = props.startTime?.getTime() ?? Date.now();
+    this.ioHelper = props.ioHelper;
   }
   /**
    * resume reading/printing events
    */
-  activate() {
-    this.active = true;
-    this.scheduleNextTick(0);
+  async activate() {
+    this.monitorId = uuid4.v4();
+    await this.ioHelper.notify(IO.CDK_TOOLKIT_I5032.msg("Start monitoring log groups", {
+      monitor: this.monitorId,
+      logGroupNames: this.logGroupNames()
+    }));
+    await this.tick();
+    this.scheduleNextTick();
   }
   /**
    * deactivates the monitor so no new events are read
@@ -7616,9 +8011,14 @@ var CloudWatchLogEventMonitor = class {
    * Also resets the start time to be when the new deployment was triggered
    * and clears the list of tracked log groups
    */
-  deactivate() {
-    this.active = false;
+  async deactivate() {
+    const oldMonitorId = this.monitorId;
+    this.monitorId = void 0;
     this.startTime = Date.now();
+    await this.ioHelper.notify(IO.CDK_TOOLKIT_I5034.msg("Stopped monitoring log groups", {
+      monitor: oldMonitorId,
+      logGroupNames: this.logGroupNames()
+    }));
     this.envsLogGroupsAccessSettings.clear();
   }
   /**
@@ -7645,22 +8045,31 @@ var CloudWatchLogEventMonitor = class {
       }
     });
   }
-  scheduleNextTick(sleep2) {
-    setTimeout(() => void this.tick(), sleep2);
+  logGroupNames() {
+    return Array.from(this.envsLogGroupsAccessSettings.values()).flatMap((settings) => Object.keys(settings.logGroupsStartTimes));
+  }
+  scheduleNextTick() {
+    if (!this.monitorId) {
+      return;
+    }
+    setTimeout(() => void this.tick(), this.pollingInterval);
   }
   async tick() {
-    if (!this.active) {
+    if (!this.monitorId) {
       return;
     }
     try {
       const events = flatten(await this.readNewEvents());
-      events.forEach((event) => {
-        this.print(event);
-      });
+      for (const event of events) {
+        await this.print(event);
+      }
+      if (!this.monitorId) {
+        return;
+      }
     } catch (e) {
-      error("Error occurred while monitoring logs: %s", e);
+      await this.ioHelper.notify(IO.CDK_TOOLKIT_E5035.msg("Error occurred while monitoring logs: %s", { error: e }));
     }
-    this.scheduleNextTick(SLEEP);
+    this.scheduleNextTick();
   }
   /**
    * Reads all new log events from a set of CloudWatch Log Groups
@@ -7678,15 +8087,16 @@ var CloudWatchLogEventMonitor = class {
   /**
    * Print out a cloudwatch event
    */
-  print(event) {
-    info(
+  async print(event) {
+    await this.ioHelper.notify(IO.CDK_TOOLKIT_I5033.msg(
       util7.format(
         "[%s] %s %s",
         chalk15.blue(event.logGroupName),
         chalk15.yellow(event.timestamp.toLocaleTimeString()),
         event.message.trim()
-      )
-    );
+      ),
+      event
+    ));
   }
   /**
    * Reads all new log events from a CloudWatch Log Group
@@ -7736,13 +8146,13 @@ var CloudWatchLogEventMonitor = class {
 
 // ../../aws-cdk/lib/api/logs/find-cloudwatch-logs.ts
 var IGNORE_LOGS_RESOURCE_TYPES = ["AWS::EC2::FlowLog", "AWS::CloudTrail::Trail", "AWS::CodeBuild::Project"];
-async function findCloudWatchLogGroups(sdkProvider, msg, stackArtifact) {
+async function findCloudWatchLogGroups(sdkProvider, ioHelper, stackArtifact) {
   let sdk;
   const resolvedEnv = await sdkProvider.resolveEnvironment(stackArtifact.environment);
   try {
-    sdk = (await new EnvironmentAccess(sdkProvider, DEFAULT_TOOLKIT_STACK_NAME, msg).accessStackForLookup(stackArtifact)).sdk;
+    sdk = (await new EnvironmentAccess(sdkProvider, DEFAULT_TOOLKIT_STACK_NAME, ioHelper).accessStackForLookup(stackArtifact)).sdk;
   } catch (e) {
-    debug(`Failed to access SDK environment: ${formatErrorMessage(e)}`);
+    await ioHelper.notify(IO.DEFAULT_TOOLKIT_DEBUG.msg(`Failed to access SDK environment: ${formatErrorMessage(e)}`));
     sdk = (await sdkProvider.forEnvironment(resolvedEnv, 0 /* ForReading */)).sdk;
   }
   const listStackResources = new LazyListStackResources(sdk, stackArtifact.stackName);
@@ -7810,12 +8220,11 @@ function findAllLogGroupNames(stackResources, evaluateCfnTemplate) {
 
 // ../../aws-cdk/lib/api/work-graph/work-graph.ts
 var WorkGraph = class {
-  constructor(nodes, props) {
+  constructor(nodes, ioHelper) {
     this.readyPool = [];
     this.lazyDependencies = /* @__PURE__ */ new Map();
     this.nodes = { ...nodes };
-    this.ioHost = props.ioHost;
-    this.action = props.action;
+    this.ioHelper = ioHelper;
   }
   addNodes(...nodes) {
     for (const node of nodes) {
@@ -7972,8 +8381,8 @@ var WorkGraph = class {
   deployed(node) {
     node.deploymentState = "completed" /* COMPLETED */;
   }
-  failed(node, error3) {
-    this.error = error3;
+  failed(node, error4) {
+    this.error = error4;
     node.deploymentState = "failed" /* FAILED */;
     this.skipRest();
     this.readyPool.splice(0);
@@ -8018,7 +8427,7 @@ var WorkGraph = class {
    * Do this in parallel, because there may be a lot of assets in an application (seen in practice: >100 assets)
    */
   async removeUnnecessaryAssets(isUnnecessary) {
-    await this.ioHost.notify(debug2(this.action, "Checking for previously published assets"));
+    await this.ioHelper.notify(debug3("Checking for previously published assets"));
     const publishes = this.nodesOfType("asset-publish");
     const classifiedNodes = await parallelPromises(
       8,
@@ -8028,7 +8437,7 @@ var WorkGraph = class {
     for (const assetNode of alreadyPublished) {
       this.removeNode(assetNode);
     }
-    await this.ioHost.notify(debug2(this.action, `${publishes.length} total assets, ${publishes.length - alreadyPublished.length} still need to be published`));
+    await this.ioHelper.notify(debug3(`${publishes.length} total assets, ${publishes.length - alreadyPublished.length} still need to be published`));
     const unusedBuilds = this.nodesOfType("asset-build").filter((build) => this.dependees(build).length === 0);
     for (const unusedBuild of unusedBuilds) {
       this.removeNode(unusedBuild);
@@ -8046,7 +8455,7 @@ var WorkGraph = class {
     this.readyPool.sort((a, b) => (b.priority ?? 0) - (a.priority ?? 0));
     if (this.readyPool.length === 0 && activeCount === 0 && pendingCount > 0) {
       const cycle = this.findCycle() ?? ["No cycle found!"];
-      await this.ioHost.notify(trace2(this.action, `Cycle ${cycle.join(" -> ")} in graph ${this}`));
+      await this.ioHelper.notify(trace3(`Cycle ${cycle.join(" -> ")} in graph ${this}`));
       throw new ToolkitError(`Unable to make progress anymore, dependency cycle between remaining artifacts: ${cycle.join(" -> ")} (run with -vv for full graph)`);
     }
   }
@@ -8139,12 +8548,11 @@ function simplifyId(id) {
 var cxapi3 = __toESM(require("@aws-cdk/cx-api"));
 var import_cdk_assets4 = require("cdk-assets");
 var WorkGraphBuilder = class _WorkGraphBuilder {
-  constructor({ ioHost, action }, prebuildAssets, idPrefix = "") {
+  constructor(ioHelper, prebuildAssets, idPrefix = "") {
     this.prebuildAssets = prebuildAssets;
     this.idPrefix = idPrefix;
-    this.graph = new WorkGraph({}, { ioHost, action });
-    this.ioHost = ioHost;
-    this.action = action;
+    this.graph = new WorkGraph({}, ioHelper);
+    this.ioHelper = ioHelper;
   }
   static {
     /**
@@ -8238,7 +8646,7 @@ var WorkGraphBuilder = class _WorkGraphBuilder {
       } else if (cxapi3.NestedCloudAssemblyArtifact.isNestedCloudAssemblyArtifact(artifact)) {
         const assembly = new cxapi3.CloudAssembly(artifact.fullPath, { topoSort: false });
         const nestedGraph = new _WorkGraphBuilder(
-          { ioHost: this.ioHost, action: this.action },
+          this.ioHelper,
           this.prebuildAssets,
           `${this.idPrefix}${artifact.id}.`
         ).build(assembly.artifacts);
@@ -8295,24 +8703,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 +8745,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 +8753,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 +8771,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 +8791,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 +8897,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 +8935,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 +8953,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 +8980,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 +9001,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 +9109,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 +9178,8 @@ var AmiContextProviderPlugin = class {
   async getValue(args) {
     const region = args.region;
     const account = args.account;
-    info(`Searching for AMI in ${account}:${region}`);
-    debug(`AMI search parameters: ${JSON.stringify(args)}`);
+    info2(`Searching for AMI in ${account}:${region}`);
+    debug2(`AMI search parameters: ${JSON.stringify(args)}`);
     const ec2 = (await initContextProviderSdk(this.aws, args)).ec2();
     const response = await ec2.describeImages({
       Owners: args.owners,
@@ -8792,7 +9193,7 @@ var AmiContextProviderPlugin = class {
       throw new ContextProviderError("No AMI found that matched the search criteria");
     }
     images.sort(descending((i) => Date.parse(i.CreationDate || "1970")));
-    debug(`Selected image '${images[0].ImageId}' created at '${images[0].CreationDate}'`);
+    debug2(`Selected image '${images[0].ImageId}' created at '${images[0].CreationDate}'`);
     return images[0].ImageId;
   }
 };
@@ -8810,7 +9211,7 @@ var AZContextProviderPlugin = class {
   async getValue(args) {
     const region = args.region;
     const account = args.account;
-    debug(`Reading AZs for ${account}:${region}`);
+    debug2(`Reading AZs for ${account}:${region}`);
     const ec2 = (await initContextProviderSdk(this.aws, args)).ec2();
     const response = await ec2.describeAvailabilityZones({});
     if (!response.AvailabilityZones) {
@@ -8837,8 +9238,8 @@ var CcApiContextProviderPlugin = class {
    */
   async getValue(args) {
     const cloudControl = (await initContextProviderSdk(this.aws, args)).cloudControl();
-    const result = await this.findResources(cloudControl, args);
-    return result;
+    const result2 = await this.findResources(cloudControl, args);
+    return result2;
   }
   async findResources(cc, args) {
     if (args.exactIdentifier && args.propertyMatch) {
@@ -8863,14 +9264,14 @@ var CcApiContextProviderPlugin = class {
   async getResource(cc, typeName, exactIdentifier, propertiesToReturn) {
     const resultObjs = [];
     try {
-      const result = await cc.getResource({
+      const result2 = await cc.getResource({
         TypeName: typeName,
         Identifier: exactIdentifier
       });
-      const id = result.ResourceDescription?.Identifier ?? "";
+      const id = result2.ResourceDescription?.Identifier ?? "";
       if (id !== "") {
-        const propsObject = JSON.parse(result.ResourceDescription?.Properties ?? "");
-        const propsObj = getResultObj(propsObject, result.ResourceDescription?.Identifier, propertiesToReturn);
+        const propsObject = JSON.parse(result2.ResourceDescription?.Properties ?? "");
+        const propsObj = getResultObj(propsObject, result2.ResourceDescription?.Identifier, propertiesToReturn);
         resultObjs.push(propsObj);
       } else {
         throw new ContextProviderError(`Could not get resource ${exactIdentifier}.`);
@@ -8890,10 +9291,10 @@ var CcApiContextProviderPlugin = class {
   async listResources(cc, typeName, propertyMatch, propertiesToReturn) {
     const resultObjs = [];
     try {
-      const result = await cc.listResources({
+      const result2 = await cc.listResources({
         TypeName: typeName
       });
-      result.ResourceDescriptions?.forEach((resource) => {
+      result2.ResourceDescriptions?.forEach((resource) => {
         const id = resource.Identifier ?? "";
         if (id !== "") {
           const propsObject = JSON.parse(resource.Properties ?? "");
@@ -8933,17 +9334,17 @@ var EndpointServiceAZContextProviderPlugin = class {
     const region = args.region;
     const account = args.account;
     const serviceName = args.serviceName;
-    debug(`Reading AZs for ${account}:${region}:${serviceName}`);
+    debug2(`Reading AZs for ${account}:${region}:${serviceName}`);
     const ec2 = (await initContextProviderSdk(this.aws, args)).ec2();
     const response = await ec2.describeVpcEndpointServices({
       ServiceNames: [serviceName]
     });
     if (!response.ServiceDetails || response.ServiceDetails.length === 0) {
-      debug(`Could not retrieve service details for ${account}:${region}:${serviceName}`);
+      debug2(`Could not retrieve service details for ${account}:${region}:${serviceName}`);
       return [];
     }
     const azs = response.ServiceDetails[0].AvailabilityZones;
-    debug(`Endpoint service ${account}:${region}:${serviceName} is available in availability zones ${azs}`);
+    debug2(`Endpoint service ${account}:${region}:${serviceName} is available in availability zones ${azs}`);
     return azs;
   }
 };
@@ -8960,7 +9361,7 @@ var HostedZoneContextProviderPlugin = class {
       throw new ContextProviderError(`HostedZoneProvider requires domainName property to be set in ${args}`);
     }
     const domainName = args.domainName;
-    debug(`Reading hosted zone ${account}:${region}:${domainName}`);
+    debug2(`Reading hosted zone ${account}:${region}:${domainName}`);
     const r53 = (await initContextProviderSdk(this.aws, args)).route53();
     const response = await r53.listHostedZonesByName({ DNSName: domainName });
     if (!response.HostedZones) {
@@ -8979,9 +9380,9 @@ var HostedZoneContextProviderPlugin = class {
   async filterZones(r53, zones, props) {
     let candidates = [];
     const domainName = props.domainName.endsWith(".") ? props.domainName : `${props.domainName}.`;
-    debug(`Found the following zones ${JSON.stringify(zones)}`);
+    debug2(`Found the following zones ${JSON.stringify(zones)}`);
     candidates = zones.filter((zone) => zone.Name === domainName);
-    debug(`Found the following matched name zones ${JSON.stringify(candidates)}`);
+    debug2(`Found the following matched name zones ${JSON.stringify(candidates)}`);
     if (props.privateZone) {
       candidates = candidates.filter((zone) => zone.Config && zone.Config.PrivateZone);
     } else {
@@ -8992,7 +9393,7 @@ var HostedZoneContextProviderPlugin = class {
       for (const zone of candidates) {
         const data = await r53.getHostedZone({ Id: zone.Id });
         if (!data.VPCs) {
-          debug(`Expected VPC for private zone but no VPC found ${zone.Id}`);
+          debug2(`Expected VPC for private zone but no VPC found ${zone.Id}`);
           continue;
         }
         if (data.VPCs.map((vpc) => vpc.VPCId).includes(props.vpcId)) {
@@ -9020,7 +9421,7 @@ var KeyContextProviderPlugin = class {
   }
   // TODO: use paginator function
   async findKey(kms, args) {
-    debug(`Listing keys in ${args.account}:${args.region}`);
+    debug2(`Listing keys in ${args.account}:${args.region}`);
     let response;
     let nextMarker;
     do {
@@ -9047,7 +9448,7 @@ var KeyContextProviderPlugin = class {
     if (!alias.TargetKeyId) {
       throw new ContextProviderError(`Could not find any key with alias named ${args.aliasName}`);
     }
-    debug(`Key found ${alias.TargetKeyId}`);
+    debug2(`Key found ${alias.TargetKeyId}`);
     return {
       keyId: alias.TargetKeyId
     };
@@ -9275,7 +9676,7 @@ var SSMContextProviderPlugin = class {
       throw new ContextProviderError("parameterName must be provided in props for SSMContextProviderPlugin");
     }
     const parameterName = args.parameterName;
-    debug(`Reading SSM parameter ${account}:${region}:${parameterName}`);
+    debug2(`Reading SSM parameter ${account}:${region}:${parameterName}`);
     const response = await this.getSsmParameterValue(args);
     const parameterNotFound = !response.Parameter || response.Parameter.Value === void 0;
     const suppressError = "ignoreErrorOnMissingContext" in args && args.ignoreErrorOnMissingContext;
@@ -9324,7 +9725,7 @@ var VpcNetworkContextProviderPlugin = class {
   }
   async findVpc(ec2, args) {
     const filters = Object.entries(args.filter).map(([tag, value]) => ({ Name: tag, Values: [value] }));
-    debug(`Listing VPCs in ${args.account}:${args.region}`);
+    debug2(`Listing VPCs in ${args.account}:${args.region}`);
     const response = await ec2.describeVpcs({ Filters: filters });
     const vpcs = response.Vpcs || [];
     if (vpcs.length === 0) {
@@ -9337,7 +9738,7 @@ var VpcNetworkContextProviderPlugin = class {
   }
   async readVpcProps(ec2, vpc, args) {
     const vpcId = vpc.VpcId;
-    debug(`Describing VPC ${vpcId}`);
+    debug2(`Describing VPC ${vpcId}`);
     const filters = { Filters: [{ Name: "vpc-id", Values: [vpcId] }] };
     const subnetsResponse = await ec2.describeSubnets(filters);
     const listedSubnets = subnetsResponse.Subnets || [];
@@ -9619,7 +10020,7 @@ async function provideContextValues(missingValues, context, sdk) {
       value = { [cxapi4.PROVIDER_ERROR_KEY]: formatErrorMessage(e), [TRANSIENT_CONTEXT_KEY]: true };
     }
     context.set(key, value);
-    debug(`Setting "${key}" context to ${JSON.stringify(value)}`);
+    debug2(`Setting "${key}" context to ${JSON.stringify(value)}`);
   }
 }
 function registerContextProvider(name, provider) {
@@ -9957,36 +10358,36 @@ var StackCollection = class _StackCollection {
     let warnings = false;
     let errors = false;
     for (const stack of this.stackArtifacts) {
-      for (const message of stack.messages) {
-        switch (message.level) {
+      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 +10403,7 @@ function includeDownstreamStacks(selectedStacks, allStacks) {
     }
   } while (madeProgress);
   if (added.length > 0) {
-    info("Including depending stacks: %s", chalk16.bold(added.join(", ")));
+    info2("Including depending stacks: %s", chalk16.bold(added.join(", ")));
   }
 }
 function includeUpstreamStacks(selectedStacks, allStacks) {
@@ -10021,7 +10422,7 @@ function includeUpstreamStacks(selectedStacks, allStacks) {
     }
   }
   if (added.length > 0) {
-    info("Including dependency stacks: %s", chalk16.bold(added.join(", ")));
+    info2("Including dependency stacks: %s", chalk16.bold(added.join(", ")));
   }
 }
 function sanitizePatterns(patterns) {
@@ -10036,7 +10437,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 +10474,7 @@ async function prepareContext(settings, context, env) {
   }
   const bundlingStacks = settings.get(["bundlingStacks"]) ?? ["**"];
   context[cxapi5.BUNDLING_STACKS] = bundlingStacks;
-  debug("context:", context);
+  debug2("context:", context);
   return context;
 }
 function appToArray(app) {
@@ -10092,7 +10493,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 +10532,6 @@ function spaceAvailableForContext(env, limit) {
   WorkGraphBuilder,
   contextproviders,
   findCloudWatchLogGroups,
-  formatSdkLoggerContent,
   guessExecutable,
   loadTree,
   prepareContext,