@aws-cdk/toolkit-lib 0.1.2 → 0.1.3

package/lib/api/aws-cdk.js

@@ -53,7 +53,6 @@ __export(aws_cdk_exports, {
   ResourceMigrator: () => ResourceMigrator,
   SdkProvider: () => SdkProvider,
   Settings: () => Settings,
-  StackActivityProgress: () => StackActivityProgress,
   StackCollection: () => StackCollection,
   WorkGraphBuilder: () => WorkGraphBuilder,
   contextproviders: () => context_providers_exports,
@@ -102,18 +101,18 @@ var import_util_retry = require("@smithy/util-retry");
 
 // ../../aws-cdk/lib/api/aws-auth/account-cache.ts
 var path2 = __toESM(require("path"));
-var fs2 = __toESM(require("fs-extra"));
+var fs3 = __toESM(require("fs-extra"));
 
 // ../../aws-cdk/lib/logging.ts
-var util2 = __toESM(require("util"));
-var chalk2 = __toESM(require("chalk"));
+var util4 = __toESM(require("util"));
+var chalk4 = __toESM(require("chalk"));
 
 // ../../aws-cdk/lib/toolkit/cli-io-host.ts
-var util = __toESM(require("node:util"));
-var chalk = __toESM(require("chalk"));
+var util3 = __toESM(require("node:util"));
+var chalk3 = __toESM(require("chalk"));
 var promptly = __toESM(require("promptly"));
 
-// ../../aws-cdk/lib/toolkit/error.ts
+// ../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");
@@ -143,6 +142,10 @@ var ToolkitError = class _ToolkitError extends Error {
   static isContextProviderError(x) {
     return this.isToolkitError(x) && CONTEXT_PROVIDER_ERROR_SYMBOL in x;
   }
+  /**
+   * The type of the error, defaults to "toolkit".
+   */
+  type;
   constructor(message, type = "toolkit") {
     super(message);
     Object.setPrototypeOf(this, _ToolkitError.prototype);
@@ -173,136 +176,933 @@ var ContextProviderError = class _ContextProviderError extends ToolkitError {
   }
 };
 
-// ../../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 = {}) {
-    // 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();
+// ../../aws-cdk/lib/util/archive.ts
+var glob = __toESM(require("glob"));
+
+// ../../aws-cdk/lib/util/format-error.ts
+function formatErrorMessage(error3) {
+  if (error3 && Array.isArray(error3.errors)) {
+    const innerMessages = error3.errors.map((innerError) => innerError?.message || innerError?.toString()).join("\n");
+    return `AggregateError: ${innerMessages}`;
   }
-  /**
-   * Returns the singleton instance
-   */
-  static instance(props = {}, forceNew = false) {
-    if (forceNew || !_CliIoHost._instance) {
-      _CliIoHost._instance = new _CliIoHost(props);
-    }
-    return _CliIoHost._instance;
+  return error3?.message || error3?.toString() || "Unknown error";
+}
+
+// ../../aws-cdk/lib/util/archive.ts
+var archiver = require("archiver");
+
+// ../../aws-cdk/lib/util/arrays.ts
+function flatMap(xs, fn) {
+  return flatten(xs.map(fn));
+}
+function flatten(xs) {
+  return Array.prototype.concat.apply([], xs);
+}
+
+// ../../aws-cdk/lib/util/bytes.ts
+function formatBytes(bytes, decimals = 2) {
+  decimals = decimals < 0 ? 0 : decimals;
+  if (bytes === 0) {
+    return "0 Bytes";
   }
-  /**
-   * Returns the singleton instance
-   */
-  registerIoHost(ioHost) {
-    if (ioHost !== this) {
-      this._internalIoHost = ioHost;
+  const k = 1024;
+  const sizes = ["Bytes", "KiB", "MiB", "GiB", "TiB", "PiB", "EiB", "ZiB", "YiB"];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  return `${parseFloat((bytes / Math.pow(k, i)).toFixed(decimals))} ${sizes[i]}`;
+}
+
+// ../../aws-cdk/lib/util/cloudformation.ts
+function validateSnsTopicArn(arn) {
+  return /^arn:aws:sns:[a-z0-9\-]+:[0-9]+:[a-z0-9\-\_]+$/i.test(arn);
+}
+function stackEventHasErrorMessage(status) {
+  return status.endsWith("_FAILED") || status === "ROLLBACK_IN_PROGRESS" || status === "UPDATE_ROLLBACK_IN_PROGRESS";
+}
+function maxResourceTypeLength(template, startWidth = "AWS::CloudFormation::Stack".length) {
+  const resources = template && template.Resources || {};
+  let maxWidth = startWidth;
+  for (const id of Object.keys(resources)) {
+    const type = resources[id].Type || "";
+    if (type.length > maxWidth) {
+      maxWidth = type.length;
     }
   }
-  /**
-   * 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;
+  return maxWidth;
+}
+
+// ../../aws-cdk/lib/util/content-hash.ts
+var crypto = __toESM(require("crypto"));
+function contentHash(data) {
+  return crypto.createHash("sha256").update(data).digest("hex");
+}
+function contentHashAny(value) {
+  const ret = crypto.createHash("sha256");
+  recurse(value);
+  return ret.digest("hex");
+  function recurse(x) {
+    if (typeof x === "string") {
+      ret.update(x);
+      return;
+    }
+    if (Array.isArray(x)) {
+      ret.update("[");
+      for (const e of x) {
+        recurse(e);
+        ret.update("||");
+      }
+      ret.update("]");
+      return;
+    }
+    if (x && typeof x === "object") {
+      ret.update("{");
+      for (const key of Object.keys(x).sort()) {
+        ret.update(key);
+        ret.update(":");
+        recurse(x[key]);
+      }
+      ret.update("}");
+      return;
+    }
+    ret.update(`${x}${typeof x}`);
   }
-  /**
-   * Whether the host can use interactions and message styling.
-   */
-  get isTTY() {
-    return this._isTTY;
+}
+
+// ../../aws-cdk/lib/util/types.ts
+function isObject(x) {
+  return x !== null && typeof x === "object" && !isArray(x);
+}
+var isArray = Array.isArray;
+
+// ../../aws-cdk/lib/util/objects.ts
+function deepClone(x) {
+  if (typeof x === "undefined") {
+    return void 0;
   }
-  /**
-   * Set TTY mode, i.e can the host use interactions and message styling.
-   *
-   * @param value set TTY mode
-   */
-  set isTTY(value) {
-    this._isTTY = value;
+  if (x === null) {
+    return null;
   }
-  /**
-   * 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;
+  if (isArray(x)) {
+    return x.map(deepClone);
   }
-  /**
-   * 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;
+  if (isObject(x)) {
+    return makeObject(mapObject(x, (k, v) => [k, deepClone(v)]));
   }
-  /**
-   * The current threshold. Messages with a lower priority level will be ignored.
-   */
-  get logLevel() {
-    return this._logLevel;
+  return x;
+}
+function mapObject(x, fn) {
+  const ret = [];
+  Object.keys(x).forEach((key) => {
+    ret.push(fn(key, x[key]));
+  });
+  return ret;
+}
+function makeObject(pairs) {
+  const ret = {};
+  for (const pair of pairs) {
+    ret[pair[0]] = pair[1];
   }
-  /**
-   * 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;
+  return ret;
+}
+function deepGet(x, path12) {
+  path12 = path12.slice();
+  while (path12.length > 0 && isObject(x)) {
+    const key = path12.shift();
+    x = x[key];
   }
-  /**
-   * 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).
-   * The corking is bound to the specific instance of the CliIoHost.
-   *
-   * @param block - Async function to execute with corked logging
-   * @returns Promise that resolves with the block's return value
-   */
-  async withCorkedLogging(block) {
-    this.corkedCounter++;
-    try {
-      return await block();
-    } finally {
-      this.corkedCounter--;
-      if (this.corkedCounter === 0) {
-        for (const ioMessage of this.corkedLoggingBuffer) {
-          await this.notify(ioMessage);
-        }
-        this.corkedLoggingBuffer.splice(0);
-      }
-    }
+  return path12.length === 0 ? x : void 0;
+}
+function deepSet(x, path12, value) {
+  path12 = path12.slice();
+  if (path12.length === 0) {
+    throw new ToolkitError("Path may not be empty");
   }
-  /**
-   * Notifies the host of a message.
-   * The caller waits until the notification completes.
-   */
-  async notify(msg) {
-    if (this._internalIoHost) {
-      return this._internalIoHost.notify(msg);
-    }
-    if (levelPriority[msg.level] > levelPriority[this.logLevel]) {
-      return;
-    }
-    if (this.corkedCounter > 0) {
-      this.corkedLoggingBuffer.push(msg);
-      return;
+  while (path12.length > 1 && isObject(x)) {
+    const key = path12.shift();
+    if (!(key in x)) {
+      x[key] = {};
     }
-    const output = this.formatMessage(msg);
-    const stream = this.selectStream(msg.level);
-    stream.write(output);
+    x = x[key];
+  }
+  if (!isObject(x)) {
+    throw new ToolkitError(`Expected an object, got '${x}'`);
+  }
+  if (value !== void 0) {
+    x[path12[0]] = value;
+  } else {
+    delete x[path12[0]];
+  }
+}
+function deepMerge(...objects) {
+  function mergeOne(target, source) {
+    for (const key of Object.keys(source)) {
+      if (key === "__proto__" || key === "constructor") {
+        continue;
+      }
+      const value = source[key];
+      if (isObject(value)) {
+        if (!isObject(target[key])) {
+          target[key] = {};
+        }
+        mergeOne(target[key], value);
+      } else if (typeof value !== "undefined") {
+        target[key] = value;
+      }
+    }
+  }
+  const others = objects.filter((x) => x != null);
+  if (others.length === 0) {
+    return {};
+  }
+  const into = others.splice(0, 1)[0];
+  others.forEach((other) => mergeOne(into, other));
+  return into;
+}
+function splitBySize(data, maxSizeBytes) {
+  if (maxSizeBytes < 2) {
+    return [void 0, data];
+  }
+  const entries = Object.entries(data);
+  return recurse(0, 0);
+  function recurse(index, runningTotalSize) {
+    if (index >= entries.length) {
+      return [data, void 0];
+    }
+    const size = runningTotalSize + entrySize(entries[index]);
+    return size > maxSizeBytes ? cutAt(index) : recurse(index + 1, size);
+  }
+  function entrySize(entry) {
+    return Buffer.byteLength(JSON.stringify(Object.fromEntries([entry])));
+  }
+  function cutAt(index) {
+    return [
+      Object.fromEntries(entries.slice(0, index)),
+      Object.fromEntries(entries.slice(index))
+    ];
+  }
+}
+
+// ../../aws-cdk/lib/util/parallel.ts
+async function parallelPromises(n, promises) {
+  const ret = new Array();
+  let count = 0;
+  let error3;
+  const queue = [...promises];
+  return new Promise((ok, ko) => {
+    tick();
+    function tick() {
+      if (count === 0 && error3) {
+        ko(error3);
+        return;
+      }
+      if (count === 0 && queue.length === 0) {
+        ok(ret);
+        return;
+      }
+      while (count < n && queue.length > 0 && !error3) {
+        const next = queue.shift();
+        if (next !== void 0) {
+          start(next);
+        }
+      }
+    }
+    function start(fn) {
+      count += 1;
+      fn().then((result) => {
+        ret.push(result);
+      }).catch((e) => {
+        error3 = e;
+      }).finally(() => {
+        count -= 1;
+        tick();
+      });
+    }
+  });
+}
+
+// ../../aws-cdk/lib/util/serialize.ts
+var fs = __toESM(require("fs-extra"));
+
+// ../../aws-cdk/lib/util/yaml-cfn.ts
+var yaml = __toESM(require("yaml"));
+var yaml_types = __toESM(require("yaml/types"));
+function serialize(obj) {
+  const oldFold = yaml_types.strOptions.fold.lineWidth;
+  try {
+    yaml_types.strOptions.fold.lineWidth = 0;
+    return yaml.stringify(obj, { schema: "yaml-1.1" });
+  } finally {
+    yaml_types.strOptions.fold.lineWidth = oldFold;
+  }
+}
+function deserialize(str) {
+  return parseYamlStrWithCfnTags(str);
+}
+function makeTagForCfnIntrinsic(intrinsicName, addFnPrefix) {
+  return {
+    identify(value) {
+      return typeof value === "string";
+    },
+    tag: `!${intrinsicName}`,
+    resolve: (_doc, cstNode) => {
+      const ret = {};
+      ret[addFnPrefix ? `Fn::${intrinsicName}` : intrinsicName] = // the +1 is to account for the ! the short form begins with
+      parseYamlStrWithCfnTags(cstNode.toString().substring(intrinsicName.length + 1));
+      return ret;
+    }
+  };
+}
+var shortForms = [
+  "Base64",
+  "Cidr",
+  "FindInMap",
+  "GetAZs",
+  "ImportValue",
+  "Join",
+  "Sub",
+  "Select",
+  "Split",
+  "Transform",
+  "And",
+  "Equals",
+  "If",
+  "Not",
+  "Or",
+  "GetAtt"
+].map((name) => makeTagForCfnIntrinsic(name, true)).concat(
+  makeTagForCfnIntrinsic("Ref", false),
+  makeTagForCfnIntrinsic("Condition", false)
+);
+function parseYamlStrWithCfnTags(text) {
+  return yaml.parse(text, {
+    customTags: shortForms,
+    schema: "core"
+  });
+}
+
+// ../../aws-cdk/lib/util/serialize.ts
+function toYAML(obj) {
+  return serialize(obj);
+}
+function deserializeStructure(str) {
+  return deserialize(str);
+}
+function serializeStructure(object, json) {
+  if (json) {
+    return JSON.stringify(object, void 0, 2);
+  } else {
+    return toYAML(object);
+  }
+}
+function obscureTemplate(template = {}) {
+  if (template.Rules) {
+    if (template.Rules.CheckBootstrapVersion) {
+      if (Object.keys(template.Rules).length > 1) {
+        delete template.Rules.CheckBootstrapVersion;
+      } else {
+        delete template.Rules;
+      }
+    }
+  }
+  return template;
+}
+function isJsonBuffer(value) {
+  return typeof value === "object" && "type" in value && value.type === "Buffer" && "data" in value && Array.isArray(value.data);
+}
+function replacerBufferWithInfo(_key, value) {
+  if (isJsonBuffer(value)) {
+    return `<Buffer: ${formatBytes(value.data.length)}>`;
+  }
+  return value;
+}
+
+// ../../aws-cdk/lib/util/string-manipulation.ts
+function padLeft(n, x, char = " ") {
+  return char.repeat(Math.max(0, n - x.length)) + x;
+}
+function padRight(n, x, char = " ") {
+  return x + char.repeat(Math.max(0, n - x.length));
+}
+function formatTime(num) {
+  return roundPercentage(millisecondsToSeconds(num));
+}
+function roundPercentage(num) {
+  return Math.round(100 * num) / 100;
+}
+function millisecondsToSeconds(num) {
+  return num / 1e3;
+}
+
+// ../../aws-cdk/lib/util/version-range.ts
+var semver = __toESM(require("semver"));
+
+// ../../aws-cdk/lib/cli/activity-printer/base.ts
+var ActivityPrinterBase = class {
+  constructor(props) {
+    this.props = props;
+    /**
+     * The with of the "resource type" column.
+     */
+    this.resourceTypeColumnWidth = maxResourceTypeLength({});
+    /**
+     * A list of resource IDs which are currently being processed
+     */
+    this.resourcesInProgress = {};
+    this.rollingBack = false;
+    this.failures = new Array();
+    this.hookFailureMap = /* @__PURE__ */ new Map();
+    this.stream = props.stream;
+  }
+  static {
+    this.TIMESTAMP_WIDTH = 12;
+  }
+  static {
+    this.STATUS_WIDTH = 20;
+  }
+  /**
+   * Receive a stack activity message
+   */
+  notify(msg) {
+    switch (msg.code) {
+      case "CDK_TOOLKIT_I5501":
+        this.start(msg.data);
+        break;
+      case "CDK_TOOLKIT_I5502":
+        this.activity(msg.data);
+        break;
+      case "CDK_TOOLKIT_I5503":
+        this.stop();
+        break;
+      default:
+        break;
+    }
+  }
+  start({ stack }) {
+    this.resourceTypeColumnWidth = maxResourceTypeLength(stack.template);
+  }
+  activity(activity) {
+    this.addActivity(activity);
+    this.print();
+  }
+  stop() {
+    this.print();
+  }
+  addActivity(activity) {
+    const status = activity.event.ResourceStatus;
+    const hookStatus = activity.event.HookStatus;
+    const hookType = activity.event.HookType;
+    if (!status || !activity.event.LogicalResourceId) {
+      return;
+    }
+    this.stackProgress = activity.progress;
+    if (status === "ROLLBACK_IN_PROGRESS" || status === "UPDATE_ROLLBACK_IN_PROGRESS") {
+      this.rollingBack = true;
+    }
+    if (status.endsWith("_IN_PROGRESS")) {
+      this.resourcesInProgress[activity.event.LogicalResourceId] = activity;
+    }
+    if (stackEventHasErrorMessage(status)) {
+      const isCancelled = (activity.event.ResourceStatusReason ?? "").indexOf("cancelled") > -1;
+      if (!isCancelled) {
+        this.failures.push(activity);
+      }
+    }
+    if (status.endsWith("_COMPLETE") || status.endsWith("_FAILED")) {
+      delete this.resourcesInProgress[activity.event.LogicalResourceId];
+    }
+    if (hookStatus !== void 0 && hookStatus.endsWith("_COMPLETE_FAILED") && activity.event.LogicalResourceId !== void 0 && hookType !== void 0) {
+      if (this.hookFailureMap.has(activity.event.LogicalResourceId)) {
+        this.hookFailureMap.get(activity.event.LogicalResourceId)?.set(hookType, activity.event.HookStatusReason ?? "");
+      } else {
+        this.hookFailureMap.set(activity.event.LogicalResourceId, /* @__PURE__ */ new Map());
+        this.hookFailureMap.get(activity.event.LogicalResourceId)?.set(hookType, activity.event.HookStatusReason ?? "");
+      }
+    }
+  }
+  failureReason(activity) {
+    const resourceStatusReason = activity.event.ResourceStatusReason ?? "";
+    const logicalResourceId = activity.event.LogicalResourceId ?? "";
+    const hookFailureReasonMap = this.hookFailureMap.get(logicalResourceId);
+    if (hookFailureReasonMap !== void 0) {
+      for (const hookType of hookFailureReasonMap.keys()) {
+        if (resourceStatusReason.includes(hookType)) {
+          return resourceStatusReason + " : " + hookFailureReasonMap.get(hookType);
+        }
+      }
+    }
+    return resourceStatusReason;
+  }
+  /**
+   * Is the activity a meta activity for the stack itself.
+   */
+  isActivityForTheStack(activity) {
+    return activity.event.PhysicalResourceId === activity.event.StackId;
+  }
+};
+
+// ../../aws-cdk/lib/cli/activity-printer/history.ts
+var util = __toESM(require("util"));
+var chalk = __toESM(require("chalk"));
+var HistoryActivityPrinter = class _HistoryActivityPrinter extends ActivityPrinterBase {
+  constructor(props) {
+    super(props);
+    /**
+     * Last time we printed something to the console.
+     *
+     * Used to measure timeout for progress reporting.
+     */
+    this.lastPrintTime = Date.now();
+    /**
+     * Number of ms of change absence before we tell the user about the resources that are currently in progress.
+     */
+    this.inProgressDelay = 3e4;
+    this.printable = new Array();
+  }
+  activity(activity) {
+    this.printable.push(activity);
+    super.activity(activity);
+  }
+  stop() {
+    super.stop();
+    if (this.failures.length > 0) {
+      this.stream.write("\nFailed resources:\n");
+      for (const failure of this.failures) {
+        if (this.isActivityForTheStack(failure)) {
+          continue;
+        }
+        this.printOne(failure, false);
+      }
+    }
+  }
+  print() {
+    for (const activity of this.printable) {
+      this.printOne(activity);
+      this.lastPrinted = activity;
+    }
+    this.printable.splice(0, this.printable.length);
+    this.printInProgress(this.lastPrinted?.progress.formatted);
+  }
+  printOne(activity, progress) {
+    const event = activity.event;
+    const color = colorFromStatusResult(event.ResourceStatus);
+    let reasonColor = chalk.cyan;
+    let stackTrace = "";
+    const metadata = activity.metadata;
+    if (event.ResourceStatus && event.ResourceStatus.indexOf("FAILED") !== -1) {
+      if (progress == void 0 || progress) {
+        event.ResourceStatusReason = event.ResourceStatusReason ? this.failureReason(activity) : "";
+      }
+      if (metadata) {
+        stackTrace = metadata.entry.trace ? `
+	${metadata.entry.trace.join("\n	\\_ ")}` : "";
+      }
+      reasonColor = chalk.red;
+    }
+    const resourceName = metadata ? metadata.constructPath : event.LogicalResourceId || "";
+    const logicalId = resourceName !== event.LogicalResourceId ? `(${event.LogicalResourceId}) ` : "";
+    this.stream.write(
+      util.format(
+        "%s | %s%s | %s | %s | %s %s%s%s\n",
+        event.StackName,
+        progress !== false ? `${activity.progress.formatted} | ` : "",
+        new Date(event.Timestamp).toLocaleTimeString(),
+        color(padRight(_HistoryActivityPrinter.STATUS_WIDTH, (event.ResourceStatus || "").slice(0, _HistoryActivityPrinter.STATUS_WIDTH))),
+        // pad left and trim
+        padRight(this.resourceTypeColumnWidth, event.ResourceType || ""),
+        color(chalk.bold(resourceName)),
+        logicalId,
+        reasonColor(chalk.bold(event.ResourceStatusReason ? event.ResourceStatusReason : "")),
+        reasonColor(stackTrace)
+      )
+    );
+    this.lastPrintTime = Date.now();
+  }
+  /**
+   * If some resources are taking a while to create, notify the user about what's currently in progress
+   */
+  printInProgress(progress) {
+    if (!progress || Date.now() < this.lastPrintTime + this.inProgressDelay) {
+      return;
+    }
+    if (Object.keys(this.resourcesInProgress).length > 0) {
+      this.stream.write(
+        util.format(
+          "%s Currently in progress: %s\n",
+          progress,
+          chalk.bold(Object.keys(this.resourcesInProgress).join(", "))
+        )
+      );
+    }
+    this.lastPrintTime = Infinity;
+  }
+};
+function colorFromStatusResult(status) {
+  if (!status) {
+    return chalk.reset;
+  }
+  if (status.indexOf("FAILED") !== -1) {
+    return chalk.red;
+  }
+  if (status.indexOf("ROLLBACK") !== -1) {
+    return chalk.yellow;
+  }
+  if (status.indexOf("COMPLETE") !== -1) {
+    return chalk.green;
+  }
+  return chalk.reset;
+}
+
+// ../../aws-cdk/lib/cli/activity-printer/current.ts
+var util2 = __toESM(require("util"));
+var chalk2 = __toESM(require("chalk"));
+
+// ../../aws-cdk/lib/cli/activity-printer/display.ts
+var wrapAnsi = require("wrap-ansi");
+var RewritableBlock = class {
+  constructor(stream) {
+    this.stream = stream;
+    this.lastHeight = 0;
+    this.trailingEmptyLines = 0;
+  }
+  get width() {
+    return this.stream.columns;
+  }
+  get height() {
+    return this.stream.rows;
+  }
+  displayLines(lines) {
+    lines = terminalWrap(this.width, expandNewlines(lines));
+    lines = lines.slice(0, getMaxBlockHeight(this.height, this.lastHeight, lines));
+    this.stream.write(cursorUp(this.lastHeight));
+    for (const line of lines) {
+      this.stream.write(cll() + line + "\n");
+    }
+    this.trailingEmptyLines = Math.max(0, this.lastHeight - lines.length);
+    for (let i = 0; i < this.trailingEmptyLines; i++) {
+      this.stream.write(cll() + "\n");
+    }
+    this.lastHeight = Math.max(this.lastHeight, lines.length);
+  }
+  removeEmptyLines() {
+    this.stream.write(cursorUp(this.trailingEmptyLines));
+  }
+};
+var ESC = "\x1B";
+function cursorUp(n) {
+  n = typeof n === "number" ? n : 1;
+  return n > 0 ? ESC + "[" + n + "A" : "";
+}
+function cll() {
+  return ESC + "[K";
+}
+function terminalWrap(width, lines) {
+  if (width === void 0) {
+    return lines;
+  }
+  return lines.flatMap((line) => wrapAnsi(line, width - 1, {
+    hard: true,
+    trim: true,
+    wordWrap: false
+  }).split("\n"));
+}
+function expandNewlines(lines) {
+  return lines.flatMap((line) => line.split("\n"));
+}
+function getMaxBlockHeight(windowHeight, lastHeight, lines) {
+  if (windowHeight === void 0) {
+    return Math.max(lines.length, lastHeight);
+  }
+  return lines.length < windowHeight ? lines.length : windowHeight - 1;
+}
+
+// ../../aws-cdk/lib/cli/activity-printer/current.ts
+var CurrentActivityPrinter = class _CurrentActivityPrinter extends ActivityPrinterBase {
+  constructor(props) {
+    super(props);
+    this.block = new RewritableBlock(this.stream);
+  }
+  print() {
+    const lines = [];
+    const progressWidth = Math.max(
+      Math.min((this.block.width ?? 80) - PROGRESSBAR_EXTRA_SPACE - 1, MAX_PROGRESSBAR_WIDTH),
+      MIN_PROGRESSBAR_WIDTH
+    );
+    const prog = this.progressBar(progressWidth);
+    if (prog) {
+      lines.push("  " + prog, "");
+    }
+    const toPrint = [...this.failures, ...Object.values(this.resourcesInProgress)];
+    toPrint.sort((a, b) => a.event.Timestamp.getTime() - b.event.Timestamp.getTime());
+    lines.push(
+      ...toPrint.map((res) => {
+        const color = colorFromStatusActivity(res.event.ResourceStatus);
+        const resourceName = res.metadata?.constructPath ?? res.event.LogicalResourceId ?? "";
+        return util2.format(
+          "%s | %s | %s | %s%s",
+          padLeft(_CurrentActivityPrinter.TIMESTAMP_WIDTH, new Date(res.event.Timestamp).toLocaleTimeString()),
+          color(padRight(_CurrentActivityPrinter.STATUS_WIDTH, (res.event.ResourceStatus || "").slice(0, _CurrentActivityPrinter.STATUS_WIDTH))),
+          padRight(this.resourceTypeColumnWidth, res.event.ResourceType || ""),
+          color(chalk2.bold(shorten(40, resourceName))),
+          this.failureReasonOnNextLine(res)
+        );
+      })
+    );
+    this.block.displayLines(lines);
+  }
+  stop() {
+    super.stop();
+    const lines = new Array();
+    for (const failure of this.failures) {
+      if (this.isActivityForTheStack(failure)) {
+        continue;
+      }
+      lines.push(
+        util2.format(
+          chalk2.red("%s | %s | %s | %s%s") + "\n",
+          padLeft(_CurrentActivityPrinter.TIMESTAMP_WIDTH, new Date(failure.event.Timestamp).toLocaleTimeString()),
+          padRight(_CurrentActivityPrinter.STATUS_WIDTH, (failure.event.ResourceStatus || "").slice(0, _CurrentActivityPrinter.STATUS_WIDTH)),
+          padRight(this.resourceTypeColumnWidth, failure.event.ResourceType || ""),
+          shorten(40, failure.event.LogicalResourceId ?? ""),
+          this.failureReasonOnNextLine(failure)
+        )
+      );
+      const trace3 = failure.metadata?.entry?.trace;
+      if (trace3) {
+        lines.push(chalk2.red(`	${trace3.join("\n	\\_ ")}
+`));
+      }
+    }
+    this.block.displayLines(lines);
+    this.block.removeEmptyLines();
+  }
+  progressBar(width) {
+    if (!this.stackProgress || !this.stackProgress.total) {
+      return "";
+    }
+    const fraction = Math.min(this.stackProgress.completed / this.stackProgress.total, 1);
+    const innerWidth = Math.max(1, width - 2);
+    const chars = innerWidth * fraction;
+    const remainder = chars - Math.floor(chars);
+    const fullChars = FULL_BLOCK.repeat(Math.floor(chars));
+    const partialChar = PARTIAL_BLOCK[Math.floor(remainder * PARTIAL_BLOCK.length)];
+    const filler = "\xB7".repeat(innerWidth - Math.floor(chars) - (partialChar ? 1 : 0));
+    const color = this.rollingBack ? chalk2.yellow : chalk2.green;
+    return "[" + color(fullChars + partialChar) + filler + `] (${this.stackProgress.completed}/${this.stackProgress.total})`;
+  }
+  failureReasonOnNextLine(activity) {
+    return stackEventHasErrorMessage(activity.event.ResourceStatus ?? "") ? `
+${" ".repeat(_CurrentActivityPrinter.TIMESTAMP_WIDTH + _CurrentActivityPrinter.STATUS_WIDTH + 6)}${chalk2.red(this.failureReason(activity) ?? "")}` : "";
+  }
+};
+var FULL_BLOCK = "\u2588";
+var PARTIAL_BLOCK = ["", "\u258F", "\u258E", "\u258D", "\u258C", "\u258B", "\u258A", "\u2589"];
+var MAX_PROGRESSBAR_WIDTH = 60;
+var MIN_PROGRESSBAR_WIDTH = 10;
+var PROGRESSBAR_EXTRA_SPACE = 2 + 2 + 4 + 6;
+function colorFromStatusActivity(status) {
+  if (!status) {
+    return chalk2.reset;
+  }
+  if (status.endsWith("_FAILED")) {
+    return chalk2.red;
+  }
+  if (status.startsWith("CREATE_") || status.startsWith("UPDATE_") || status.startsWith("IMPORT_")) {
+    return chalk2.green;
+  }
+  if (status.indexOf("ROLLBACK_") !== -1) {
+    return chalk2.yellow;
+  }
+  if (status.startsWith("DELETE_")) {
+    return chalk2.yellow;
+  }
+  return chalk2.reset;
+}
+function shorten(maxWidth, p) {
+  if (p.length <= maxWidth) {
+    return p;
+  }
+  const half = Math.floor((maxWidth - 3) / 2);
+  return p.slice(0, half) + "..." + p.slice(-half);
+}
+
+// ../../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.stackProgress = props.stackProgress ?? "bar" /* BAR */;
+  }
+  /**
+   * Returns the singleton instance
+   */
+  static instance(props = {}, forceNew = false) {
+    if (forceNew || !_CliIoHost._instance) {
+      _CliIoHost._instance = new _CliIoHost(props);
+    }
+    return _CliIoHost._instance;
+  }
+  /**
+   * Returns the singleton instance
+   */
+  registerIoHost(ioHost) {
+    if (ioHost !== this) {
+      this._internalIoHost = ioHost;
+    }
+  }
+  /**
+   * Update the stackProgress preference.
+   */
+  set stackProgress(type) {
+    this._progress = type;
+  }
+  /**
+   * Gets the stackProgress value.
+   *
+   * This takes into account other state of the ioHost,
+   * like if isTTY and isCI.
+   */
+  get stackProgress() {
+    if (this._progress === "events" /* EVENTS */) {
+      return this._progress;
+    }
+    const verboseLogging = levelPriority[this.logLevel] > levelPriority.info;
+    if (verboseLogging) {
+      return "events" /* EVENTS */;
+    }
+    const isWindows = process.platform === "win32";
+    if (isWindows) {
+      return "events" /* EVENTS */;
+    }
+    const fancyOutputAvailable = this.isTTY && !this.isCI;
+    if (!fancyOutputAvailable) {
+      return "events" /* EVENTS */;
+    }
+    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).
+   * The corking is bound to the specific instance of the CliIoHost.
+   *
+   * @param block - Async function to execute with corked logging
+   * @returns Promise that resolves with the block's return value
+   */
+  async withCorkedLogging(block) {
+    this.corkedCounter++;
+    try {
+      return await block();
+    } finally {
+      this.corkedCounter--;
+      if (this.corkedCounter === 0) {
+        for (const ioMessage of this.corkedLoggingBuffer) {
+          await this.notify(ioMessage);
+        }
+        this.corkedLoggingBuffer.splice(0);
+      }
+    }
+  }
+  /**
+   * Notifies the host of a message.
+   * The caller waits until the notification completes.
+   */
+  async notify(msg) {
+    if (this._internalIoHost) {
+      return this._internalIoHost.notify(msg);
+    }
+    if (this.isStackActivity(msg)) {
+      if (!this.activityPrinter) {
+        this.activityPrinter = this.makeActivityPrinter();
+      }
+      await this.activityPrinter.notify(msg);
+      return;
+    }
+    if (levelPriority[msg.level] > levelPriority[this.logLevel]) {
+      return;
+    }
+    if (this.corkedCounter > 0) {
+      this.corkedLoggingBuffer.push(msg);
+      return;
+    }
+    const output = this.formatMessage(msg);
+    const stream = this.selectStream(msg.level);
+    stream.write(output);
+  }
+  /**
+   * Detect stack activity messages so they can be send to the printer.
+   */
+  isStackActivity(msg) {
+    return [
+      "CDK_TOOLKIT_I5501",
+      "CDK_TOOLKIT_I5502",
+      "CDK_TOOLKIT_I5503"
+    ].includes(msg.code);
   }
   /**
    * Determines the output stream, based on message level and configuration.
@@ -342,14 +1142,14 @@ var CliIoHost = class _CliIoHost {
         throw new ToolkitError(`${motivation}, but concurrency is greater than 1 so we are unable to get a confirmation from the user`);
       }
       if (isConfirmationPrompt(msg)) {
-        const confirmed = await promptly.confirm(`${chalk.cyan(msg.message)} (y/n)`);
+        const confirmed = await promptly.confirm(`${chalk3.cyan(msg.message)} (y/n)`);
         if (!confirmed) {
           throw new ToolkitError("Aborted by user");
         }
         return confirmed;
       }
       const prompt4 = extractPromptInfo(msg);
-      const answer = await promptly.prompt(`${chalk.cyan(msg.message)} (${prompt4.default})`, {
+      const answer = await promptly.prompt(`${chalk3.cyan(msg.message)} (${prompt4.default})`, {
         default: prompt4.default
       });
       return prompt4.convertAnswer(answer);
@@ -370,6 +1170,20 @@ var CliIoHost = class _CliIoHost {
     const pad = (n) => n.toString().padStart(2, "0");
     return `${pad(d.getHours())}:${pad(d.getMinutes())}:${pad(d.getSeconds())}`;
   }
+  /**
+   * Get an instance of the ActivityPrinter
+   */
+  makeActivityPrinter() {
+    const props = {
+      stream: this.selectStream("info")
+    };
+    switch (this.stackProgress) {
+      case "events" /* EVENTS */:
+        return new HistoryActivityPrinter(props);
+      case "bar" /* BAR */:
+        return new CurrentActivityPrinter(props);
+    }
+  }
 };
 function isPromptableRequest(msg) {
   return isConfirmationPrompt(msg) || typeof msg.defaultResponse === "string" || typeof msg.defaultResponse === "number";
@@ -380,17 +1194,17 @@ function isConfirmationPrompt(msg) {
 function extractPromptInfo(msg) {
   const isNumber = typeof msg.defaultResponse === "number";
   return {
-    default: util.format(msg.defaultResponse),
+    default: util3.format(msg.defaultResponse),
     convertAnswer: isNumber ? (v) => Number(v) : (v) => String(v)
   };
 }
 var styleMap = {
-  error: chalk.red,
-  warn: chalk.yellow,
-  result: chalk.white,
-  info: chalk.white,
-  debug: chalk.gray,
-  trace: chalk.gray
+  error: chalk3.red,
+  warn: chalk3.yellow,
+  result: chalk3.white,
+  info: chalk3.white,
+  debug: chalk3.gray,
+  trace: chalk3.gray
 };
 function isCI() {
   return process.env.CI !== void 0 && process.env.CI !== "false" && process.env.CI !== "0";
@@ -399,7 +1213,7 @@ 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 ? util2.format(message, ...args) : message;
+  const formattedMessage = args.length > 0 ? util4.format(message, ...args) : message;
   const finalMessage = style ? style(formattedMessage) : formattedMessage;
   const ioHost = CliIoHost.instance();
   const ioMessage = {
@@ -432,11 +1246,11 @@ var trace = (input, ...args) => {
 };
 
 // ../../aws-cdk/lib/util/directories.ts
-var fs = __toESM(require("fs"));
+var fs2 = __toESM(require("fs"));
 var os = __toESM(require("os"));
 var path = __toESM(require("path"));
 function cdkHomeDir() {
-  const tmpDir = fs.realpathSync(os.tmpdir());
+  const tmpDir = fs2.realpathSync(os.tmpdir());
   let home;
   try {
     let userInfoHome = os.userInfo().homedir;
@@ -446,7 +1260,7 @@ function cdkHomeDir() {
     home = path.join((userInfoHome ?? os.homedir()).trim(), ".cdk");
   } catch {
   }
-  return process.env.CDK_HOME ? path.resolve(process.env.CDK_HOME) : home || fs.mkdtempSync(path.join(tmpDir, ".cdk")).trim();
+  return process.env.CDK_HOME ? path.resolve(process.env.CDK_HOME) : home || fs2.mkdtempSync(path.join(tmpDir, ".cdk")).trim();
 }
 function cdkCacheDir() {
   return path.join(cdkHomeDir(), "cache");
@@ -454,7 +1268,7 @@ function cdkCacheDir() {
 function rootDir(fail) {
   function _rootDir(dirname5) {
     const manifestPath = path.join(dirname5, "package.json");
-    if (fs.existsSync(manifestPath)) {
+    if (fs2.existsSync(manifestPath)) {
       return dirname5;
     }
     if (path.dirname(dirname5) === dirname5) {
@@ -521,7 +1335,7 @@ var AccountAccessKeyCache = class _AccountAccessKeyCache {
   }
   async loadMap() {
     try {
-      return await fs2.readJson(this.cacheFile);
+      return await fs3.readJson(this.cacheFile);
     } catch (e) {
       if (e.code === "ENOENT" || e.code === "EACCES") {
         return {};
@@ -534,8 +1348,8 @@ var AccountAccessKeyCache = class _AccountAccessKeyCache {
   }
   async saveMap(map) {
     try {
-      await fs2.ensureFile(this.cacheFile);
-      await fs2.writeJson(this.cacheFile, map, { spaces: 2 });
+      await fs3.ensureFile(this.cacheFile);
+      await fs3.writeJson(this.cacheFile, map, { spaces: 2 });
     } catch (e) {
       if (e.code === "ENOENT" || e.code === "EACCES" || e.code === "EROFS") {
         return;
@@ -604,13 +1418,13 @@ function traceMemberMethods(constructor) {
 var path3 = __toESM(require("path"));
 
 // ../../aws-cdk/lib/api/aws-auth/util.ts
-var fs3 = __toESM(require("fs-extra"));
+var fs4 = __toESM(require("fs-extra"));
 function readIfPossible(filename) {
   try {
-    if (!fs3.pathExistsSync(filename)) {
+    if (!fs4.pathExistsSync(filename)) {
       return void 0;
     }
-    return fs3.readFileSync(filename, { encoding: "utf-8" });
+    return fs4.readFileSync(filename, { encoding: "utf-8" });
   } catch (e) {
     debug(e);
     return void 0;
@@ -618,21 +1432,12 @@ function readIfPossible(filename) {
 }
 
 // ../../aws-cdk/lib/api/aws-auth/user-agent.ts
-function defaultCliUserAgent() {
-  const root = rootDir(false);
-  const pkg = JSON.parse((root ? readIfPossible(path3.join(root, "package.json")) : void 0) ?? "{}");
-  const name = pkg.name ?? path3.basename(process.argv[1] ?? "cdk-cli");
-  const version = pkg.version ?? "<unknown>";
-  return `${name}/${version}`;
-}
-
-// ../../aws-cdk/lib/util/format-error.ts
-function formatErrorMessage(error3) {
-  if (error3 && Array.isArray(error3.errors)) {
-    const innerMessages = error3.errors.map((innerError) => innerError?.message || innerError?.toString()).join("\n");
-    return `AggregateError: ${innerMessages}`;
-  }
-  return error3?.message || error3?.toString() || "Unknown error";
+function defaultCliUserAgent() {
+  const root = rootDir(false);
+  const pkg = JSON.parse((root ? readIfPossible(path3.join(root, "package.json")) : void 0) ?? "{}");
+  const name = pkg.name ?? path3.basename(process.argv[1] ?? "cdk-cli");
+  const version = pkg.version ?? "<unknown>";
+  return `${name}/${version}`;
 }
 
 // ../../aws-cdk/lib/api/aws-auth/sdk.ts
@@ -1150,11 +1955,11 @@ async function tokenCodeFn(serialArn) {
 }
 
 // ../../aws-cdk/lib/api/aws-auth/credential-plugins.ts
-var import_util4 = require("util");
+var import_util7 = require("util");
 
 // ../../aws-cdk/lib/api/plugin/plugin.ts
-var import_util3 = require("util");
-var chalk3 = __toESM(require("chalk"));
+var import_util6 = require("util");
+var chalk5 = __toESM(require("chalk"));
 
 // ../../aws-cdk/lib/api/plugin/context-provider-plugin.ts
 function isContextProviderPlugin(x) {
@@ -1187,14 +1992,14 @@ var PluginHost = class _PluginHost {
     try {
       const plugin = require(moduleSpec);
       if (!isPlugin(plugin)) {
-        error(`Module ${chalk3.green(moduleSpec)} is not a valid plug-in, or has an unsupported version.`);
+        error(`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 ${chalk3.green(moduleSpec)}: ${e.stack}`);
+      error(`Unable to load ${chalk5.green(moduleSpec)}: ${e.stack}`);
       throw new ToolkitError(`Unable to load plug-in: ${moduleSpec}: ${e}`);
     }
     function isPlugin(x) {
@@ -1243,7 +2048,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_util3.inspect)(provider)}`);
+      throw new ToolkitError(`Object you gave me does not look like a ContextProviderPlugin: ${(0, import_util6.inspect)(provider)}`);
     }
     this.contextProviderPlugins[pluginProviderName] = provider;
   }
@@ -1312,7 +2117,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_util4.inspect)(initial)}`);
+    throw new AuthenticationError(`Plugin returned a value that doesn't resemble AWS credentials: ${(0, import_util7.inspect)(initial)}`);
   }
 }
 function v3ProviderFromV2Credentials(x) {
@@ -1331,7 +2136,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_util4.inspect)(newCreds)}`);
+        throw new AuthenticationError(`Plugin initially returned static V3 credentials but now returned something else: ${(0, import_util7.inspect)(newCreds)}`);
       }
       current = newCreds;
     }
@@ -1600,291 +2405,65 @@ function fmtObtainedCredentials(obtainResult) {
       return `credentials returned by plugin '${obtainResult.pluginName}'`;
     case "incorrectDefault":
       const msg = [];
-      msg.push(`current credentials (which are for account ${obtainResult.accountId}`);
-      if (obtainResult.unusedPlugins.length > 0) {
-        msg.push(`, and none of the following plugins provided credentials: ${obtainResult.unusedPlugins.join(", ")}`);
-      }
-      msg.push(")");
-      return msg.join("");
-  }
-}
-async function initContextProviderSdk(aws, options) {
-  const account = options.account;
-  const region = options.region;
-  const creds = {
-    assumeRoleArn: options.lookupRoleArn,
-    assumeRoleExternalId: options.lookupRoleExternalId,
-    assumeRoleAdditionalOptions: options.assumeRoleAdditionalOptions
-  };
-  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_util5 = require("util");
-
-// ../../aws-cdk/lib/util/serialize.ts
-var fs4 = __toESM(require("fs-extra"));
-
-// ../../aws-cdk/lib/util/bytes.ts
-function formatBytes(bytes, decimals = 2) {
-  decimals = decimals < 0 ? 0 : decimals;
-  if (bytes === 0) {
-    return "0 Bytes";
-  }
-  const k = 1024;
-  const sizes = ["Bytes", "KiB", "MiB", "GiB", "TiB", "PiB", "EiB", "ZiB", "YiB"];
-  const i = Math.floor(Math.log(bytes) / Math.log(k));
-  return `${parseFloat((bytes / Math.pow(k, i)).toFixed(decimals))} ${sizes[i]}`;
-}
-
-// ../../aws-cdk/lib/util/yaml-cfn.ts
-var yaml = __toESM(require("yaml"));
-var yaml_types = __toESM(require("yaml/types"));
-function serialize(obj) {
-  const oldFold = yaml_types.strOptions.fold.lineWidth;
-  try {
-    yaml_types.strOptions.fold.lineWidth = 0;
-    return yaml.stringify(obj, { schema: "yaml-1.1" });
-  } finally {
-    yaml_types.strOptions.fold.lineWidth = oldFold;
-  }
-}
-function deserialize(str) {
-  return parseYamlStrWithCfnTags(str);
-}
-function makeTagForCfnIntrinsic(intrinsicName, addFnPrefix) {
-  return {
-    identify(value) {
-      return typeof value === "string";
-    },
-    tag: `!${intrinsicName}`,
-    resolve: (_doc, cstNode) => {
-      const ret = {};
-      ret[addFnPrefix ? `Fn::${intrinsicName}` : intrinsicName] = // the +1 is to account for the ! the short form begins with
-      parseYamlStrWithCfnTags(cstNode.toString().substring(intrinsicName.length + 1));
-      return ret;
-    }
-  };
-}
-var shortForms = [
-  "Base64",
-  "Cidr",
-  "FindInMap",
-  "GetAZs",
-  "ImportValue",
-  "Join",
-  "Sub",
-  "Select",
-  "Split",
-  "Transform",
-  "And",
-  "Equals",
-  "If",
-  "Not",
-  "Or",
-  "GetAtt"
-].map((name) => makeTagForCfnIntrinsic(name, true)).concat(
-  makeTagForCfnIntrinsic("Ref", false),
-  makeTagForCfnIntrinsic("Condition", false)
-);
-function parseYamlStrWithCfnTags(text) {
-  return yaml.parse(text, {
-    customTags: shortForms,
-    schema: "core"
-  });
-}
-
-// ../../aws-cdk/lib/util/serialize.ts
-function toYAML(obj) {
-  return serialize(obj);
-}
-function deserializeStructure(str) {
-  return deserialize(str);
-}
-function serializeStructure(object, json) {
-  if (json) {
-    return JSON.stringify(object, void 0, 2);
-  } else {
-    return toYAML(object);
-  }
-}
-function obscureTemplate(template = {}) {
-  if (template.Rules) {
-    if (template.Rules.CheckBootstrapVersion) {
-      if (Object.keys(template.Rules).length > 1) {
-        delete template.Rules.CheckBootstrapVersion;
-      } else {
-        delete template.Rules;
-      }
-    }
-  }
-  return template;
-}
-function isJsonBuffer(value) {
-  return typeof value === "object" && "type" in value && value.type === "Buffer" && "data" in value && Array.isArray(value.data);
-}
-function replacerBufferWithInfo(_key, value) {
-  if (isJsonBuffer(value)) {
-    return `<Buffer: ${formatBytes(value.data.length)}>`;
-  }
-  return value;
-}
-
-// ../../aws-cdk/lib/api/aws-auth/sdk-logger.ts
-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_util5.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"));
-var fs5 = __toESM(require("fs-extra"));
-
-// ../../aws-cdk/lib/util/types.ts
-function isObject(x) {
-  return x !== null && typeof x === "object" && !isArray(x);
-}
-var isArray = Array.isArray;
-
-// ../../aws-cdk/lib/util/objects.ts
-function deepClone(x) {
-  if (typeof x === "undefined") {
-    return void 0;
-  }
-  if (x === null) {
-    return null;
-  }
-  if (isArray(x)) {
-    return x.map(deepClone);
-  }
-  if (isObject(x)) {
-    return makeObject(mapObject(x, (k, v) => [k, deepClone(v)]));
-  }
-  return x;
-}
-function mapObject(x, fn) {
-  const ret = [];
-  Object.keys(x).forEach((key) => {
-    ret.push(fn(key, x[key]));
-  });
-  return ret;
-}
-function makeObject(pairs) {
-  const ret = {};
-  for (const pair of pairs) {
-    ret[pair[0]] = pair[1];
-  }
-  return ret;
-}
-function deepGet(x, path12) {
-  path12 = path12.slice();
-  while (path12.length > 0 && isObject(x)) {
-    const key = path12.shift();
-    x = x[key];
-  }
-  return path12.length === 0 ? x : void 0;
-}
-function deepSet(x, path12, value) {
-  path12 = path12.slice();
-  if (path12.length === 0) {
-    throw new ToolkitError("Path may not be empty");
-  }
-  while (path12.length > 1 && isObject(x)) {
-    const key = path12.shift();
-    if (!(key in x)) {
-      x[key] = {};
-    }
-    x = x[key];
-  }
-  if (!isObject(x)) {
-    throw new ToolkitError(`Expected an object, got '${x}'`);
-  }
-  if (value !== void 0) {
-    x[path12[0]] = value;
-  } else {
-    delete x[path12[0]];
-  }
-}
-function deepMerge(...objects) {
-  function mergeOne(target, source) {
-    for (const key of Object.keys(source)) {
-      if (key === "__proto__" || key === "constructor") {
-        continue;
-      }
-      const value = source[key];
-      if (isObject(value)) {
-        if (!isObject(target[key])) {
-          target[key] = {};
-        }
-        mergeOne(target[key], value);
-      } else if (typeof value !== "undefined") {
-        target[key] = value;
+      msg.push(`current credentials (which are for account ${obtainResult.accountId}`);
+      if (obtainResult.unusedPlugins.length > 0) {
+        msg.push(`, and none of the following plugins provided credentials: ${obtainResult.unusedPlugins.join(", ")}`);
       }
-    }
-  }
-  const others = objects.filter((x) => x != null);
-  if (others.length === 0) {
-    return {};
+      msg.push(")");
+      return msg.join("");
   }
-  const into = others.splice(0, 1)[0];
-  others.forEach((other) => mergeOne(into, other));
-  return into;
 }
-function splitBySize(data, maxSizeBytes) {
-  if (maxSizeBytes < 2) {
-    return [void 0, data];
-  }
-  const entries = Object.entries(data);
-  return recurse(0, 0);
-  function recurse(index, runningTotalSize) {
-    if (index >= entries.length) {
-      return [data, void 0];
+async function initContextProviderSdk(aws, options) {
+  const account = options.account;
+  const region = options.region;
+  const creds = {
+    assumeRoleArn: options.lookupRoleArn,
+    assumeRoleExternalId: options.lookupRoleExternalId,
+    assumeRoleAdditionalOptions: options.assumeRoleAdditionalOptions
+  };
+  return (await aws.forEnvironment(import_cx_api.EnvironmentUtils.make(account, region), 0 /* ForReading */, creds)).sdk;
+}
+
+// ../../aws-cdk/lib/api/aws-auth/sdk-logger.ts
+var import_util8 = require("util");
+function formatSdkLoggerContent(content) {
+  if (content.length === 1) {
+    const apiFmt = formatApiCall(content[0]);
+    if (apiFmt) {
+      return apiFmt;
     }
-    const size = runningTotalSize + entrySize(entries[index]);
-    return size > maxSizeBytes ? cutAt(index) : recurse(index + 1, size);
   }
-  function entrySize(entry) {
-    return Buffer.byteLength(JSON.stringify(Object.fromEntries([entry])));
+  return content.map((x) => typeof x === "string" ? x : (0, import_util8.inspect)(x)).join("");
+}
+function formatApiCall(content) {
+  if (!isSdkApiCallSuccess(content) && !isSdkApiCallError(content)) {
+    return void 0;
   }
-  function cutAt(index) {
-    return [
-      Object.fromEntries(entries.slice(0, index)),
-      Object.fromEntries(entries.slice(index))
-    ];
+  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"));
+var fs5 = __toESM(require("fs-extra"));
 var TRANSIENT_CONTEXT_KEY = "$dontSaveContext";
 var Settings = class _Settings {
   constructor(settings = {}, readOnly = false) {
@@ -2069,7 +2648,7 @@ var Context = class {
 };
 
 // ../../aws-cdk/lib/api/deployments/cloudformation.ts
-var import_util6 = require("util");
+var import_util10 = require("util");
 var cxapi = __toESM(require("@aws-cdk/cx-api"));
 var import_cx_api3 = require("@aws-cdk/cx-api");
 var import_client_cloudformation3 = require("@aws-sdk/client-cloudformation");
@@ -2169,9 +2748,9 @@ var trace2 = (action, message, code, payload) => {
 };
 
 // ../../aws-cdk/lib/api/stack-events/stack-activity-monitor.ts
-var util3 = __toESM(require("util"));
+var util6 = __toESM(require("util"));
 var import_cloud_assembly_schema = require("@aws-cdk/cloud-assembly-schema");
-var chalk4 = __toESM(require("chalk"));
+var uuid = __toESM(require("uuid"));
 
 // ../../aws-cdk/lib/api/stack-events/stack-event-poller.ts
 var StackEventPoller = class _StackEventPoller {
@@ -2257,254 +2836,36 @@ var StackEventPoller = class _StackEventPoller {
    */
   trackNestedStack(event, parentStackLogicalIds) {
     const logicalId = event.LogicalResourceId;
-    const physicalResourceId = event.PhysicalResourceId;
-    if (!logicalId || !physicalResourceId) {
-      return;
-    }
-    if (!this.nestedStackPollers[logicalId]) {
-      this.nestedStackPollers[logicalId] = new _StackEventPoller(this.cfn, {
-        stackName: physicalResourceId,
-        parentStackLogicalIds,
-        startTime: event.Timestamp.valueOf()
-      });
-    }
-  }
-};
-function isStackBeginOperationState(state) {
-  return [
-    "CREATE_IN_PROGRESS",
-    "UPDATE_IN_PROGRESS",
-    "DELETE_IN_PROGRESS",
-    "UPDATE_ROLLBACK_IN_PROGRESS",
-    "ROLLBACK_IN_PROGRESS"
-  ].includes(state ?? "");
-}
-function isStackTerminalState(state) {
-  return !(state ?? "").endsWith("_IN_PROGRESS");
-}
-
-// ../../aws-cdk/lib/api/stack-events/display.ts
-var wrapAnsi = require("wrap-ansi");
-var RewritableBlock = class {
-  constructor(stream) {
-    this.stream = stream;
-    this.lastHeight = 0;
-    this.trailingEmptyLines = 0;
-  }
-  get width() {
-    return this.stream.columns;
-  }
-  get height() {
-    return this.stream.rows;
-  }
-  displayLines(lines) {
-    lines = terminalWrap(this.width, expandNewlines(lines));
-    lines = lines.slice(0, getMaxBlockHeight(this.height, this.lastHeight, lines));
-    this.stream.write(cursorUp(this.lastHeight));
-    for (const line of lines) {
-      this.stream.write(cll() + line + "\n");
-    }
-    this.trailingEmptyLines = Math.max(0, this.lastHeight - lines.length);
-    for (let i = 0; i < this.trailingEmptyLines; i++) {
-      this.stream.write(cll() + "\n");
-    }
-    this.lastHeight = Math.max(this.lastHeight, lines.length);
-  }
-  removeEmptyLines() {
-    this.stream.write(cursorUp(this.trailingEmptyLines));
-  }
-};
-var ESC = "\x1B";
-function cursorUp(n) {
-  n = typeof n === "number" ? n : 1;
-  return n > 0 ? ESC + "[" + n + "A" : "";
-}
-function cll() {
-  return ESC + "[K";
-}
-function terminalWrap(width, lines) {
-  if (width === void 0) {
-    return lines;
-  }
-  return lines.flatMap((line) => wrapAnsi(line, width - 1, {
-    hard: true,
-    trim: true,
-    wordWrap: false
-  }).split("\n"));
-}
-function expandNewlines(lines) {
-  return lines.flatMap((line) => line.split("\n"));
-}
-function getMaxBlockHeight(windowHeight, lastHeight, lines) {
-  if (windowHeight === void 0) {
-    return Math.max(lines.length, lastHeight);
-  }
-  return lines.length < windowHeight ? lines.length : windowHeight - 1;
-}
-
-// ../../aws-cdk/lib/api/stack-events/stack-activity-monitor.ts
-var StackActivityProgress = /* @__PURE__ */ ((StackActivityProgress3) => {
-  StackActivityProgress3["BAR"] = "bar";
-  StackActivityProgress3["EVENTS"] = "events";
-  return StackActivityProgress3;
-})(StackActivityProgress || {});
-var StackActivityMonitor = class _StackActivityMonitor {
-  constructor(cfn, stackName, printer, stack, changeSetCreationTime) {
-    this.stackName = stackName;
-    this.printer = printer;
-    this.stack = stack;
-    this.errors = [];
-    this.active = false;
-    this.poller = new StackEventPoller(cfn, {
-      stackName,
-      startTime: changeSetCreationTime?.getTime() ?? Date.now()
-    });
-  }
-  /**
-   * Create a Stack Activity Monitor using a default printer, based on context clues
-   */
-  static withDefaultPrinter(cfn, stackName, stackArtifact, options = {}) {
-    const stream = options.ci ? process.stdout : process.stderr;
-    const props = {
-      resourceTypeColumnWidth: calcMaxResourceTypeLength(stackArtifact.template),
-      resourcesTotal: options.resourcesTotal,
-      stream
-    };
-    const isWindows = process.platform === "win32";
-    const verbose = options.logLevel ?? "info";
-    const fancyOutputAvailable = !isWindows && stream.isTTY && !options.ci;
-    const progress = options.progress ?? "bar" /* BAR */;
-    const printer = fancyOutputAvailable && !verbose && progress === "bar" /* BAR */ ? new CurrentActivityPrinter(props) : new HistoryActivityPrinter(props);
-    return new _StackActivityMonitor(cfn, stackName, printer, stackArtifact, options.changeSetCreationTime);
-  }
-  start() {
-    this.active = true;
-    this.printer.start();
-    this.scheduleNextTick();
-    return this;
-  }
-  async stop() {
-    this.active = false;
-    if (this.tickTimer) {
-      clearTimeout(this.tickTimer);
-    }
-    await this.finalPollToEnd();
-    this.printer.stop();
-  }
-  scheduleNextTick() {
-    if (!this.active) {
-      return;
-    }
-    this.tickTimer = setTimeout(() => void this.tick(), this.printer.updateSleep);
-  }
-  async tick() {
-    if (!this.active) {
-      return;
-    }
-    try {
-      this.readPromise = this.readNewEvents();
-      await this.readPromise;
-      this.readPromise = void 0;
-      if (!this.active) {
-        return;
-      }
-      this.printer.print();
-    } catch (e) {
-      error("Error occurred while monitoring stack: %s", e);
-    }
-    this.scheduleNextTick();
-  }
-  findMetadataFor(logicalId) {
-    const metadata = this.stack?.manifest?.metadata;
-    if (!logicalId || !metadata) {
-      return void 0;
-    }
-    for (const path12 of Object.keys(metadata)) {
-      const entry = metadata[path12].filter((e) => e.type === import_cloud_assembly_schema.ArtifactMetadataEntryType.LOGICAL_ID).find((e) => e.data === logicalId);
-      if (entry) {
-        return {
-          entry,
-          constructPath: this.simplifyConstructPath(path12)
-        };
-      }
-    }
-    return void 0;
-  }
-  /**
-   * Reads all new events from the stack history
-   *
-   * The events are returned in reverse chronological order; we continue to the next page if we
-   * see a next page and the last event in the page is new to us (and within the time window).
-   * haven't seen the final event
-   */
-  async readNewEvents() {
-    const pollEvents = await this.poller.poll();
-    const activities = pollEvents.map((event) => ({
-      ...event,
-      metadata: this.findMetadataFor(event.event.LogicalResourceId)
-    }));
-    for (const activity of activities) {
-      this.checkForErrors(activity);
-      this.printer.addActivity(activity);
-    }
-  }
-  /**
-   * Perform a final poll to the end and flush out all events to the printer
-   *
-   * Finish any poll currently in progress, then do a final one until we've
-   * reached the last page.
-   */
-  async finalPollToEnd() {
-    if (this.readPromise) {
-      await this.readPromise;
-    }
-    await this.readNewEvents();
-  }
-  checkForErrors(activity) {
-    if (hasErrorMessage(activity.event.ResourceStatus ?? "")) {
-      const isCancelled = (activity.event.ResourceStatusReason ?? "").indexOf("cancelled") > -1;
-      if (!isCancelled && activity.event.StackName !== activity.event.LogicalResourceId) {
-        this.errors.push(activity.event.ResourceStatusReason ?? "");
-      }
-    }
-  }
-  simplifyConstructPath(path12) {
-    path12 = path12.replace(/\/Resource$/, "");
-    path12 = path12.replace(/^\//, "");
-    if (path12.startsWith(this.stackName + "/")) {
-      path12 = path12.slice(this.stackName.length + 1);
+    const physicalResourceId = event.PhysicalResourceId;
+    if (!logicalId || !physicalResourceId) {
+      return;
+    }
+    if (!this.nestedStackPollers[logicalId]) {
+      this.nestedStackPollers[logicalId] = new _StackEventPoller(this.cfn, {
+        stackName: physicalResourceId,
+        parentStackLogicalIds,
+        startTime: event.Timestamp.valueOf()
+      });
     }
-    return path12;
   }
 };
-function padRight(n, x) {
-  return x + " ".repeat(Math.max(0, n - x.length));
-}
-function padLeft(n, x) {
-  return " ".repeat(Math.max(0, n - x.length)) + x;
+function isStackBeginOperationState(state) {
+  return [
+    "CREATE_IN_PROGRESS",
+    "UPDATE_IN_PROGRESS",
+    "DELETE_IN_PROGRESS",
+    "UPDATE_ROLLBACK_IN_PROGRESS",
+    "ROLLBACK_IN_PROGRESS"
+  ].includes(state ?? "");
 }
-function calcMaxResourceTypeLength(template) {
-  const resources = template && template.Resources || {};
-  let maxWidth = 0;
-  for (const id of Object.keys(resources)) {
-    const type = resources[id].Type || "";
-    if (type.length > maxWidth) {
-      maxWidth = type.length;
-    }
-  }
-  return maxWidth;
+function isStackTerminalState(state) {
+  return !(state ?? "").endsWith("_IN_PROGRESS");
 }
-var ActivityPrinterBase = class {
-  constructor(props) {
-    this.props = props;
-    /**
-     * Fetch new activity every 5 seconds
-     */
-    this.updateSleep = 5e3;
-    /**
-     * A list of resource IDs which are currently being processed
-     */
-    this.resourcesInProgress = {};
+
+// ../../aws-cdk/lib/api/stack-events/stack-progress-monitor.ts
+var util5 = __toESM(require("util"));
+var StackProgressMonitor = class {
+  constructor(resourcesTotal) {
     /**
      * Previous completion state observed by logical ID
      *
@@ -2521,319 +2882,234 @@ var ActivityPrinterBase = class {
      * How many digits we need to represent the total count (for lining up the status reporting)
      */
     this.resourceDigits = 0;
-    this.rollingBack = false;
-    this.failures = new Array();
-    this.hookFailureMap = /* @__PURE__ */ new Map();
-    this.resourcesTotal = props.resourcesTotal ? props.resourcesTotal + 1 : void 0;
+    this.resourcesTotal = resourcesTotal ? resourcesTotal + 1 : void 0;
     this.resourceDigits = this.resourcesTotal ? Math.ceil(Math.log10(this.resourcesTotal)) : 0;
   }
-  failureReason(activity) {
-    const resourceStatusReason = activity.event.ResourceStatusReason ?? "";
-    const logicalResourceId = activity.event.LogicalResourceId ?? "";
-    const hookFailureReasonMap = this.hookFailureMap.get(logicalResourceId);
-    if (hookFailureReasonMap !== void 0) {
-      for (const hookType of hookFailureReasonMap.keys()) {
-        if (resourceStatusReason.includes(hookType)) {
-          return resourceStatusReason + " : " + hookFailureReasonMap.get(hookType);
-        }
-      }
-    }
-    return resourceStatusReason;
-  }
-  addActivity(activity) {
-    const status = activity.event.ResourceStatus;
-    const hookStatus = activity.event.HookStatus;
-    const hookType = activity.event.HookType;
-    if (!status || !activity.event.LogicalResourceId) {
-      return;
-    }
-    if (status === "ROLLBACK_IN_PROGRESS" || status === "UPDATE_ROLLBACK_IN_PROGRESS") {
-      this.rollingBack = true;
-    }
-    if (status.endsWith("_IN_PROGRESS")) {
-      this.resourcesInProgress[activity.event.LogicalResourceId] = activity;
-    }
-    if (hasErrorMessage(status)) {
-      const isCancelled = (activity.event.ResourceStatusReason ?? "").indexOf("cancelled") > -1;
-      if (!isCancelled) {
-        this.failures.push(activity);
-      }
-    }
-    if (status.endsWith("_COMPLETE") || status.endsWith("_FAILED")) {
-      delete this.resourcesInProgress[activity.event.LogicalResourceId];
-    }
-    if (status.endsWith("_COMPLETE_CLEANUP_IN_PROGRESS")) {
-      this.resourcesDone++;
-    }
-    if (status.endsWith("_COMPLETE")) {
-      const prevState = this.resourcesPrevCompleteState[activity.event.LogicalResourceId];
-      if (!prevState) {
-        this.resourcesDone++;
-      } else {
-        this.resourcesDone--;
-        if (this.resourcesDone < 0) {
-          this.resourcesDone = 0;
-        }
-      }
-      this.resourcesPrevCompleteState[activity.event.LogicalResourceId] = status;
-    }
-    if (hookStatus !== void 0 && hookStatus.endsWith("_COMPLETE_FAILED") && activity.event.LogicalResourceId !== void 0 && hookType !== void 0) {
-      if (this.hookFailureMap.has(activity.event.LogicalResourceId)) {
-        this.hookFailureMap.get(activity.event.LogicalResourceId)?.set(hookType, activity.event.HookStatusReason ?? "");
-      } else {
-        this.hookFailureMap.set(activity.event.LogicalResourceId, /* @__PURE__ */ new Map());
-        this.hookFailureMap.get(activity.event.LogicalResourceId)?.set(hookType, activity.event.HookStatusReason ?? "");
-      }
-    }
-  }
-  start() {
-  }
-  stop() {
-  }
-};
-var HistoryActivityPrinter = class extends ActivityPrinterBase {
-  constructor(props) {
-    super(props);
-    /**
-     * Last time we printed something to the console.
-     *
-     * Used to measure timeout for progress reporting.
-     */
-    this.lastPrintTime = Date.now();
-    /**
-     * Number of ms of change absence before we tell the user about the resources that are currently in progress.
-     */
-    this.inProgressDelay = 3e4;
-    this.printable = new Array();
-  }
-  addActivity(activity) {
-    super.addActivity(activity);
-    this.printable.push(activity);
-    this.print();
-  }
-  print() {
-    for (const activity of this.printable) {
-      this.printOne(activity);
-    }
-    this.printable.splice(0, this.printable.length);
-    this.printInProgress();
+  /**
+   * Report the stack progress
+   */
+  get progress() {
+    return {
+      total: this.total,
+      completed: this.completed,
+      formatted: this.formatted
+    };
   }
-  stop() {
-    if (this.failures.length > 0) {
-      info("\nFailed resources:");
-      for (const failure of this.failures) {
-        if (failure.isStackEvent) {
-          continue;
-        }
-        this.printOne(failure, false);
-      }
-    }
+  /**
+   * The total number of progress monitored resources.
+   */
+  get total() {
+    return this.resourcesTotal;
   }
-  printOne(activity, progress) {
-    const event = activity.event;
-    const color = colorFromStatusResult(event.ResourceStatus);
-    let reasonColor = chalk4.cyan;
-    let stackTrace = "";
-    const metadata = activity.metadata;
-    if (event.ResourceStatus && event.ResourceStatus.indexOf("FAILED") !== -1) {
-      if (progress == void 0 || progress) {
-        event.ResourceStatusReason = event.ResourceStatusReason ? this.failureReason(activity) : "";
-      }
-      if (metadata) {
-        stackTrace = metadata.entry.trace ? `
-	${metadata.entry.trace.join("\n	\\_ ")}` : "";
-      }
-      reasonColor = chalk4.red;
-    }
-    const resourceName = metadata ? metadata.constructPath : event.LogicalResourceId || "";
-    const logicalId = resourceName !== event.LogicalResourceId ? `(${event.LogicalResourceId}) ` : "";
-    info(
-      util3.format(
-        "%s | %s%s | %s | %s | %s %s%s%s",
-        event.StackName,
-        progress !== false ? `${this.progress()} | ` : "",
-        new Date(event.Timestamp).toLocaleTimeString(),
-        color(padRight(STATUS_WIDTH, (event.ResourceStatus || "").slice(0, STATUS_WIDTH))),
-        // pad left and trim
-        padRight(this.props.resourceTypeColumnWidth, event.ResourceType || ""),
-        color(chalk4.bold(resourceName)),
-        logicalId,
-        reasonColor(chalk4.bold(event.ResourceStatusReason ? event.ResourceStatusReason : "")),
-        reasonColor(stackTrace)
-      )
-    );
-    this.lastPrintTime = Date.now();
+  /**
+   * The number of completed resources.
+   */
+  get completed() {
+    return this.resourcesDone;
   }
   /**
    * Report the current progress as a [34/42] string, or just [34] if the total is unknown
    */
-  progress() {
+  get formatted() {
     if (this.resourcesTotal == null) {
-      return padLeft(3, util3.format("%s", this.resourcesDone));
+      return padLeft(3, util5.format("%s", this.resourcesDone));
     }
-    return util3.format(
+    return util5.format(
       "%s/%s",
       padLeft(this.resourceDigits, this.resourcesDone.toString()),
-      padLeft(this.resourceDigits, this.resourcesTotal != null ? this.resourcesTotal.toString() : "?")
+      padLeft(this.resourceDigits, this.resourcesTotal.toString())
     );
   }
   /**
-   * If some resources are taking a while to create, notify the user about what's currently in progress
+   * Process as stack event and update the progress state.
    */
-  printInProgress() {
-    if (Date.now() < this.lastPrintTime + this.inProgressDelay) {
+  process(event) {
+    const status = event.ResourceStatus;
+    if (!status || !event.LogicalResourceId) {
       return;
     }
-    if (Object.keys(this.resourcesInProgress).length > 0) {
-      info(
-        util3.format(
-          "%s Currently in progress: %s",
-          this.progress(),
-          chalk4.bold(Object.keys(this.resourcesInProgress).join(", "))
-        )
-      );
-    }
-    this.lastPrintTime = Infinity;
-  }
-};
-var CurrentActivityPrinter = class extends ActivityPrinterBase {
-  constructor(props) {
-    super(props);
-    /**
-     * This looks very disorienting sleeping for 5 seconds. Update quicker.
-     */
-    this.updateSleep = 2e3;
-    this.oldLogThreshold = CliIoHost.instance().logLevel;
-    this.stream = props.stream;
-    this.block = new RewritableBlock(this.stream);
-  }
-  print() {
-    const lines = [];
-    const progressWidth = Math.max(
-      Math.min((this.block.width ?? 80) - PROGRESSBAR_EXTRA_SPACE - 1, MAX_PROGRESSBAR_WIDTH),
-      MIN_PROGRESSBAR_WIDTH
-    );
-    const prog = this.progressBar(progressWidth);
-    if (prog) {
-      lines.push("  " + prog, "");
+    if (status.endsWith("_COMPLETE_CLEANUP_IN_PROGRESS")) {
+      this.resourcesDone++;
     }
-    const toPrint = [...this.failures, ...Object.values(this.resourcesInProgress)];
-    toPrint.sort((a, b) => a.event.Timestamp.getTime() - b.event.Timestamp.getTime());
-    lines.push(
-      ...toPrint.map((res) => {
-        const color = colorFromStatusActivity(res.event.ResourceStatus);
-        const resourceName = res.metadata?.constructPath ?? res.event.LogicalResourceId ?? "";
-        return util3.format(
-          "%s | %s | %s | %s%s",
-          padLeft(TIMESTAMP_WIDTH, new Date(res.event.Timestamp).toLocaleTimeString()),
-          color(padRight(STATUS_WIDTH, (res.event.ResourceStatus || "").slice(0, STATUS_WIDTH))),
-          padRight(this.props.resourceTypeColumnWidth, res.event.ResourceType || ""),
-          color(chalk4.bold(shorten(40, resourceName))),
-          this.failureReasonOnNextLine(res)
-        );
-      })
-    );
-    this.block.displayLines(lines);
-  }
-  start() {
-    this.oldLogThreshold = CliIoHost.instance().logLevel;
-    CliIoHost.instance().logLevel = "info";
-  }
-  stop() {
-    CliIoHost.instance().logLevel = this.oldLogThreshold;
-    const lines = new Array();
-    for (const failure of this.failures) {
-      if (failure.isStackEvent) {
-        continue;
-      }
-      lines.push(
-        util3.format(
-          chalk4.red("%s | %s | %s | %s%s") + "\n",
-          padLeft(TIMESTAMP_WIDTH, new Date(failure.event.Timestamp).toLocaleTimeString()),
-          padRight(STATUS_WIDTH, (failure.event.ResourceStatus || "").slice(0, STATUS_WIDTH)),
-          padRight(this.props.resourceTypeColumnWidth, failure.event.ResourceType || ""),
-          shorten(40, failure.event.LogicalResourceId ?? ""),
-          this.failureReasonOnNextLine(failure)
-        )
-      );
-      const trace3 = failure.metadata?.entry?.trace;
-      if (trace3) {
-        lines.push(chalk4.red(`	${trace3.join("\n	\\_ ")}
-`));
+    if (status.endsWith("_COMPLETE")) {
+      const prevState = this.resourcesPrevCompleteState[event.LogicalResourceId];
+      if (!prevState) {
+        this.resourcesDone++;
+      } else {
+        this.resourcesDone--;
+        if (this.resourcesDone < 0) {
+          this.resourcesDone = 0;
+        }
       }
+      this.resourcesPrevCompleteState[event.LogicalResourceId] = status;
     }
-    this.block.displayLines(lines);
-    this.block.removeEmptyLines();
-  }
-  progressBar(width) {
-    if (!this.resourcesTotal) {
-      return "";
-    }
-    const fraction = Math.min(this.resourcesDone / this.resourcesTotal, 1);
-    const innerWidth = Math.max(1, width - 2);
-    const chars = innerWidth * fraction;
-    const remainder = chars - Math.floor(chars);
-    const fullChars = FULL_BLOCK.repeat(Math.floor(chars));
-    const partialChar = PARTIAL_BLOCK[Math.floor(remainder * PARTIAL_BLOCK.length)];
-    const filler = "\xB7".repeat(innerWidth - Math.floor(chars) - (partialChar ? 1 : 0));
-    const color = this.rollingBack ? chalk4.yellow : chalk4.green;
-    return "[" + color(fullChars + partialChar) + filler + `] (${this.resourcesDone}/${this.resourcesTotal})`;
   }
-  failureReasonOnNextLine(activity) {
-    return hasErrorMessage(activity.event.ResourceStatus ?? "") ? `
-${" ".repeat(TIMESTAMP_WIDTH + STATUS_WIDTH + 6)}${chalk4.red(this.failureReason(activity) ?? "")}` : "";
+};
+
+// ../../aws-cdk/lib/api/stack-events/stack-activity-monitor.ts
+var StackActivityMonitor = class {
+  constructor({
+    cfn,
+    ioHost,
+    action,
+    stack,
+    stackName,
+    resourcesTotal,
+    changeSetCreationTime,
+    pollingInterval = 2e3
+  }) {
+    this.errors = [];
+    this.ioHost = ioHost;
+    this.action = action;
+    this.stack = stack;
+    this.stackName = stackName;
+    this.progressMonitor = new StackProgressMonitor(resourcesTotal);
+    this.pollingInterval = pollingInterval;
+    this.poller = new StackEventPoller(cfn, {
+      stackName,
+      startTime: changeSetCreationTime?.getTime() ?? Date.now()
+    });
   }
-};
-var FULL_BLOCK = "\u2588";
-var PARTIAL_BLOCK = ["", "\u258F", "\u258E", "\u258D", "\u258C", "\u258B", "\u258A", "\u2589"];
-var MAX_PROGRESSBAR_WIDTH = 60;
-var MIN_PROGRESSBAR_WIDTH = 10;
-var PROGRESSBAR_EXTRA_SPACE = 2 + 2 + 4 + 6;
-function hasErrorMessage(status) {
-  return status.endsWith("_FAILED") || status === "ROLLBACK_IN_PROGRESS" || status === "UPDATE_ROLLBACK_IN_PROGRESS";
-}
-function colorFromStatusResult(status) {
-  if (!status) {
-    return chalk4.reset;
+  async start() {
+    this.monitorId = uuid.v4();
+    await this.ioHost.notify(debug2(this.action, `Deploying ${this.stackName}`, "CDK_TOOLKIT_I5501", {
+      deployment: this.monitorId,
+      stack: this.stack,
+      stackName: this.stackName,
+      resourcesTotal: this.progressMonitor.total
+    }));
+    this.scheduleNextTick();
+    return this;
   }
-  if (status.indexOf("FAILED") !== -1) {
-    return chalk4.red;
+  async stop() {
+    const oldMonitorId = this.monitorId;
+    this.monitorId = void 0;
+    if (this.tickTimer) {
+      clearTimeout(this.tickTimer);
+    }
+    await this.finalPollToEnd(oldMonitorId);
+    await this.ioHost.notify(debug2(this.action, `Completed ${this.stackName}`, "CDK_TOOLKIT_I5503", {
+      deployment: oldMonitorId,
+      stack: this.stack,
+      stackName: this.stackName,
+      resourcesTotal: this.progressMonitor.total
+    }));
   }
-  if (status.indexOf("ROLLBACK") !== -1) {
-    return chalk4.yellow;
+  scheduleNextTick() {
+    if (!this.monitorId) {
+      return;
+    }
+    this.tickTimer = setTimeout(() => void this.tick(), this.pollingInterval);
   }
-  if (status.indexOf("COMPLETE") !== -1) {
-    return chalk4.green;
+  async tick() {
+    if (!this.monitorId) {
+      return;
+    }
+    try {
+      this.readPromise = this.readNewEvents(this.monitorId);
+      await this.readPromise;
+      this.readPromise = void 0;
+      if (!this.monitorId) {
+        return;
+      }
+    } catch (e) {
+      await this.ioHost.notify(error2(
+        this.action,
+        util6.format("Error occurred while monitoring stack: %s", e),
+        "CDK_TOOLKIT_E5500",
+        { error: e }
+      ));
+    }
+    this.scheduleNextTick();
   }
-  return chalk4.reset;
-}
-function colorFromStatusActivity(status) {
-  if (!status) {
-    return chalk4.reset;
+  findMetadataFor(logicalId) {
+    const metadata = this.stack.manifest?.metadata;
+    if (!logicalId || !metadata) {
+      return void 0;
+    }
+    for (const path12 of Object.keys(metadata)) {
+      const entry = metadata[path12].filter((e) => e.type === import_cloud_assembly_schema.ArtifactMetadataEntryType.LOGICAL_ID).find((e) => e.data === logicalId);
+      if (entry) {
+        return {
+          entry,
+          constructPath: this.simplifyConstructPath(path12)
+        };
+      }
+    }
+    return void 0;
   }
-  if (status.endsWith("_FAILED")) {
-    return chalk4.red;
+  /**
+   * Reads all new events from the stack history
+   *
+   * The events are returned in reverse chronological order; we continue to the next page if we
+   * see a next page and the last event in the page is new to us (and within the time window).
+   * haven't seen the final event
+   */
+  async readNewEvents(monitorId) {
+    const pollEvents = await this.poller.poll();
+    for (const resourceEvent of pollEvents) {
+      this.progressMonitor.process(resourceEvent.event);
+      const activity = {
+        deployment: monitorId,
+        event: resourceEvent.event,
+        metadata: this.findMetadataFor(resourceEvent.event.LogicalResourceId),
+        progress: this.progressMonitor.progress
+      };
+      this.checkForErrors(activity);
+      await this.ioHost.notify(info2(this.action, this.formatActivity(activity, true), "CDK_TOOLKIT_I5502", activity));
+    }
   }
-  if (status.startsWith("CREATE_") || status.startsWith("UPDATE_") || status.startsWith("IMPORT_")) {
-    return chalk4.green;
+  /**
+   * Perform a final poll to the end and flush out all events to the printer
+   *
+   * Finish any poll currently in progress, then do a final one until we've
+   * reached the last page.
+   */
+  async finalPollToEnd(monitorId) {
+    if (this.readPromise) {
+      await this.readPromise;
+    }
+    await this.readNewEvents(monitorId);
   }
-  if (status.indexOf("ROLLBACK_") !== -1) {
-    return chalk4.yellow;
+  /**
+   * Formats a stack activity into a basic string
+   */
+  formatActivity(activity, progress) {
+    const event = activity.event;
+    const metadata = activity.metadata;
+    const resourceName = metadata ? metadata.constructPath : event.LogicalResourceId || "";
+    const logicalId = resourceName !== event.LogicalResourceId ? `(${event.LogicalResourceId}) ` : "";
+    return util6.format(
+      "%s | %s%s | %s | %s | %s %s%s%s",
+      event.StackName,
+      progress !== false ? `${activity.progress.formatted} | ` : "",
+      new Date(event.Timestamp).toLocaleTimeString(),
+      event.ResourceStatus || "",
+      event.ResourceType,
+      resourceName,
+      logicalId,
+      event.ResourceStatusReason ? event.ResourceStatusReason : "",
+      metadata?.entry.trace ? `
+	${metadata.entry.trace.join("\n	\\_ ")}` : ""
+    );
   }
-  if (status.startsWith("DELETE_")) {
-    return chalk4.yellow;
+  checkForErrors(activity) {
+    if (stackEventHasErrorMessage(activity.event.ResourceStatus ?? "")) {
+      const isCancelled = (activity.event.ResourceStatusReason ?? "").indexOf("cancelled") > -1;
+      if (!isCancelled && activity.event.StackName !== activity.event.LogicalResourceId) {
+        this.errors.push(activity.event.ResourceStatusReason ?? "");
+      }
+    }
   }
-  return chalk4.reset;
-}
-function shorten(maxWidth, p) {
-  if (p.length <= maxWidth) {
-    return p;
+  simplifyConstructPath(path12) {
+    path12 = path12.replace(/\/Resource$/, "");
+    path12 = path12.replace(/^\//, "");
+    if (path12.startsWith(this.stackName + "/")) {
+      path12 = path12.slice(this.stackName.length + 1);
+    }
+    return path12;
   }
-  const half = Math.floor((maxWidth - 3) / 2);
-  return p.slice(0, half) + "..." + p.slice(-half);
-}
-var TIMESTAMP_WIDTH = 12;
-var STATUS_WIDTH = 20;
+};
 
 // ../../aws-cdk/lib/api/stack-events/stack-status.ts
 var import_client_cloudformation2 = require("@aws-sdk/client-cloudformation");
@@ -2900,47 +3176,8 @@ var path4 = __toESM(require("path"));
 var import_cx_api2 = require("@aws-cdk/cx-api");
 var import_client_s32 = require("@aws-sdk/client-s3");
 var import_middleware_endpoint2 = require("@smithy/middleware-endpoint");
-var chalk5 = __toESM(require("chalk"));
+var chalk6 = __toESM(require("chalk"));
 var fs6 = __toESM(require("fs-extra"));
-
-// ../../aws-cdk/lib/util/content-hash.ts
-var crypto = __toESM(require("crypto"));
-function contentHash(data) {
-  return crypto.createHash("sha256").update(data).digest("hex");
-}
-function contentHashAny(value) {
-  const ret = crypto.createHash("sha256");
-  recurse(value);
-  return ret.digest("hex");
-  function recurse(x) {
-    if (typeof x === "string") {
-      ret.update(x);
-      return;
-    }
-    if (Array.isArray(x)) {
-      ret.update("[");
-      for (const e of x) {
-        recurse(e);
-        ret.update("||");
-      }
-      ret.update("]");
-      return;
-    }
-    if (x && typeof x === "object") {
-      ret.update("{");
-      for (const key of Object.keys(x).sort()) {
-        ret.update(key);
-        ret.update(":");
-        recurse(x[key]);
-      }
-      ret.update("}");
-      return;
-    }
-    ret.update(`${x}${typeof x}`);
-  }
-}
-
-// ../../aws-cdk/lib/api/util/template-body-parameter.ts
 var LARGE_TEMPLATE_SIZE_KB = 50;
 async function makeBodyParameter(stack, resolvedEnvironment, assetManifest, resources, overrideTemplate) {
   if (stack.stackTemplateAssetObjectUrl && !overrideTemplate) {
@@ -2959,7 +3196,7 @@ async function makeBodyParameter(stack, resolvedEnvironment, assetManifest, reso
 Run the following command in order to setup an S3 bucket in this environment, and then re-deploy:
 
 `,
-      chalk5.blue(`	$ cdk bootstrap ${resolvedEnvironment.name}
+      chalk6.blue(`	$ cdk bootstrap ${resolvedEnvironment.name}
 `)
     );
     throw new ToolkitError('Template too large to deploy ("cdk bootstrap" is required)');
@@ -3185,13 +3422,13 @@ async function waitFor(valueProvider, timeout = 5e3) {
   }
 }
 async function waitForChangeSet(cfn, { ioHost, action }, stackName, changeSetName, { fetchAll }) {
-  await ioHost.notify(debug2(action, (0, import_util6.format)("Waiting for changeset %s on stack %s to finish creating...", changeSetName, stackName)));
+  await ioHost.notify(debug2(action, (0, import_util10.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_util6.format)("Changeset %s on stack %s is still creating", changeSetName, stackName)));
+      await ioHost.notify(debug2(action, (0, import_util10.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)) {
@@ -3276,19 +3513,19 @@ async function waitForStackDeploy(cfn, { ioHost, action }, stackName) {
   return stack;
 }
 async function stabilizeStack(cfn, { ioHost, action }, stackName) {
-  await ioHost.notify(debug2(action, (0, import_util6.format)("Waiting for stack %s to finish creating or updating...", stackName)));
+  await ioHost.notify(debug2(action, (0, import_util10.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_util6.format)("Stack %s does not exist", stackName)));
+      await ioHost.notify(debug2(action, (0, import_util10.format)("Stack %s does not exist", stackName)));
       return null;
     }
     const status = stack.stackStatus;
     if (status.isInProgress) {
-      await ioHost.notify(debug2(action, (0, import_util6.format)("Stack %s has an ongoing operation in progress and is not stable (%s)", stackName, status)));
+      await ioHost.notify(debug2(action, (0, import_util10.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_util6.format)("Stack %s is in REVIEW_IN_PROGRESS state. Considering this is a stable status (%s)", stackName, status)));
+      await ioHost.notify(debug2(action, (0, import_util10.format)("Stack %s is in REVIEW_IN_PROGRESS state. Considering this is a stable status (%s)", stackName, status)));
     }
     return stack;
   });
@@ -3380,7 +3617,7 @@ var ParameterValues = class {
 // ../../aws-cdk/lib/api/deployments/deployments.ts
 var import_crypto = require("crypto");
 var cdk_assets = __toESM(require("cdk-assets"));
-var chalk11 = __toESM(require("chalk"));
+var chalk12 = __toESM(require("chalk"));
 
 // ../../aws-cdk/lib/api/deployments/asset-publishing.ts
 var import_cx_api4 = require("@aws-cdk/cx-api");
@@ -3557,15 +3794,15 @@ async function getBootstrapStackInfo(sdk, stackName) {
 }
 
 // ../../aws-cdk/lib/api/deployments/deploy-stack.ts
-var import_util9 = require("util");
-var chalk8 = __toESM(require("chalk"));
-var uuid = __toESM(require("uuid"));
+var import_util13 = require("util");
+var chalk9 = __toESM(require("chalk"));
+var uuid2 = __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 chalk6 = __toESM(require("chalk"));
+var chalk7 = __toESM(require("chalk"));
 async function addMetadataAssetsToManifest({ ioHost, action }, stack, assetManifest, envResources, reuse) {
   reuse = reuse || [];
   const assets = stack.assets;
@@ -3574,7 +3811,7 @@ async function addMetadataAssetsToManifest({ ioHost, action }, stack, assetManif
   }
   const toolkitInfo = await envResources.lookupToolkit();
   if (!toolkitInfo.found) {
-    throw new ToolkitError(`This stack uses assets, so the toolkit stack must be deployed to the environment (Run "${chalk6.blue("cdk bootstrap " + stack.environment.name)}")`);
+    throw new ToolkitError(`This stack uses assets, so the toolkit stack must be deployed to the environment (Run "${chalk7.blue("cdk bootstrap " + stack.environment.name)}")`);
   }
   const params = {};
   for (const asset of assets) {
@@ -3655,9 +3892,9 @@ async function prepareDockerImageAsset(asset, assetManifest, envResources) {
 }
 
 // ../../aws-cdk/lib/api/deployments/hotswap-deployments.ts
-var import_util8 = require("util");
+var import_util12 = require("util");
 var cfn_diff = __toESM(require("@aws-cdk/cloudformation-diff"));
-var chalk7 = __toESM(require("chalk"));
+var chalk8 = __toESM(require("chalk"));
 
 // ../../aws-cdk/lib/api/deployments/nested-stack-helpers.ts
 var path6 = __toESM(require("path"));
@@ -4572,77 +4809,6 @@ async function prepareTaskDefinitionChange(evaluateCfnTemplate, logicalId, chang
 
 // ../../aws-cdk/lib/api/hotswap/lambda-functions.ts
 var import_stream = require("stream");
-
-// ../../aws-cdk/lib/util/archive.ts
-var glob = __toESM(require("glob"));
-var archiver = require("archiver");
-
-// ../../aws-cdk/lib/util/arrays.ts
-function flatMap(xs, fn) {
-  return flatten(xs.map(fn));
-}
-function flatten(xs) {
-  return Array.prototype.concat.apply([], xs);
-}
-
-// ../../aws-cdk/lib/util/cloudformation.ts
-function validateSnsTopicArn(arn) {
-  return /^arn:aws:sns:[a-z0-9\-]+:[0-9]+:[a-z0-9\-\_]+$/i.test(arn);
-}
-
-// ../../aws-cdk/lib/util/parallel.ts
-async function parallelPromises(n, promises) {
-  const ret = new Array();
-  let count = 0;
-  let error3;
-  const queue = [...promises];
-  return new Promise((ok, ko) => {
-    tick();
-    function tick() {
-      if (count === 0 && error3) {
-        ko(error3);
-        return;
-      }
-      if (count === 0 && queue.length === 0) {
-        ok(ret);
-        return;
-      }
-      while (count < n && queue.length > 0 && !error3) {
-        const next = queue.shift();
-        if (next !== void 0) {
-          start(next);
-        }
-      }
-    }
-    function start(fn) {
-      count += 1;
-      fn().then((result) => {
-        ret.push(result);
-      }).catch((e) => {
-        error3 = e;
-      }).finally(() => {
-        count -= 1;
-        tick();
-      });
-    }
-  });
-}
-
-// ../../aws-cdk/lib/util/string-manipulation.ts
-function formatTime(num) {
-  return roundPercentage(millisecondsToSeconds(num));
-}
-function roundPercentage(num) {
-  return Math.round(100 * num) / 100;
-}
-function millisecondsToSeconds(num) {
-  return num / 1e3;
-}
-
-// ../../aws-cdk/lib/util/version-range.ts
-var semver = __toESM(require("semver"));
-
-// ../../aws-cdk/lib/api/hotswap/lambda-functions.ts
 var archiver2 = require("archiver");
 async function isHotswappableLambdaFunctionChange(logicalId, change, evaluateCfnTemplate) {
   if (change.newValue.Type === "AWS::Lambda::Version") {
@@ -5263,7 +5429,7 @@ async function applyHotswappableChange(sdk, { ioHost, action }, hotswapOperation
   const customUserAgent = `cdk-hotswap/success-${hotswapOperation.service}`;
   sdk.appendCustomUserAgent(customUserAgent);
   for (const name of hotswapOperation.resourceNames) {
-    await ioHost.notify(info2(action, (0, import_util8.format)(`   ${ICON} %s`, chalk7.bold(name))));
+    await ioHost.notify(info2(action, (0, import_util12.format)(`   ${ICON} %s`, chalk8.bold(name))));
   }
   try {
     await hotswapOperation.apply(sdk);
@@ -5277,7 +5443,7 @@ async function applyHotswappableChange(sdk, { ioHost, action }, hotswapOperation
     throw e;
   }
   for (const name of hotswapOperation.resourceNames) {
-    await ioHost.notify(info2(action, (0, import_util8.format)(`${ICON} %s %s`, chalk7.bold(name), chalk7.green("hotswapped!"))));
+    await ioHost.notify(info2(action, (0, import_util12.format)(`${ICON} %s %s`, chalk8.bold(name), chalk8.green("hotswapped!"))));
   }
   sdk.removeCustomUserAgent(customUserAgent);
 }
@@ -5305,25 +5471,25 @@ async function logNonHotswappableChanges({ ioHost, action }, nonHotswappableChan
   }
   const messages = [""];
   if (hotswapMode === "hotswap-only" /* HOTSWAP_ONLY */) {
-    messages.push((0, import_util8.format)("%s %s", chalk7.red("\u26A0\uFE0F"), chalk7.red("The following non-hotswappable changes were found. To reconcile these using CloudFormation, specify --hotswap-fallback")));
+    messages.push((0, import_util12.format)("%s %s", chalk8.red("\u26A0\uFE0F"), chalk8.red("The following non-hotswappable changes were found. To reconcile these using CloudFormation, specify --hotswap-fallback")));
   } else {
-    messages.push((0, import_util8.format)("%s %s", chalk7.red("\u26A0\uFE0F"), chalk7.red("The following non-hotswappable changes were found:")));
+    messages.push((0, import_util12.format)("%s %s", chalk8.red("\u26A0\uFE0F"), chalk8.red("The following non-hotswappable changes were found:")));
   }
   for (const change of nonHotswappableChanges) {
     if (change.rejectedChanges.length > 0) {
-      messages.push((0, import_util8.format)(
+      messages.push((0, import_util12.format)(
         "    logicalID: %s, type: %s, rejected changes: %s, reason: %s",
-        chalk7.bold(change.logicalId),
-        chalk7.bold(change.resourceType),
-        chalk7.bold(change.rejectedChanges),
-        chalk7.red(change.reason)
+        chalk8.bold(change.logicalId),
+        chalk8.bold(change.resourceType),
+        chalk8.bold(change.rejectedChanges),
+        chalk8.red(change.reason)
       ));
     } else {
-      messages.push((0, import_util8.format)(
+      messages.push((0, import_util12.format)(
         "    logicalID: %s, type: %s, reason: %s",
-        chalk7.bold(change.logicalId),
-        chalk7.bold(change.resourceType),
-        chalk7.red(change.reason)
+        chalk8.bold(change.logicalId),
+        chalk8.bold(change.resourceType),
+        chalk8.red(change.reason)
       ));
     }
   }
@@ -5371,11 +5537,11 @@ async function deployStack(options, { ioHost, action }) {
     if (hotswapMode !== "full-deployment" /* FULL_DEPLOYMENT */) {
       await ioHost.notify(info2(
         action,
-        (0, import_util9.format)(
+        (0, import_util13.format)(
           `
  ${ICON} %s
 `,
-          chalk8.bold("hotswap deployment skipped - no changes were detected (use --force to override)")
+          chalk9.bold("hotswap deployment skipped - no changes were detected (use --force to override)")
         )
       ));
     }
@@ -5419,7 +5585,7 @@ async function deployStack(options, { ioHost, action }) {
       if (hotswapDeploymentResult) {
         return hotswapDeploymentResult;
       }
-      await ioHost.notify(info2(action, (0, import_util9.format)(
+      await ioHost.notify(info2(action, (0, import_util13.format)(
         "Could not perform a hotswap deployment, as the stack %s contains non-Asset changes",
         stackArtifact.displayName
       )));
@@ -5427,7 +5593,7 @@ async function deployStack(options, { ioHost, action }) {
       if (!(e instanceof CfnEvaluationException)) {
         throw e;
       }
-      await ioHost.notify(info2(action, (0, import_util9.format)(
+      await ioHost.notify(info2(action, (0, import_util13.format)(
         "Could not perform a hotswap deployment, because the CloudFormation template could not be resolved: %s",
         formatErrorMessage(e)
       )));
@@ -5468,7 +5634,7 @@ var FullCloudFormationDeployment = class {
     this.stackName = options.deployName ?? stackArtifact.stackName;
     this.update = cloudFormationStack.exists && cloudFormationStack.stackStatus.name !== "REVIEW_IN_PROGRESS";
     this.verb = this.update ? "update" : "create";
-    this.uuid = uuid.v4();
+    this.uuid = uuid2.v4();
   }
   async performDeployment() {
     const deploymentMethod = this.options.deploymentMethod ?? {
@@ -5491,9 +5657,9 @@ var FullCloudFormationDeployment = class {
     const changeSetDescription = await this.createChangeSet(changeSetName, execute, importExistingResources);
     await this.updateTerminationProtection();
     if (changeSetHasNoChanges(changeSetDescription)) {
-      debug2(this.action, (0, import_util9.format)("No changes are to be performed on %s.", this.stackName));
+      await this.ioHost.notify(debug2(this.action, (0, import_util13.format)("No changes are to be performed on %s.", this.stackName)));
       if (execute) {
-        debug2(this.action, (0, import_util9.format)("Deleting empty change set %s", changeSetDescription.ChangeSetId));
+        await this.ioHost.notify(debug2(this.action, (0, import_util13.format)("Deleting empty change set %s", changeSetDescription.ChangeSetId)));
         await this.cfn.deleteChangeSet({
           StackName: this.stackName,
           ChangeSetName: changeSetName
@@ -5519,10 +5685,10 @@ var FullCloudFormationDeployment = class {
       };
     }
     if (!execute) {
-      info2(this.action, (0, import_util9.format)(
+      await this.ioHost.notify(info2(this.action, (0, import_util13.format)(
         "Changeset %s created and waiting in review for manual execution (--no-execute)",
         changeSetDescription.ChangeSetId
-      ));
+      )));
       return {
         type: "did-deploy-stack",
         noOp: false,
@@ -5547,7 +5713,7 @@ 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_util9.format)("%s: creating CloudFormation changeset...", chalk8.bold(this.stackName))));
+    await this.ioHost.notify(info2(this.action, (0, import_util13.format)("%s: creating CloudFormation changeset...", chalk9.bold(this.stackName))));
     const changeSet = await this.cfn.createChangeSet({
       StackName: this.stackName,
       ChangeSetName: changeSetName,
@@ -5558,13 +5724,13 @@ var FullCloudFormationDeployment = class {
       ImportExistingResources: importExistingResources,
       ...this.commonPrepareOptions()
     });
-    await this.ioHost.notify(debug2(this.action, (0, import_util9.format)("Initiated creation of changeset: %s; waiting for it to finish creating...", changeSet.Id)));
+    await this.ioHost.notify(debug2(this.action, (0, import_util13.format)("Initiated creation of changeset: %s; waiting for it to finish creating...", changeSet.Id)));
     return waitForChangeSet(this.cfn, { ioHost: this.ioHost, action: this.action }, this.stackName, changeSetName, {
       fetchAll: willExecute
     });
   }
   async executeChangeSet(changeSet) {
-    await this.ioHost.notify(debug2(this.action, (0, import_util9.format)("Initiating execution of changeset %s on stack %s", changeSet.ChangeSetId, this.stackName)));
+    await this.ioHost.notify(debug2(this.action, (0, import_util13.format)("Initiating execution of changeset %s on stack %s", changeSet.ChangeSetId, this.stackName)));
     await this.cfn.executeChangeSet({
       StackName: this.stackName,
       ChangeSetName: changeSet.ChangeSetName,
@@ -5573,7 +5739,7 @@ var FullCloudFormationDeployment = class {
     });
     await this.ioHost.notify(debug2(
       this.action,
-      (0, import_util9.format)(
+      (0, import_util13.format)(
         "Execution of changeset %s on stack %s has started; waiting for the update to complete...",
         changeSet.ChangeSetId,
         this.stackName
@@ -5596,7 +5762,7 @@ var FullCloudFormationDeployment = class {
     if (!!this.cloudFormationStack.terminationProtection !== terminationProtection) {
       await this.ioHost.notify(debug2(
         this.action,
-        (0, import_util9.format)(
+        (0, import_util13.format)(
           "Updating termination protection from %s to %s for stack %s",
           this.cloudFormationStack.terminationProtection,
           terminationProtection,
@@ -5607,11 +5773,11 @@ var FullCloudFormationDeployment = class {
         StackName: this.stackName,
         EnableTerminationProtection: terminationProtection
       });
-      await this.ioHost.notify(debug2(this.action, (0, import_util9.format)("Termination protection updated to %s for stack %s", terminationProtection, this.stackName)));
+      await this.ioHost.notify(debug2(this.action, (0, import_util13.format)("Termination protection updated to %s for stack %s", terminationProtection, this.stackName)));
     }
   }
   async directDeployment() {
-    await this.ioHost.notify(info2(this.action, (0, import_util9.format)("%s: %s stack...", chalk8.bold(this.stackName), this.update ? "updating" : "creating")));
+    await this.ioHost.notify(info2(this.action, (0, import_util13.format)("%s: %s stack...", chalk9.bold(this.stackName), this.update ? "updating" : "creating")));
     const startTime = /* @__PURE__ */ new Date();
     if (this.update) {
       await this.updateTerminationProtection();
@@ -5624,7 +5790,7 @@ var FullCloudFormationDeployment = class {
         });
       } catch (err) {
         if (err.message === "No updates are to be performed.") {
-          await this.ioHost.notify(debug2(this.action, (0, import_util9.format)("No updates are to be performed for stack %s", this.stackName)));
+          await this.ioHost.notify(debug2(this.action, (0, import_util13.format)("No updates are to be performed for stack %s", this.stackName)));
           return {
             type: "did-deploy-stack",
             noOp: true,
@@ -5648,12 +5814,16 @@ var FullCloudFormationDeployment = class {
     }
   }
   async monitorDeployment(startTime, expectedChanges) {
-    const monitor = this.options.quiet ? void 0 : StackActivityMonitor.withDefaultPrinter(this.cfn, this.stackName, this.stackArtifact, {
+    const monitor = new StackActivityMonitor({
+      cfn: this.cfn,
+      stack: this.stackArtifact,
+      stackName: this.stackName,
       resourcesTotal: expectedChanges,
-      progress: this.options.progress,
-      changeSetCreationTime: startTime,
-      ci: this.options.ci
-    }).start();
+      ioHost: this.ioHost,
+      action: this.action,
+      changeSetCreationTime: startTime
+    });
+    await monitor.start();
     let finalState = this.cloudFormationStack;
     try {
       const successStack = await waitForStackDeploy(this.cfn, { ioHost: this.ioHost, action: this.action }, this.stackName);
@@ -5662,11 +5832,11 @@ var FullCloudFormationDeployment = class {
       }
       finalState = successStack;
     } catch (e) {
-      throw new ToolkitError(suffixWithErrors(formatErrorMessage(e), monitor?.errors));
+      throw new ToolkitError(suffixWithErrors(formatErrorMessage(e), monitor.errors));
     } finally {
-      await monitor?.stop();
+      await monitor.stop();
     }
-    debug2(this.action, (0, import_util9.format)("Stack %s has completed updating", this.stackName));
+    debug2(this.action, (0, import_util13.format)("Stack %s has completed updating", this.stackName));
     return {
       type: "did-deploy-stack",
       noOp: false,
@@ -5709,9 +5879,14 @@ async function destroyStack(options, { ioHost, action }) {
   if (!currentStack.exists) {
     return;
   }
-  const monitor = options.quiet ? void 0 : StackActivityMonitor.withDefaultPrinter(cfn, deployName, options.stack, {
-    ci: options.ci
-  }).start();
+  const monitor = new StackActivityMonitor({
+    cfn,
+    stack: options.stack,
+    stackName: deployName,
+    ioHost,
+    action
+  });
+  await monitor.start();
   try {
     await cfn.deleteStack({ StackName: deployName, RoleARN: options.roleArn });
     const destroyedStack = await waitForStackDelete(cfn, { ioHost, action }, deployName);
@@ -5719,7 +5894,7 @@ async function destroyStack(options, { ioHost, action }) {
       throw new ToolkitError(`Failed to destroy ${deployName}: ${destroyedStack.stackStatus}`);
     }
   } catch (e) {
-    throw new ToolkitError(suffixWithErrors(formatErrorMessage(e), monitor?.errors));
+    throw new ToolkitError(suffixWithErrors(formatErrorMessage(e), monitor.errors));
   } finally {
     if (monitor) {
       await monitor.stop();
@@ -5804,7 +5979,7 @@ var semver4 = __toESM(require("semver"));
 
 // ../../aws-cdk/lib/cli/version.ts
 var path7 = __toESM(require("path"));
-var chalk9 = __toESM(require("chalk"));
+var chalk10 = __toESM(require("chalk"));
 var fs8 = __toESM(require("fs-extra"));
 var semver3 = __toESM(require("semver"));
 
@@ -5813,9 +5988,9 @@ var stripAnsi = require("strip-ansi");
 
 // ../../aws-cdk/lib/cli/util/npm.ts
 var import_child_process = require("child_process");
-var import_util10 = require("util");
+var import_util14 = require("util");
 var semver2 = __toESM(require("semver"));
-var exec = (0, import_util10.promisify)(import_child_process.exec);
+var exec = (0, import_util14.promisify)(import_child_process.exec);
 
 // ../../aws-cdk/lib/cli/version.ts
 var ONE_DAY_IN_SECONDS = 1 * 24 * 60 * 60;
@@ -5901,7 +6076,7 @@ var NoticesFilter = class _NoticesFilter {
     return data.flatMap((notice) => {
       const ors = this.resolveAliases(normalizeComponents(notice.components));
       for (const ands of ors) {
-        const matched = ands.map((affected) => actualComponents.filter((actual) => _NoticesFilter.componentNameMatches(affected, actual) && semver4.satisfies(actual.version, affected.version)));
+        const matched = ands.map((affected) => actualComponents.filter((actual) => _NoticesFilter.componentNameMatches(affected, actual) && semver4.satisfies(actual.version, affected.version, { includePrerelease: true })));
         if (matched.every((xs) => xs.length > 0)) {
           const ret = new FilteredNotice(notice);
           _NoticesFilter.addDynamicValues(matched.flatMap((x) => x), ret);
@@ -6225,8 +6400,8 @@ var CachedDataSource = class {
 };
 
 // ../../aws-cdk/lib/api/toolkit-info.ts
-var import_util11 = require("util");
-var chalk10 = __toESM(require("chalk"));
+var import_util15 = require("util");
+var chalk11 = __toESM(require("chalk"));
 
 // ../../aws-cdk/lib/api/bootstrap/bootstrap-props.ts
 var BUCKET_NAME_OUTPUT = "BucketName";
@@ -6250,11 +6425,11 @@ var ToolkitInfo = class _ToolkitInfo {
       if (!stack) {
         await ioHost.notify(debug2(
           action,
-          (0, import_util11.format)(
+          (0, import_util15.format)(
             "The environment %s doesn't have the CDK toolkit stack (%s) installed. Use %s to setup your environment for use with the toolkit.",
             environment.name,
             stackName,
-            chalk10.blue(`cdk bootstrap "${environment.name}"`)
+            chalk11.blue(`cdk bootstrap "${environment.name}"`)
           )
         ));
         return _ToolkitInfo.bootstrapStackNotFoundInfo(stackName);
@@ -6262,11 +6437,11 @@ var ToolkitInfo = class _ToolkitInfo {
       if (stack.stackStatus.isCreationFailure) {
         await ioHost.notify(debug2(
           action,
-          (0, import_util11.format)(
+          (0, import_util15.format)(
             "The environment %s has a CDK toolkit stack (%s) that failed to create. Use %s to try provisioning it again.",
             environment.name,
             stackName,
-            chalk10.blue(`cdk bootstrap "${environment.name}"`)
+            chalk11.blue(`cdk bootstrap "${environment.name}"`)
           )
         ));
         return _ToolkitInfo.bootstrapStackNotFoundInfo(stackName);
@@ -6800,7 +6975,6 @@ var Deployments = class {
       resolvedEnvironment: env.resolvedEnvironment,
       deployName: options.deployName,
       notificationArns: options.notificationArns,
-      quiet: options.quiet,
       sdk: env.sdk,
       sdkProvider: this.deployStackSdkProvider,
       roleArn: executionRoleArn,
@@ -6811,8 +6985,6 @@ var Deployments = class {
       force: options.force,
       parameters: options.parameters,
       usePreviousParameters: options.usePreviousParameters,
-      progress: options.progress,
-      ci: options.ci,
       rollback: options.rollback,
       hotswap: options.hotswap,
       hotswapPropertyOverrides: options.hotswapPropertyOverrides,
@@ -6883,9 +7055,14 @@ var Deployments = class {
         default:
           throw new ToolkitError(`Unexpected rollback choice: ${cloudFormationStack.stackStatus.rollbackChoice}`);
       }
-      const monitor = options.quiet ? void 0 : StackActivityMonitor.withDefaultPrinter(cfn, deployName, options.stack, {
-        ci: options.ci
-      }).start();
+      const monitor = new StackActivityMonitor({
+        cfn,
+        stack: options.stack,
+        stackName: deployName,
+        ioHost: this.ioHost,
+        action: this.action
+      });
+      await monitor.start();
       let stackErrorMessage = void 0;
       let finalStackState = cloudFormationStack;
       try {
@@ -6894,14 +7071,14 @@ var Deployments = class {
           throw new ToolkitError("Stack deploy failed (the stack disappeared while we were rolling it back)");
         }
         finalStackState = successStack;
-        const errors = monitor?.errors?.join(", ");
+        const errors = monitor.errors.join(", ");
         if (errors) {
           stackErrorMessage = errors;
         }
       } catch (e) {
-        stackErrorMessage = suffixWithErrors2(formatErrorMessage(e), monitor?.errors);
+        stackErrorMessage = suffixWithErrors2(formatErrorMessage(e), monitor.errors);
       } finally {
-        await monitor?.stop();
+        await monitor.stop();
       }
       if (finalStackState.stackStatus.isRollbackSuccess || !stackErrorMessage) {
         return { success: true };
@@ -7010,7 +7187,7 @@ var Deployments = class {
     if (existing) {
       return existing;
     }
-    const prefix = stackName ? `${chalk11.bold(stackName)}: ` : "";
+    const prefix = stackName ? `${chalk12.bold(stackName)}: ` : "";
     const publisher = new cdk_assets.AssetPublishing(assetManifest, {
       // The AssetPublishing class takes care of role assuming etc, so it's okay to
       // give it a direct `SdkProvider`.
@@ -7047,9 +7224,9 @@ function tagsForStack(stack) {
 }
 
 // ../../aws-cdk/lib/api/resource-import/importer.ts
-var import_util12 = require("util");
+var import_util16 = require("util");
 var cfnDiff = __toESM(require("@aws-cdk/cloudformation-diff"));
-var chalk12 = __toESM(require("chalk"));
+var chalk13 = __toESM(require("chalk"));
 var fs11 = __toESM(require("fs-extra"));
 var promptly3 = __toESM(require("promptly"));
 var ResourceImporter = class {
@@ -7085,12 +7262,12 @@ 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_util12.format)("%s: importing using %s", chalk12.blue(descr), chalk12.blue(fmtdict(idProps)))));
+        await this.ioHost.notify(info2(this.action, (0, import_util16.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_util12.format)("%s: skipping", chalk12.blue(descr))));
+        await this.ioHost.notify(info2(this.action, (0, import_util16.format)("%s: skipping", chalk13.blue(descr))));
       }
     }
     const unknown = Object.keys(contents);
@@ -7134,9 +7311,9 @@ var ResourceImporter = class {
       });
       assertIsSuccessfulDeployStackResult(result);
       const message = result.noOp ? " \u2705  %s (no changes)" : " \u2705  %s";
-      await this.ioHost.notify(info2(this.action, "\n" + chalk12.green((0, import_util12.format)(message, this.stack.displayName))));
+      await this.ioHost.notify(info2(this.action, "\n" + chalk13.green((0, import_util16.format)(message, this.stack.displayName))));
     } catch (e) {
-      await this.ioHost.notify(error2(this.action, (0, import_util12.format)("\n \u274C  %s failed: %s", chalk12.bold(this.stack.displayName), e), "CDK_TOOLKIT_E3900"));
+      await this.ioHost.notify(error2(this.action, (0, import_util16.format)("\n \u274C  %s failed: %s", chalk13.bold(this.stack.displayName), e), "CDK_TOOLKIT_E3900"));
       throw e;
     }
   }
@@ -7238,21 +7415,21 @@ var ResourceImporter = class {
       const candidateProps = Object.fromEntries(satisfiedPropSet.map((p) => [p, resourceProps[p]]));
       const displayCandidateProps = fmtdict(candidateProps);
       if (await promptly3.confirm(
-        `${chalk12.blue(resourceName)} (${resourceType}): import with ${chalk12.yellow(displayCandidateProps)} (yes/no) [default: yes]? `,
+        `${chalk13.blue(resourceName)} (${resourceType}): import with ${chalk13.yellow(displayCandidateProps)} (yes/no) [default: yes]? `,
         { default: "yes" }
       )) {
         return candidateProps;
       }
     }
     if (satisfiedPropSets.length > 0) {
-      await this.ioHost.notify(info2(this.action, chalk12.grey(`Skipping import of ${resourceName}`)));
+      await this.ioHost.notify(info2(this.action, chalk13.grey(`Skipping import of ${resourceName}`)));
       return void 0;
     }
-    const prefix = `${chalk12.blue(resourceName)} (${resourceType})`;
+    const prefix = `${chalk13.blue(resourceName)} (${resourceType})`;
     let preamble;
     let promptPattern;
     if (idPropSets.length > 1) {
-      preamble = `${prefix}: enter one of ${idPropSets.map((x) => chalk12.blue(x.join("+"))).join(", ")} to import (all empty to skip)`;
+      preamble = `${prefix}: enter one of ${idPropSets.map((x) => chalk13.blue(x.join("+"))).join(", ")} to import (all empty to skip)`;
       promptPattern = `${prefix}: enter %`;
     } else {
       promptPattern = `${prefix}: enter %`;
@@ -7265,7 +7442,7 @@ var ResourceImporter = class {
       for (const idProp of idProps) {
         const defaultValue = resourceProps[idProp] ?? "";
         const prompt4 = [
-          promptPattern.replace(/%/g, chalk12.blue(idProp)),
+          promptPattern.replace(/%/g, chalk13.blue(idProp)),
           defaultValue ? `[${defaultValue}]` : "(empty to skip)"
         ].join(" ") + ":";
         const response = await promptly3.prompt(
@@ -7282,7 +7459,7 @@ var ResourceImporter = class {
         return input;
       }
     }
-    await this.ioHost.notify(info2(this.action, chalk12.grey(`Skipping import of ${resourceName}`)));
+    await this.ioHost.notify(info2(this.action, chalk13.grey(`Skipping import of ${resourceName}`)));
     return void 0;
   }
   /**
@@ -7332,7 +7509,7 @@ function addDefaultDeletionPolicy(resource) {
 }
 
 // ../../aws-cdk/lib/api/resource-import/migrator.ts
-var chalk13 = __toESM(require("chalk"));
+var chalk14 = __toESM(require("chalk"));
 var fs12 = __toESM(require("fs-extra"));
 var ResourceMigrator = class {
   constructor(props) {
@@ -7355,11 +7532,11 @@ var ResourceMigrator = class {
     });
     const resourcesToImport = await this.tryGetResources(await migrateDeployment.resolveEnvironment());
     if (resourcesToImport) {
-      await this.ioHost.notify(info2(this.action, `${chalk13.bold(stack.displayName)}: creating stack for resource migration...`));
-      await this.ioHost.notify(info2(this.action, `${chalk13.bold(stack.displayName)}: importing resources into stack...`));
+      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.performResourceMigration(migrateDeployment, resourcesToImport, options);
       fs12.rmSync("migrate.json");
-      await this.ioHost.notify(info2(this.action, `${chalk13.bold(stack.displayName)}: applying CDKMetadata and Outputs to stack (if applicable)...`));
+      await this.ioHost.notify(info2(this.action, `${chalk14.bold(stack.displayName)}: applying CDKMetadata and Outputs to stack (if applicable)...`));
     }
   }
   /**
@@ -7372,7 +7549,6 @@ var ResourceMigrator = class {
       roleArn: options.roleArn,
       deploymentMethod: options.deploymentMethod,
       usePreviousParameters: true,
-      progress: options.progress,
       rollback: options.rollback
     });
     elapsedDeployTime = (/* @__PURE__ */ new Date()).getTime() - startDeployTime;
@@ -7398,8 +7574,8 @@ var ResourceMigrator = class {
 };
 
 // ../../aws-cdk/lib/api/logs/logs-monitor.ts
-var util4 = __toESM(require("util"));
-var chalk14 = __toESM(require("chalk"));
+var util7 = __toESM(require("util"));
+var chalk15 = __toESM(require("chalk"));
 var SLEEP = 2e3;
 var CloudWatchLogEventMonitor = class {
   constructor(startTime) {
@@ -7490,10 +7666,10 @@ var CloudWatchLogEventMonitor = class {
    */
   print(event) {
     info(
-      util4.format(
+      util7.format(
         "[%s] %s %s",
-        chalk14.blue(event.logGroupName),
-        chalk14.yellow(event.timestamp.toLocaleTimeString()),
+        chalk15.blue(event.logGroupName),
+        chalk15.yellow(event.timestamp.toLocaleTimeString()),
         event.message.trim()
       )
     );
@@ -8086,8 +8262,8 @@ var WorkGraphBuilder = class _WorkGraphBuilder {
 };
 function stacksFromAssets(artifacts) {
   const ret = /* @__PURE__ */ new Map();
-  for (const stack of artifacts.filter(cxapi3.CloudFormationStackArtifact.isCloudFormationStackArtifact)) {
-    const assetArtifacts = stack.dependencies.filter(cxapi3.AssetManifestArtifact.isAssetManifestArtifact);
+  for (const stack of artifacts.filter((x) => cxapi3.CloudFormationStackArtifact.isCloudFormationStackArtifact(x))) {
+    const assetArtifacts = stack.dependencies.filter((x) => cxapi3.AssetManifestArtifact.isAssetManifestArtifact(x));
     for (const art of assetArtifacts) {
       ret.set(art, stack);
     }
@@ -8095,7 +8271,7 @@ function stacksFromAssets(artifacts) {
   return ret;
 }
 function onlyStacks(artifacts) {
-  return artifacts.filter(cxapi3.CloudFormationStackArtifact.isCloudFormationStackArtifact);
+  return artifacts.filter((x) => cxapi3.CloudFormationStackArtifact.isCloudFormationStackArtifact(x));
 }
 
 // ../../aws-cdk/lib/context-providers/index.ts
@@ -8279,7 +8455,7 @@ var CcApiContextProviderPlugin = class {
         }
       });
     } catch (err) {
-      throw new ContextProviderError(`Could not get resources ${propertyMatch}. Error: ${err}`);
+      throw new ContextProviderError(`Could not get resources ${JSON.stringify(propertyMatch)}. Error: ${err}`);
     }
     return resultObjs;
   }
@@ -9158,7 +9334,7 @@ function processExists(pid) {
 
 // ../../aws-cdk/lib/api/cxapp/cloud-assembly.ts
 var import_cx_api8 = require("@aws-cdk/cx-api");
-var chalk15 = __toESM(require("chalk"));
+var chalk16 = __toESM(require("chalk"));
 var import_minimatch = require("minimatch");
 var semver5 = __toESM(require("semver"));
 var ExtendedStackSelection = /* @__PURE__ */ ((ExtendedStackSelection2) => {
@@ -9363,7 +9539,7 @@ function includeDownstreamStacks(selectedStacks, allStacks) {
     }
   } while (madeProgress);
   if (added.length > 0) {
-    info("Including depending stacks: %s", chalk15.bold(added.join(", ")));
+    info("Including depending stacks: %s", chalk16.bold(added.join(", ")));
   }
 }
 function includeUpstreamStacks(selectedStacks, allStacks) {
@@ -9382,7 +9558,7 @@ function includeUpstreamStacks(selectedStacks, allStacks) {
     }
   }
   if (added.length > 0) {
-    info("Including dependency stacks: %s", chalk15.bold(added.join(", ")));
+    info("Including dependency stacks: %s", chalk16.bold(added.join(", ")));
   }
 }
 function sanitizePatterns(patterns) {
@@ -9487,7 +9663,6 @@ function spaceAvailableForContext(env, limit) {
   ResourceMigrator,
   SdkProvider,
   Settings,
-  StackActivityProgress,
   StackCollection,
   WorkGraphBuilder,
   contextproviders,