@aws-cdk/toolkit-lib 0.1.2 → 0.1.4

package/lib/api/aws-cdk.js

@@ -38,6 +38,7 @@ var __decorateClass = (decorators, target, key, kind) => {
 // lib/api/aws-cdk.ts
 var aws_cdk_exports = {};
 __export(aws_cdk_exports, {
+  Bootstrapper: () => Bootstrapper,
   CliIoHost: () => CliIoHost,
   CloudAssembly: () => CloudAssembly2,
   CloudWatchLogEventMonitor: () => CloudWatchLogEventMonitor,
@@ -53,26 +54,19 @@ __export(aws_cdk_exports, {
   ResourceMigrator: () => ResourceMigrator,
   SdkProvider: () => SdkProvider,
   Settings: () => Settings,
-  StackActivityProgress: () => StackActivityProgress,
   StackCollection: () => StackCollection,
   WorkGraphBuilder: () => WorkGraphBuilder,
   contextproviders: () => context_providers_exports,
   findCloudWatchLogGroups: () => findCloudWatchLogGroups,
-  formatErrorMessage: () => formatErrorMessage,
   formatSdkLoggerContent: () => formatSdkLoggerContent,
-  formatTime: () => formatTime,
   guessExecutable: () => guessExecutable,
   loadTree: () => loadTree,
-  obscureTemplate: () => obscureTemplate,
   prepareContext: () => prepareContext,
   prepareDefaultEnvironment: () => prepareDefaultEnvironment,
   sanitizePatterns: () => sanitizePatterns,
-  serializeStructure: () => serializeStructure,
   some: () => some,
   spaceAvailableForContext: () => spaceAvailableForContext,
-  splitBySize: () => splitBySize,
   tagsForStack: () => tagsForStack,
-  validateSnsTopicArn: () => validateSnsTopicArn,
   versionNumber: () => versionNumber
 });
 module.exports = __toCommonJS(aws_cdk_exports);
@@ -102,18 +96,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 +137,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,183 +171,1004 @@ 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();
-  }
-  /**
-   * 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;
-    }
-  }
-  /**
-   * 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;
+// ../tmp-toolkit-helpers/src/util/archive.ts
+var glob = __toESM(require("glob"));
+
+// ../tmp-toolkit-helpers/src/util/format-error.ts
+function formatErrorMessage(error3) {
+  if (error3 && Array.isArray(error3.errors)) {
+    const innerMessages = error3.errors.map((innerError) => innerError?.message || innerError?.toString()).join("\n");
+    return `AggregateError: ${innerMessages}`;
   }
-  /**
-   * 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 error3?.message || error3?.toString() || "Unknown error";
+}
+
+// ../tmp-toolkit-helpers/src/util/archive.ts
+var archiver = require("archiver");
+
+// ../tmp-toolkit-helpers/src/util/arrays.ts
+function flatMap(xs, fn) {
+  return flatten(xs.map(fn));
+}
+function flatten(xs) {
+  return Array.prototype.concat.apply([], xs);
+}
+
+// ../tmp-toolkit-helpers/src/util/bytes.ts
+function formatBytes(bytes, decimals = 2) {
+  decimals = decimals < 0 ? 0 : decimals;
+  if (bytes === 0) {
+    return "0 Bytes";
   }
-  /**
-   * 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);
-      }
+  const k = 1024;
+  const sizes = ["Bytes", "KiB", "MiB", "GiB", "TiB", "PiB", "EiB", "ZiB", "YiB"];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  return `${parseFloat((bytes / Math.pow(k, i)).toFixed(decimals))} ${sizes[i]}`;
+}
+
+// ../tmp-toolkit-helpers/src/util/cloudformation.ts
+function stackEventHasErrorMessage(status) {
+  return status.endsWith("_FAILED") || status === "ROLLBACK_IN_PROGRESS" || status === "UPDATE_ROLLBACK_IN_PROGRESS";
+}
+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;
     }
   }
-  /**
-   * Notifies the host of a message.
-   * The caller waits until the notification completes.
-   */
-  async notify(msg) {
-    if (this._internalIoHost) {
-      return this._internalIoHost.notify(msg);
+  return maxWidth;
+}
+
+// ../tmp-toolkit-helpers/src/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 (levelPriority[msg.level] > levelPriority[this.logLevel]) {
+    if (Array.isArray(x)) {
+      ret.update("[");
+      for (const e of x) {
+        recurse(e);
+        ret.update("||");
+      }
+      ret.update("]");
       return;
     }
-    if (this.corkedCounter > 0) {
-      this.corkedLoggingBuffer.push(msg);
+    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;
     }
-    const output = this.formatMessage(msg);
-    const stream = this.selectStream(msg.level);
-    stream.write(output);
+    ret.update(`${x}${typeof x}`);
   }
-  /**
-   * Determines the output stream, based on message level and configuration.
-   */
-  selectStream(level) {
-    switch (level) {
-      case "error":
-        return process.stderr;
-      case "result":
-        return process.stdout;
-      default:
-        return this.isCI ? process.stdout : process.stderr;
+}
+
+// ../tmp-toolkit-helpers/src/util/directories.ts
+var fs = __toESM(require("fs"));
+var os = __toESM(require("os"));
+var path = __toESM(require("path"));
+function cdkHomeDir() {
+  const tmpDir = fs.realpathSync(os.tmpdir());
+  let home;
+  try {
+    let userInfoHome = os.userInfo().homedir;
+    if (userInfoHome == "/var/empty") {
+      userInfoHome = void 0;
     }
+    home = path.join((userInfoHome ?? os.homedir()).trim(), ".cdk");
+  } catch {
   }
-  /**
-   * Notifies the host of a message that requires a response.
-   *
-   * If the host does not return a response the suggested
-   * default response from the input message will be used.
-   */
-  async requestResponse(msg) {
-    if (this._internalIoHost) {
-      return this._internalIoHost.requestResponse(msg);
-    }
-    if (!isPromptableRequest(msg)) {
-      await this.notify(msg);
-      return msg.defaultResponse;
+  return process.env.CDK_HOME ? path.resolve(process.env.CDK_HOME) : home || fs.mkdtempSync(path.join(tmpDir, ".cdk")).trim();
+}
+function cdkCacheDir() {
+  return path.join(cdkHomeDir(), "cache");
+}
+function bundledPackageRootDir(start, fail) {
+  function _rootDir(dirname6) {
+    const manifestPath = path.join(dirname6, "package.json");
+    if (fs.existsSync(manifestPath)) {
+      return dirname6;
     }
-    const response = await this.withCorkedLogging(async () => {
-      const data = msg.data ?? {};
-      const motivation = data.motivation ?? "User input is needed";
-      const concurrency = data.concurrency ?? 0;
-      if (!this.isTTY) {
-        throw new ToolkitError(`${motivation}, but terminal (TTY) is not attached so we are unable to get a confirmation from the user`);
-      }
-      if (concurrency > 1) {
-        throw new ToolkitError(`${motivation}, but concurrency is greater than 1 so we are unable to get a confirmation from the user`);
+    if (path.dirname(dirname6) === dirname6) {
+      if (fail ?? true) {
+        throw new ToolkitError("Unable to find package manifest");
       }
-      if (isConfirmationPrompt(msg)) {
-        const confirmed = await promptly.confirm(`${chalk.cyan(msg.message)} (y/n)`);
-        if (!confirmed) {
-          throw new ToolkitError("Aborted by user");
-        }
-        return confirmed;
+      return void 0;
+    }
+    return _rootDir(path.dirname(dirname6));
+  }
+  return _rootDir(start);
+}
+
+// ../tmp-toolkit-helpers/src/util/json.ts
+function getResultObj(jsonObject, identifier, propertiesToReturn) {
+  const propsObj = {};
+  propertiesToReturn.forEach((propName) => {
+    Object.assign(propsObj, { [propName]: findJsonValue(jsonObject, propName) });
+  });
+  Object.assign(propsObj, { ["Identifier"]: identifier });
+  return propsObj;
+}
+function findJsonValue(jsonObject, path15) {
+  const paths = path15.split(".");
+  let obj = jsonObject;
+  paths.forEach((p) => {
+    obj = obj[p];
+    if (obj === void 0) {
+      throw new TypeError(`Cannot read field ${path15}. ${p} is not found.`);
+    }
+  });
+  return obj;
+}
+
+// ../tmp-toolkit-helpers/src/util/types.ts
+function isObject(x) {
+  return x !== null && typeof x === "object" && !isArray(x);
+}
+var isArray = Array.isArray;
+
+// ../tmp-toolkit-helpers/src/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, path15) {
+  path15 = path15.slice();
+  while (path15.length > 0 && isObject(x)) {
+    const key = path15.shift();
+    x = x[key];
+  }
+  return path15.length === 0 ? x : void 0;
+}
+function deepSet(x, path15, value) {
+  path15 = path15.slice();
+  if (path15.length === 0) {
+    throw new ToolkitError("Path may not be empty");
+  }
+  while (path15.length > 1 && isObject(x)) {
+    const key = path15.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[path15[0]] = value;
+  } else {
+    delete x[path15[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;
+}
+
+// ../tmp-toolkit-helpers/src/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();
+      });
+    }
+  });
+}
+
+// ../tmp-toolkit-helpers/src/util/serialize.ts
+var fs2 = __toESM(require("fs/promises"));
+
+// ../tmp-toolkit-helpers/src/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"
+  });
+}
+
+// ../tmp-toolkit-helpers/src/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);
+  }
+}
+async function loadStructuredFile(fileName) {
+  const contents = await fs2.readFile(fileName, { encoding: "utf-8" });
+  return deserializeStructure(contents);
+}
+function isJsonBuffer(value) {
+  return typeof value === "object" && "type" in value && value.type === "Buffer" && "data" in value && Array.isArray(value.data);
+}
+function replacerBufferWithInfo(_key, value) {
+  if (isJsonBuffer(value)) {
+    return `<Buffer: ${formatBytes(value.data.length)}>`;
+  }
+  return value;
+}
+
+// ../tmp-toolkit-helpers/src/util/string-manipulation.ts
+function padLeft(n, x, char = " ") {
+  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;
+}
+
+// ../tmp-toolkit-helpers/src/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.
+   */
+  selectStream(level) {
+    switch (level) {
+      case "error":
+        return process.stderr;
+      case "result":
+        return process.stdout;
+      default:
+        return this.isCI ? process.stdout : process.stderr;
+    }
+  }
+  /**
+   * Notifies the host of a message that requires a response.
+   *
+   * If the host does not return a response the suggested
+   * default response from the input message will be used.
+   */
+  async requestResponse(msg) {
+    if (this._internalIoHost) {
+      return this._internalIoHost.requestResponse(msg);
+    }
+    if (!isPromptableRequest(msg)) {
+      await this.notify(msg);
+      return msg.defaultResponse;
+    }
+    const response = await this.withCorkedLogging(async () => {
+      const data = msg.data ?? {};
+      const motivation = data.motivation ?? "User input is needed";
+      const concurrency = data.concurrency ?? 0;
+      if (!this.isTTY) {
+        throw new ToolkitError(`${motivation}, but terminal (TTY) is not attached so we are unable to get a confirmation from the user`);
+      }
+      if (concurrency > 1) {
+        throw new ToolkitError(`${motivation}, but concurrency is greater than 1 so we are unable to get a confirmation from the user`);
+      }
+      if (isConfirmationPrompt(msg)) {
+        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 +1189,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 +1213,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 +1232,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 = {
@@ -431,43 +1264,6 @@ var trace = (input, ...args) => {
   return formatMessageAndLog("trace", input, void 0, ...args);
 };
 
-// ../../aws-cdk/lib/util/directories.ts
-var fs = __toESM(require("fs"));
-var os = __toESM(require("os"));
-var path = __toESM(require("path"));
-function cdkHomeDir() {
-  const tmpDir = fs.realpathSync(os.tmpdir());
-  let home;
-  try {
-    let userInfoHome = os.userInfo().homedir;
-    if (userInfoHome == "/var/empty") {
-      userInfoHome = void 0;
-    }
-    home = path.join((userInfoHome ?? os.homedir()).trim(), ".cdk");
-  } catch {
-  }
-  return process.env.CDK_HOME ? path.resolve(process.env.CDK_HOME) : home || fs.mkdtempSync(path.join(tmpDir, ".cdk")).trim();
-}
-function cdkCacheDir() {
-  return path.join(cdkHomeDir(), "cache");
-}
-function rootDir(fail) {
-  function _rootDir(dirname5) {
-    const manifestPath = path.join(dirname5, "package.json");
-    if (fs.existsSync(manifestPath)) {
-      return dirname5;
-    }
-    if (path.dirname(dirname5) === dirname5) {
-      if (fail ?? true) {
-        throw new ToolkitError("Unable to find package manifest");
-      }
-      return void 0;
-    }
-    return _rootDir(path.dirname(dirname5));
-  }
-  return _rootDir(__dirname);
-}
-
 // ../../aws-cdk/lib/api/aws-auth/account-cache.ts
 var AccountAccessKeyCache = class _AccountAccessKeyCache {
   static {
@@ -521,7 +1317,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 +1330,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 +1400,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;
@@ -619,22 +1415,13 @@ function readIfPossible(filename) {
 
 // ../../aws-cdk/lib/api/aws-auth/user-agent.ts
 function defaultCliUserAgent() {
-  const root = rootDir(false);
+  const root = bundledPackageRootDir(__dirname, false);
   const pkg = JSON.parse((root ? readIfPossible(path3.join(root, "package.json")) : void 0) ?? "{}");
   const name = pkg.name ?? path3.basename(process.argv[1] ?? "cdk-cli");
   const version = pkg.version ?? "<unknown>";
   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";
-}
-
 // ../../aws-cdk/lib/api/aws-auth/sdk.ts
 var SDK = class {
   constructor(credProvider, region, requestHandler, logger) {
@@ -1087,10 +1874,10 @@ function getRegionFromIniFile(profile, data) {
   return data?.[profile]?.region;
 }
 function tryGetCACert(bundlePath) {
-  const path12 = bundlePath || caBundlePathFromEnvironment();
-  if (path12) {
-    debug("Using CA bundle path: %s", path12);
-    return readIfPossible(path12);
+  const path15 = bundlePath || caBundlePathFromEnvironment();
+  if (path15) {
+    debug("Using CA bundle path: %s", path15);
+    return readIfPossible(path15);
   }
   return void 0;
 }
@@ -1150,11 +1937,11 @@ async function tokenCodeFn(serialArn) {
 }
 
 // ../../aws-cdk/lib/api/aws-auth/credential-plugins.ts
-var import_util4 = require("util");
+var import_util10 = require("util");
 
 // ../../aws-cdk/lib/api/plugin/plugin.ts
-var import_util3 = require("util");
-var chalk3 = __toESM(require("chalk"));
+var import_util9 = require("util");
+var chalk5 = __toESM(require("chalk"));
 
 // ../../aws-cdk/lib/api/plugin/context-provider-plugin.ts
 function isContextProviderPlugin(x) {
@@ -1187,14 +1974,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 +2030,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_util9.inspect)(provider)}`);
     }
     this.contextProviderPlugins[pluginProviderName] = provider;
   }
@@ -1312,7 +2099,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_util10.inspect)(initial)}`);
   }
 }
 function v3ProviderFromV2Credentials(x) {
@@ -1331,7 +2118,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_util10.inspect)(newCreds)}`);
       }
       current = newCreds;
     }
@@ -1604,133 +2391,23 @@ function fmtObtainedCredentials(obtainResult) {
       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;
-      }
-    }
+      msg.push(")");
+      return msg.join("");
   }
-  return template;
-}
-function isJsonBuffer(value) {
-  return typeof value === "object" && "type" in value && value.type === "Buffer" && "data" in value && Array.isArray(value.data);
 }
-function replacerBufferWithInfo(_key, value) {
-  if (isJsonBuffer(value)) {
-    return `<Buffer: ${formatBytes(value.data.length)}>`;
-  }
-  return value;
+async function 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_util13 = require("util");
 function formatSdkLoggerContent(content) {
   if (content.length === 1) {
     const apiFmt = formatApiCall(content[0]);
@@ -1738,7 +2415,7 @@ function formatSdkLoggerContent(content) {
       return apiFmt;
     }
   }
-  return content.map((x) => typeof x === "string" ? x : (0, import_util5.inspect)(x)).join("");
+  return content.map((x) => typeof x === "string" ? x : (0, import_util13.inspect)(x)).join("");
 }
 function formatApiCall(content) {
   if (!isSdkApiCallSuccess(content) && !isSdkApiCallError(content)) {
@@ -1769,122 +2446,6 @@ function isSdkApiCallError(x) {
 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;
-      }
-    }
-  }
-  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/api/settings.ts
 var TRANSIENT_CONTEXT_KEY = "$dontSaveContext";
 var Settings = class _Settings {
   constructor(settings = {}, readOnly = false) {
@@ -1942,22 +2503,22 @@ var Settings = class _Settings {
   get empty() {
     return Object.keys(this.settings).length === 0;
   }
-  get(path12) {
-    return deepClone(deepGet(this.settings, path12));
+  get(path15) {
+    return deepClone(deepGet(this.settings, path15));
   }
-  set(path12, value) {
+  set(path15, value) {
     if (this.readOnly) {
-      throw new ToolkitError(`Can't set ${path12}: settings object is readonly`);
+      throw new ToolkitError(`Can't set ${path15}: settings object is readonly`);
     }
-    if (path12.length === 0) {
+    if (path15.length === 0) {
       this.settings = value;
     } else {
-      deepSet(this.settings, path12, value);
+      deepSet(this.settings, path15, value);
     }
     return this;
   }
-  unset(path12) {
-    this.set(path12, void 0);
+  unset(path15) {
+    this.set(path15, void 0);
   }
   prohibitContextKey(key, fileName) {
     if (!this.settings.context) {
@@ -2069,7 +2630,7 @@ var Context = class {
 };
 
 // ../../aws-cdk/lib/api/deployments/cloudformation.ts
-var import_util6 = require("util");
+var import_util19 = require("util");
 var cxapi = __toESM(require("@aws-cdk/cx-api"));
 var import_cx_api3 = require("@aws-cdk/cx-api");
 var import_client_cloudformation3 = require("@aws-sdk/client-cloudformation");
@@ -2169,9 +2730,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 {
@@ -2233,278 +2794,60 @@ var StackEventPoller = class _StackEventPoller {
             isStackEvent: isParentStackEvent
           };
           events.push(resEvent);
-          if (!isParentStackEvent && event.ResourceType === "AWS::CloudFormation::Stack" && isStackBeginOperationState(event.ResourceStatus)) {
-            this.trackNestedStack(event, [...this.props.parentStackLogicalIds ?? [], event.LogicalResourceId ?? ""]);
-          }
-          if (isParentStackEvent && isStackTerminalState(event.ResourceStatus)) {
-            this.complete = true;
-          }
-        }
-        nextToken = page?.NextToken;
-        if (nextToken === void 0) {
-          finished = true;
-        }
-      }
-    } catch (e) {
-      if (!(e.name === "ValidationError" && formatErrorMessage(e) === `Stack [${this.props.stackName}] does not exist`)) {
-        throw e;
-      }
-    }
-    return events;
-  }
-  /**
-   * On the CREATE_IN_PROGRESS, UPDATE_IN_PROGRESS, DELETE_IN_PROGRESS event of a nested stack, poll the nested stack updates
-   */
-  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;
+          if (!isParentStackEvent && event.ResourceType === "AWS::CloudFormation::Stack" && isStackBeginOperationState(event.ResourceStatus)) {
+            this.trackNestedStack(event, [...this.props.parentStackLogicalIds ?? [], event.LogicalResourceId ?? ""]);
+          }
+          if (isParentStackEvent && isStackTerminalState(event.ResourceStatus)) {
+            this.complete = true;
+          }
+        }
+        nextToken = page?.NextToken;
+        if (nextToken === void 0) {
+          finished = true;
+        }
       }
-      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)
-        };
+      if (!(e.name === "ValidationError" && formatErrorMessage(e) === `Stack [${this.props.stackName}] does not exist`)) {
+        throw e;
       }
     }
-    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);
-    }
+    return events;
   }
   /**
-   * 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.
+   * On the CREATE_IN_PROGRESS, UPDATE_IN_PROGRESS, DELETE_IN_PROGRESS event of a nested stack, poll the nested stack updates
    */
-  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 ?? "");
-      }
+  trackNestedStack(event, parentStackLogicalIds) {
+    const logicalId = event.LogicalResourceId;
+    const physicalResourceId = event.PhysicalResourceId;
+    if (!logicalId || !physicalResourceId) {
+      return;
     }
-  }
-  simplifyConstructPath(path12) {
-    path12 = path12.replace(/\/Resource$/, "");
-    path12 = path12.replace(/^\//, "");
-    if (path12.startsWith(this.stackName + "/")) {
-      path12 = path12.slice(this.stackName.length + 1);
+    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,52 +2864,57 @@ 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);
-        }
-      }
+  /**
+   * Report the stack progress
+   */
+  get progress() {
+    return {
+      total: this.total,
+      completed: this.completed,
+      formatted: this.formatted
+    };
+  }
+  /**
+   * The total number of progress monitored resources.
+   */
+  get total() {
+    return this.resourcesTotal;
+  }
+  /**
+   * 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
+   */
+  get formatted() {
+    if (this.resourcesTotal == null) {
+      return padLeft(3, util5.format("%s", this.resourcesDone));
     }
-    return resourceStatusReason;
+    return util5.format(
+      "%s/%s",
+      padLeft(this.resourceDigits, this.resourcesDone.toString()),
+      padLeft(this.resourceDigits, this.resourcesTotal.toString())
+    );
   }
-  addActivity(activity) {
-    const status = activity.event.ResourceStatus;
-    const hookStatus = activity.event.HookStatus;
-    const hookType = activity.event.HookType;
-    if (!status || !activity.event.LogicalResourceId) {
+  /**
+   * Process as stack event and update the progress state.
+   */
+  process(event) {
+    const status = event.ResourceStatus;
+    if (!status || !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];
+      const prevState = this.resourcesPrevCompleteState[event.LogicalResourceId];
       if (!prevState) {
         this.resourcesDone++;
       } else {
@@ -2575,265 +2923,175 @@ var ActivityPrinterBase = class {
           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 ?? "");
-      }
+      this.resourcesPrevCompleteState[event.LogicalResourceId] = status;
     }
   }
-  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();
+
+// ../../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()
+    });
   }
-  addActivity(activity) {
-    super.addActivity(activity);
-    this.printable.push(activity);
-    this.print();
+  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;
   }
-  print() {
-    for (const activity of this.printable) {
-      this.printOne(activity);
+  async stop() {
+    const oldMonitorId = this.monitorId;
+    this.monitorId = void 0;
+    if (this.tickTimer) {
+      clearTimeout(this.tickTimer);
     }
-    this.printable.splice(0, this.printable.length);
-    this.printInProgress();
+    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
+    }));
   }
-  stop() {
-    if (this.failures.length > 0) {
-      info("\nFailed resources:");
-      for (const failure of this.failures) {
-        if (failure.isStackEvent) {
-          continue;
-        }
-        this.printOne(failure, false);
-      }
+  scheduleNextTick() {
+    if (!this.monitorId) {
+      return;
     }
+    this.tickTimer = setTimeout(() => void this.tick(), this.pollingInterval);
   }
-  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) : "";
+  async tick() {
+    if (!this.monitorId) {
+      return;
+    }
+    try {
+      this.readPromise = this.readNewEvents(this.monitorId);
+      await this.readPromise;
+      this.readPromise = void 0;
+      if (!this.monitorId) {
+        return;
       }
-      if (metadata) {
-        stackTrace = metadata.entry.trace ? `
-	${metadata.entry.trace.join("\n	\\_ ")}` : "";
+    } 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();
+  }
+  findMetadataFor(logicalId) {
+    const metadata = this.stack.manifest?.metadata;
+    if (!logicalId || !metadata) {
+      return void 0;
+    }
+    for (const path15 of Object.keys(metadata)) {
+      const entry = metadata[path15].filter((e) => e.type === import_cloud_assembly_schema.ArtifactMetadataEntryType.LOGICAL_ID).find((e) => e.data === logicalId);
+      if (entry) {
+        return {
+          entry,
+          constructPath: this.simplifyConstructPath(path15)
+        };
       }
-      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();
+    return void 0;
   }
   /**
-   * Report the current progress as a [34/42] string, or just [34] if the total is unknown
+   * 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
    */
-  progress() {
-    if (this.resourcesTotal == null) {
-      return padLeft(3, util3.format("%s", this.resourcesDone));
+  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));
     }
-    return util3.format(
-      "%s/%s",
-      padLeft(this.resourceDigits, this.resourcesDone.toString()),
-      padLeft(this.resourceDigits, this.resourcesTotal != null ? this.resourcesTotal.toString() : "?")
-    );
   }
   /**
-   * If some resources are taking a while to create, notify the user about what's currently in progress
+   * 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.
    */
-  printInProgress() {
-    if (Date.now() < this.lastPrintTime + this.inProgressDelay) {
-      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(", "))
-        )
-      );
+  async finalPollToEnd(monitorId) {
+    if (this.readPromise) {
+      await this.readPromise;
     }
-    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);
+    await this.readNewEvents(monitorId);
   }
-  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 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)
-        );
-      })
+  /**
+   * 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	\\_ ")}` : ""
     );
-    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	\\_ ")}
-`));
+  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 ?? "");
       }
     }
-    this.block.displayLines(lines);
-    this.block.removeEmptyLines();
   }
-  progressBar(width) {
-    if (!this.resourcesTotal) {
-      return "";
+  simplifyConstructPath(path15) {
+    path15 = path15.replace(/\/Resource$/, "");
+    path15 = path15.replace(/^\//, "");
+    if (path15.startsWith(this.stackName + "/")) {
+      path15 = path15.slice(this.stackName.length + 1);
     }
-    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) ?? "")}` : "";
+    return path15;
   }
 };
-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;
-  }
-  if (status.indexOf("FAILED") !== -1) {
-    return chalk4.red;
-  }
-  if (status.indexOf("ROLLBACK") !== -1) {
-    return chalk4.yellow;
-  }
-  if (status.indexOf("COMPLETE") !== -1) {
-    return chalk4.green;
-  }
-  return chalk4.reset;
-}
-function colorFromStatusActivity(status) {
-  if (!status) {
-    return chalk4.reset;
-  }
-  if (status.endsWith("_FAILED")) {
-    return chalk4.red;
-  }
-  if (status.startsWith("CREATE_") || status.startsWith("UPDATE_") || status.startsWith("IMPORT_")) {
-    return chalk4.green;
-  }
-  if (status.indexOf("ROLLBACK_") !== -1) {
-    return chalk4.yellow;
-  }
-  if (status.startsWith("DELETE_")) {
-    return chalk4.yellow;
-  }
-  return chalk4.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);
-}
-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 +3158,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 +3178,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 +3404,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_util19.format)("Waiting for changeset %s on stack %s to finish creating...", changeSetName, stackName)));
   const ret = await waitFor(async () => {
     const description = await describeChangeSet(cfn, stackName, changeSetName, {
       fetchAll
     });
     if (description.Status === "CREATE_PENDING" || description.Status === "CREATE_IN_PROGRESS") {
-      await ioHost.notify(debug2(action, (0, import_util6.format)("Changeset %s on stack %s is still creating", changeSetName, stackName)));
+      await ioHost.notify(debug2(action, (0, import_util19.format)("Changeset %s on stack %s is still creating", changeSetName, stackName)));
       return void 0;
     }
     if (description.Status === import_client_cloudformation3.ChangeSetStatus.CREATE_COMPLETE || changeSetHasNoChanges(description)) {
@@ -3276,19 +3495,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_util19.format)("Waiting for stack %s to finish creating or updating...", stackName)));
   return waitFor(async () => {
     const stack = await CloudFormationStack.lookup(cfn, stackName);
     if (!stack.exists) {
-      await ioHost.notify(debug2(action, (0, import_util6.format)("Stack %s does not exist", stackName)));
+      await ioHost.notify(debug2(action, (0, import_util19.format)("Stack %s does not exist", stackName)));
       return null;
     }
     const status = stack.stackStatus;
     if (status.isInProgress) {
-      await ioHost.notify(debug2(action, (0, import_util6.format)("Stack %s has an ongoing operation in progress and is not stable (%s)", stackName, status)));
+      await ioHost.notify(debug2(action, (0, import_util19.format)("Stack %s has an ongoing operation in progress and is not stable (%s)", stackName, status)));
       return void 0;
     } else if (status.isReviewInProgress) {
-      await ioHost.notify(debug2(action, (0, import_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_util19.format)("Stack %s is in REVIEW_IN_PROGRESS state. Considering this is a stable status (%s)", stackName, status)));
     }
     return stack;
   });
@@ -3380,7 +3599,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 +3776,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_util25 = 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 +3793,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 +3874,9 @@ async function prepareDockerImageAsset(asset, assetManifest, envResources) {
 }
 
 // ../../aws-cdk/lib/api/deployments/hotswap-deployments.ts
-var import_util8 = require("util");
+var import_util23 = 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"));
@@ -4548,101 +4767,30 @@ async function prepareTaskDefinitionChange(evaluateCfnTemplate, logicalId, chang
   const familyNameOrArn = await evaluateCfnTemplate.establishResourcePhysicalName(
     logicalId,
     taskDefinitionResource?.Family
-  );
-  if (!familyNameOrArn) {
-    return;
-  }
-  const familyNameOrArnParts = familyNameOrArn.split(":");
-  const family = familyNameOrArnParts.length > 1 ? (
-    // familyNameOrArn is actually an ARN, of the format 'arn:aws:ecs:region:account:task-definition/<family-name>:<revision-nr>'
-    // so, take the 6th element, at index 5, and split it on '/'
-    familyNameOrArnParts[5].split("/")[1]
-  ) : (
-    // otherwise, familyNameOrArn is just the simple name evaluated from the CloudFormation template
-    familyNameOrArn
-  );
-  return {
-    ...await evaluateCfnTemplate.evaluateCfnExpression({
-      ...taskDefinitionResource ?? {},
-      Family: void 0
-    }),
-    Family: family
-  };
-}
-
-// ../../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;
+  );
+  if (!familyNameOrArn) {
+    return;
+  }
+  const familyNameOrArnParts = familyNameOrArn.split(":");
+  const family = familyNameOrArnParts.length > 1 ? (
+    // familyNameOrArn is actually an ARN, of the format 'arn:aws:ecs:region:account:task-definition/<family-name>:<revision-nr>'
+    // so, take the 6th element, at index 5, and split it on '/'
+    familyNameOrArnParts[5].split("/")[1]
+  ) : (
+    // otherwise, familyNameOrArn is just the simple name evaluated from the CloudFormation template
+    familyNameOrArn
+  );
+  return {
+    ...await evaluateCfnTemplate.evaluateCfnExpression({
+      ...taskDefinitionResource ?? {},
+      Family: void 0
+    }),
+    Family: family
+  };
 }
 
-// ../../aws-cdk/lib/util/version-range.ts
-var semver = __toESM(require("semver"));
-
 // ../../aws-cdk/lib/api/hotswap/lambda-functions.ts
+var import_stream = require("stream");
 var archiver2 = require("archiver");
 async function isHotswappableLambdaFunctionChange(logicalId, change, evaluateCfnTemplate) {
   if (change.newValue.Type === "AWS::Lambda::Version") {
@@ -5263,7 +5411,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_util23.format)(`   ${ICON} %s`, chalk8.bold(name))));
   }
   try {
     await hotswapOperation.apply(sdk);
@@ -5277,7 +5425,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_util23.format)(`${ICON} %s %s`, chalk8.bold(name), chalk8.green("hotswapped!"))));
   }
   sdk.removeCustomUserAgent(customUserAgent);
 }
@@ -5305,25 +5453,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_util23.format)("%s %s", chalk8.red("\u26A0\uFE0F"), chalk8.red("The following non-hotswappable changes were found. To reconcile these using CloudFormation, specify --hotswap-fallback")));
   } else {
-    messages.push((0, import_util8.format)("%s %s", chalk7.red("\u26A0\uFE0F"), chalk7.red("The following non-hotswappable changes were found:")));
+    messages.push((0, import_util23.format)("%s %s", chalk8.red("\u26A0\uFE0F"), chalk8.red("The following non-hotswappable changes were found:")));
   }
   for (const change of nonHotswappableChanges) {
     if (change.rejectedChanges.length > 0) {
-      messages.push((0, import_util8.format)(
+      messages.push((0, import_util23.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_util23.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 +5519,11 @@ async function deployStack(options, { ioHost, action }) {
     if (hotswapMode !== "full-deployment" /* FULL_DEPLOYMENT */) {
       await ioHost.notify(info2(
         action,
-        (0, import_util9.format)(
+        (0, import_util25.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 +5567,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_util25.format)(
         "Could not perform a hotswap deployment, as the stack %s contains non-Asset changes",
         stackArtifact.displayName
       )));
@@ -5427,7 +5575,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_util25.format)(
         "Could not perform a hotswap deployment, because the CloudFormation template could not be resolved: %s",
         formatErrorMessage(e)
       )));
@@ -5468,7 +5616,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 +5639,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_util25.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_util25.format)("Deleting empty change set %s", changeSetDescription.ChangeSetId)));
         await this.cfn.deleteChangeSet({
           StackName: this.stackName,
           ChangeSetName: changeSetName
@@ -5519,10 +5667,10 @@ var FullCloudFormationDeployment = class {
       };
     }
     if (!execute) {
-      info2(this.action, (0, import_util9.format)(
+      await this.ioHost.notify(info2(this.action, (0, import_util25.format)(
         "Changeset %s created and waiting in review for manual execution (--no-execute)",
         changeSetDescription.ChangeSetId
-      ));
+      )));
       return {
         type: "did-deploy-stack",
         noOp: false,
@@ -5547,7 +5695,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_util25.format)("%s: creating CloudFormation changeset...", chalk9.bold(this.stackName))));
     const changeSet = await this.cfn.createChangeSet({
       StackName: this.stackName,
       ChangeSetName: changeSetName,
@@ -5558,13 +5706,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_util25.format)("Initiated creation of changeset: %s; waiting for it to finish creating...", changeSet.Id)));
     return waitForChangeSet(this.cfn, { ioHost: this.ioHost, action: this.action }, this.stackName, changeSetName, {
       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_util25.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 +5721,7 @@ var FullCloudFormationDeployment = class {
     });
     await this.ioHost.notify(debug2(
       this.action,
-      (0, import_util9.format)(
+      (0, import_util25.format)(
         "Execution of changeset %s on stack %s has started; waiting for the update to complete...",
         changeSet.ChangeSetId,
         this.stackName
@@ -5596,7 +5744,7 @@ var FullCloudFormationDeployment = class {
     if (!!this.cloudFormationStack.terminationProtection !== terminationProtection) {
       await this.ioHost.notify(debug2(
         this.action,
-        (0, import_util9.format)(
+        (0, import_util25.format)(
           "Updating termination protection from %s to %s for stack %s",
           this.cloudFormationStack.terminationProtection,
           terminationProtection,
@@ -5607,11 +5755,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_util25.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_util25.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 +5772,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_util25.format)("No updates are to be performed for stack %s", this.stackName)));
           return {
             type: "did-deploy-stack",
             noOp: true,
@@ -5648,12 +5796,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 +5814,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_util25.format)("Stack %s has completed updating", this.stackName));
     return {
       type: "did-deploy-stack",
       noOp: false,
@@ -5709,9 +5861,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 +5876,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();
@@ -5798,34 +5955,54 @@ function hasReplacement(cs) {
 
 // ../../aws-cdk/lib/notices.ts
 var https = __toESM(require("node:https"));
-var path9 = __toESM(require("path"));
-var fs10 = __toESM(require("fs-extra"));
+var path10 = __toESM(require("path"));
+var fs11 = __toESM(require("fs-extra"));
 var semver4 = __toESM(require("semver"));
 
 // ../../aws-cdk/lib/cli/version.ts
-var path7 = __toESM(require("path"));
-var chalk9 = __toESM(require("chalk"));
-var fs8 = __toESM(require("fs-extra"));
+var path8 = __toESM(require("path"));
+var chalk10 = __toESM(require("chalk"));
+var fs9 = __toESM(require("fs-extra"));
 var semver3 = __toESM(require("semver"));
 
+// ../../aws-cdk/lib/cli/root-dir.ts
+var fs8 = __toESM(require("fs"));
+var path7 = __toESM(require("path"));
+function cliRootDir(fail) {
+  function _rootDir(dirname6) {
+    const manifestPath = path7.join(dirname6, "package.json");
+    if (fs8.existsSync(manifestPath)) {
+      return dirname6;
+    }
+    if (path7.dirname(dirname6) === dirname6) {
+      if (fail ?? true) {
+        throw new ToolkitError("Unable to find package manifest");
+      }
+      return void 0;
+    }
+    return _rootDir(path7.dirname(dirname6));
+  }
+  return _rootDir(__dirname);
+}
+
 // ../../aws-cdk/lib/cli/util/console-formatters.ts
 var stripAnsi = require("strip-ansi");
 
 // ../../aws-cdk/lib/cli/util/npm.ts
 var import_child_process = require("child_process");
-var import_util10 = require("util");
+var import_util27 = require("util");
 var semver2 = __toESM(require("semver"));
-var exec = (0, import_util10.promisify)(import_child_process.exec);
+var exec = (0, import_util27.promisify)(import_child_process.exec);
 
 // ../../aws-cdk/lib/cli/version.ts
 var ONE_DAY_IN_SECONDS = 1 * 24 * 60 * 60;
 function versionNumber() {
-  return require(path7.join(rootDir(), "package.json")).version.replace(/\+[0-9a-f]+$/, "");
+  return require(path8.join(cliRootDir(), "package.json")).version.replace(/\+[0-9a-f]+$/, "");
 }
 
 // ../../aws-cdk/lib/tree.ts
-var path8 = __toESM(require("path"));
-var fs9 = __toESM(require("fs-extra"));
+var path9 = __toESM(require("path"));
+var fs10 = __toESM(require("fs-extra"));
 function some(node, predicate) {
   return node != null && (predicate(node) || findInChildren());
   function findInChildren() {
@@ -5836,7 +6013,7 @@ function loadTree(assembly) {
   try {
     const outdir = assembly.directory;
     const fileName = assembly.tree()?.file;
-    return fileName ? fs9.readJSONSync(path8.join(outdir, fileName)).tree : {};
+    return fileName ? fs10.readJSONSync(path9.join(outdir, fileName)).tree : {};
   } catch (e) {
     trace(`Failed to get tree.json file: ${e}. Proceeding with empty tree.`);
     return void 0;
@@ -5844,7 +6021,7 @@ function loadTree(assembly) {
 }
 function loadTreeFromDir(outdir) {
   try {
-    return fs9.readJSONSync(path8.join(outdir, "tree.json")).tree;
+    return fs10.readJSONSync(path9.join(outdir, "tree.json")).tree;
   } catch (e) {
     trace(`Failed to get tree.json file: ${e}. Proceeding with empty tree.`);
     return void 0;
@@ -5852,7 +6029,7 @@ function loadTreeFromDir(outdir) {
 }
 
 // ../../aws-cdk/lib/notices.ts
-var CACHE_FILE_PATH = path9.join(cdkCacheDir(), "notices.json");
+var CACHE_FILE_PATH = path10.join(cdkCacheDir(), "notices.json");
 var NoticesFilter = class _NoticesFilter {
   static filter(options) {
     const components = [
@@ -5901,7 +6078,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);
@@ -6209,7 +6386,7 @@ var CachedDataSource = class {
       notices: []
     };
     try {
-      return fs10.existsSync(this.fileName) ? await fs10.readJSON(this.fileName) : defaultValue;
+      return fs11.existsSync(this.fileName) ? await fs11.readJSON(this.fileName) : defaultValue;
     } catch (e) {
       debug(`Failed to load notices from cache: ${e}`);
       return defaultValue;
@@ -6217,7 +6394,7 @@ var CachedDataSource = class {
   }
   async save(cached2) {
     try {
-      await fs10.writeJSON(this.fileName, cached2);
+      await fs11.writeJSON(this.fileName, cached2);
     } catch (e) {
       debug(`Failed to store notices in the cache: ${e}`);
     }
@@ -6225,14 +6402,15 @@ var CachedDataSource = class {
 };
 
 // ../../aws-cdk/lib/api/toolkit-info.ts
-var import_util11 = require("util");
-var chalk10 = __toESM(require("chalk"));
+var import_util30 = require("util");
+var chalk11 = __toESM(require("chalk"));
 
 // ../../aws-cdk/lib/api/bootstrap/bootstrap-props.ts
 var BUCKET_NAME_OUTPUT = "BucketName";
 var REPOSITORY_NAME_OUTPUT = "ImageRepositoryName";
 var BUCKET_DOMAIN_NAME_OUTPUT = "BucketDomainName";
 var BOOTSTRAP_VERSION_OUTPUT = "BootstrapVersion";
+var BOOTSTRAP_VERSION_RESOURCE = "CdkBootstrapVersion";
 var BOOTSTRAP_VARIANT_PARAMETER = "BootstrapVariant";
 var DEFAULT_BOOTSTRAP_VARIANT = "AWS CDK: Default Resources";
 
@@ -6250,11 +6428,11 @@ var ToolkitInfo = class _ToolkitInfo {
       if (!stack) {
         await ioHost.notify(debug2(
           action,
-          (0, import_util11.format)(
+          (0, import_util30.format)(
             "The environment %s doesn't have the CDK toolkit stack (%s) installed. Use %s to setup your environment for use with the toolkit.",
             environment.name,
             stackName,
-            chalk10.blue(`cdk bootstrap "${environment.name}"`)
+            chalk11.blue(`cdk bootstrap "${environment.name}"`)
           )
         ));
         return _ToolkitInfo.bootstrapStackNotFoundInfo(stackName);
@@ -6262,11 +6440,11 @@ var ToolkitInfo = class _ToolkitInfo {
       if (stack.stackStatus.isCreationFailure) {
         await ioHost.notify(debug2(
           action,
-          (0, import_util11.format)(
+          (0, import_util30.format)(
             "The environment %s has a CDK toolkit stack (%s) that failed to create. Use %s to try provisioning it again.",
             environment.name,
             stackName,
-            chalk10.blue(`cdk bootstrap "${environment.name}"`)
+            chalk11.blue(`cdk bootstrap "${environment.name}"`)
           )
         ));
         return _ToolkitInfo.bootstrapStackNotFoundInfo(stackName);
@@ -6513,6 +6691,19 @@ var EnvironmentResources = class {
     return { repositoryUri };
   }
 };
+var NoBootstrapStackEnvironmentResources = class extends EnvironmentResources {
+  constructor(environment, sdk, msg) {
+    super(environment, sdk, msg, emptyCache());
+  }
+  /**
+   * Look up the toolkit for a given environment, using a given SDK
+   */
+  async lookupToolkit() {
+    throw new ToolkitError(
+      "Trying to perform an operation that requires a bootstrap stack; you should not see this error, this is a bug in the CDK CLI."
+    );
+  }
+};
 function emptyCache() {
   return {
     ssmParameters: /* @__PURE__ */ new Map(),
@@ -6800,7 +6991,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 +7001,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 +7071,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 +7087,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 };
@@ -6924,9 +7117,7 @@ var Deployments = class {
       sdk: env.sdk,
       roleArn: executionRoleArn,
       stack: options.stack,
-      deployName: options.deployName,
-      quiet: options.quiet,
-      ci: options.ci
+      deployName: options.deployName
     }, { ioHost: this.ioHost, action: this.action });
   }
   async stackExists(options) {
@@ -6961,7 +7152,7 @@ var Deployments = class {
     const publisher = this.cachedPublisher(assetManifest, resolvedEnvironment, options.stackName);
     await publisher.buildEntry(asset);
     if (publisher.hasFailures) {
-      throw new ToolkitError(`Failed to build asset ${asset.id}`);
+      throw new ToolkitError(`Failed to build asset ${asset.displayName(false)}`);
     }
   }
   /**
@@ -6972,7 +7163,7 @@ var Deployments = class {
     const publisher = this.cachedPublisher(assetManifest, stackEnv, options.stackName);
     await publisher.publishEntry(asset, { allowCrossAccount: await this.allowCrossAccountAssetPublishingForEnv(options.stack) });
     if (publisher.hasFailures) {
-      throw new ToolkitError(`Failed to publish asset ${asset.id}`);
+      throw new ToolkitError(`Failed to publish asset ${asset.displayName(true)}`);
     }
   }
   async allowCrossAccountAssetPublishingForEnv(stack) {
@@ -7010,7 +7201,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,10 +7238,10 @@ function tagsForStack(stack) {
 }
 
 // ../../aws-cdk/lib/api/resource-import/importer.ts
-var import_util12 = require("util");
+var import_util34 = require("util");
 var cfnDiff = __toESM(require("@aws-cdk/cloudformation-diff"));
-var chalk12 = __toESM(require("chalk"));
-var fs11 = __toESM(require("fs-extra"));
+var chalk13 = __toESM(require("chalk"));
+var fs12 = __toESM(require("fs-extra"));
 var promptly3 = __toESM(require("promptly"));
 var ResourceImporter = class {
   constructor(stack, props) {
@@ -7079,18 +7270,18 @@ var ResourceImporter = class {
    * Load the resources to import from a file
    */
   async loadResourceIdentifiers(available, filename) {
-    const contents = await fs11.readJson(filename);
+    const contents = await fs12.readJson(filename);
     const ret = { importResources: [], resourceMap: {} };
     for (const resource of available) {
       const descr = this.describeResource(resource.logicalId);
       const idProps = contents[resource.logicalId];
       if (idProps) {
-        await this.ioHost.notify(info2(this.action, (0, import_util12.format)("%s: importing using %s", chalk12.blue(descr), chalk12.blue(fmtdict(idProps)))));
+        await this.ioHost.notify(info2(this.action, (0, import_util34.format)("%s: importing using %s", chalk13.blue(descr), chalk13.blue(fmtdict(idProps)))));
         ret.importResources.push(resource);
         ret.resourceMap[resource.logicalId] = idProps;
         delete contents[resource.logicalId];
       } else {
-        await this.ioHost.notify(info2(this.action, (0, import_util12.format)("%s: skipping", chalk12.blue(descr))));
+        await this.ioHost.notify(info2(this.action, (0, import_util34.format)("%s: skipping", chalk13.blue(descr))));
       }
     }
     const unknown = Object.keys(contents);
@@ -7134,9 +7325,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_util34.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_util34.format)("\n \u274C  %s failed: %s", chalk13.bold(this.stack.displayName), e), "CDK_TOOLKIT_E3900"));
       throw e;
     }
   }
@@ -7238,21 +7429,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 +7456,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 +7473,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,8 +7523,8 @@ function addDefaultDeletionPolicy(resource) {
 }
 
 // ../../aws-cdk/lib/api/resource-import/migrator.ts
-var chalk13 = __toESM(require("chalk"));
-var fs12 = __toESM(require("fs-extra"));
+var chalk14 = __toESM(require("chalk"));
+var fs13 = __toESM(require("fs-extra"));
 var ResourceMigrator = class {
   constructor(props) {
     this.props = props;
@@ -7355,11 +7546,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)...`));
+      fs13.rmSync("migrate.json");
+      await this.ioHost.notify(info2(this.action, `${chalk14.bold(stack.displayName)}: applying CDKMetadata and Outputs to stack (if applicable)...`));
     }
   }
   /**
@@ -7372,7 +7563,6 @@ var ResourceMigrator = class {
       roleArn: options.roleArn,
       deploymentMethod: options.deploymentMethod,
       usePreviousParameters: true,
-      progress: options.progress,
       rollback: options.rollback
     });
     elapsedDeployTime = (/* @__PURE__ */ new Date()).getTime() - startDeployTime;
@@ -7384,7 +7574,7 @@ var ResourceMigrator = class {
   }
   async tryGetResources(environment) {
     try {
-      const migrateFile = fs12.readJsonSync("migrate.json", {
+      const migrateFile = fs13.readJsonSync("migrate.json", {
         encoding: "utf-8"
       });
       const sourceEnv = migrateFile.Source.split(":");
@@ -7398,8 +7588,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 +7680,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()
       )
     );
@@ -7882,17 +8072,17 @@ var WorkGraph = class {
       }
     }
     return void 0;
-    function recurse(nodeId, path12) {
+    function recurse(nodeId, path15) {
       if (seen.has(nodeId)) {
         return void 0;
       }
       try {
         for (const dep of self.nodes[nodeId].dependencies ?? []) {
-          const index = path12.indexOf(dep);
+          const index = path15.indexOf(dep);
           if (index > -1) {
-            return [...path12.slice(index), dep];
+            return [...path15.slice(index), dep];
           }
-          const cycle = recurse(dep, [...path12, dep]);
+          const cycle = recurse(dep, [...path15, dep]);
           if (cycle) {
             return cycle;
           }
@@ -7994,7 +8184,7 @@ var WorkGraphBuilder = class _WorkGraphBuilder {
       const node = {
         type: "asset-build",
         id: buildId,
-        note: assetId,
+        note: asset.displayName(false),
         dependencies: /* @__PURE__ */ new Set([
           ...this.stackArtifactIds(assetManifestArtifact.dependencies),
           // If we disable prebuild, then assets inherit (stack) dependencies from their parent stack
@@ -8014,7 +8204,7 @@ var WorkGraphBuilder = class _WorkGraphBuilder {
       this.graph.addNodes({
         type: "asset-publish",
         id: publishId,
-        note: `${asset.id}`,
+        note: asset.displayName(true),
         dependencies: /* @__PURE__ */ new Set([
           buildId
         ]),
@@ -8086,8 +8276,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 +8285,477 @@ 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/api/bootstrap/bootstrap-environment.ts
+var import_console = require("console");
+var path12 = __toESM(require("path"));
+
+// ../../aws-cdk/lib/api/bootstrap/deploy-bootstrap.ts
+var os4 = __toESM(require("os"));
+var path11 = __toESM(require("path"));
+var import_cloud_assembly_schema2 = require("@aws-cdk/cloud-assembly-schema");
+var import_cx_api6 = require("@aws-cdk/cx-api");
+var fs14 = __toESM(require("fs-extra"));
+var BootstrapStack = class _BootstrapStack {
+  constructor(sdkProvider, sdk, resolvedEnvironment, toolkitStackName, currentToolkitInfo, msg) {
+    this.sdkProvider = sdkProvider;
+    this.sdk = sdk;
+    this.resolvedEnvironment = resolvedEnvironment;
+    this.toolkitStackName = toolkitStackName;
+    this.currentToolkitInfo = currentToolkitInfo;
+    this.msg = msg;
+  }
+  static async lookup(sdkProvider, environment, toolkitStackName, msg) {
+    toolkitStackName = toolkitStackName ?? DEFAULT_TOOLKIT_STACK_NAME;
+    const resolvedEnvironment = await sdkProvider.resolveEnvironment(environment);
+    const sdk = (await sdkProvider.forEnvironment(resolvedEnvironment, 1 /* ForWriting */)).sdk;
+    const currentToolkitInfo = await ToolkitInfo.lookup(resolvedEnvironment, sdk, msg, toolkitStackName);
+    return new _BootstrapStack(sdkProvider, sdk, resolvedEnvironment, toolkitStackName, currentToolkitInfo, msg);
+  }
+  get parameters() {
+    return this.currentToolkitInfo.found ? this.currentToolkitInfo.bootstrapStack.parameters : {};
+  }
+  get terminationProtection() {
+    return this.currentToolkitInfo.found ? this.currentToolkitInfo.bootstrapStack.terminationProtection : void 0;
+  }
+  async partition() {
+    return (await this.sdk.currentAccount()).partition;
+  }
+  /**
+   * Perform the actual deployment of a bootstrap stack, given a template and some parameters
+   */
+  async update(template, parameters, options) {
+    if (this.currentToolkitInfo.found && !options.force) {
+      const abortResponse = {
+        type: "did-deploy-stack",
+        noOp: true,
+        outputs: {},
+        stackArn: this.currentToolkitInfo.bootstrapStack.stackId
+      };
+      const currentVariant = this.currentToolkitInfo.variant;
+      const newVariant = bootstrapVariantFromTemplate(template);
+      if (currentVariant !== newVariant) {
+        await this.msg.ioHost.notify(warn(
+          this.msg.action,
+          `Bootstrap stack already exists, containing '${currentVariant}'. Not overwriting it with a template containing '${newVariant}' (use --force if you intend to overwrite)`
+        ));
+        return abortResponse;
+      }
+      const newVersion = bootstrapVersionFromTemplate(template);
+      const currentVersion = this.currentToolkitInfo.version;
+      if (newVersion < currentVersion) {
+        await this.msg.ioHost.notify(warn(
+          this.msg.action,
+          `Bootstrap stack already at version ${currentVersion}. Not downgrading it to version ${newVersion} (use --force if you intend to downgrade)`
+        ));
+        if (newVersion === 0) {
+          await this.msg.ioHost.notify(warn(
+            this.msg.action,
+            "(Did you set the '@aws-cdk/core:newStyleStackSynthesis' feature flag in cdk.json?)"
+          ));
+        }
+        return abortResponse;
+      }
+    }
+    const outdir = await fs14.mkdtemp(path11.join(os4.tmpdir(), "cdk-bootstrap"));
+    const builder = new import_cx_api6.CloudAssemblyBuilder(outdir);
+    const templateFile = `${this.toolkitStackName}.template.json`;
+    await fs14.writeJson(path11.join(builder.outdir, templateFile), template, {
+      spaces: 2
+    });
+    builder.addArtifact(this.toolkitStackName, {
+      type: import_cloud_assembly_schema2.ArtifactType.AWS_CLOUDFORMATION_STACK,
+      environment: import_cx_api6.EnvironmentUtils.format(this.resolvedEnvironment.account, this.resolvedEnvironment.region),
+      properties: {
+        templateFile,
+        terminationProtection: options.terminationProtection ?? false
+      }
+    });
+    const assembly = builder.buildAssembly();
+    const ret = await deployStack({
+      stack: assembly.getStackByName(this.toolkitStackName),
+      resolvedEnvironment: this.resolvedEnvironment,
+      sdk: this.sdk,
+      sdkProvider: this.sdkProvider,
+      force: options.force,
+      roleArn: options.roleArn,
+      tags: options.tags,
+      deploymentMethod: { method: "change-set", execute: options.execute },
+      parameters,
+      usePreviousParameters: options.usePreviousParameters ?? true,
+      // Obviously we can't need a bootstrap stack to deploy a bootstrap stack
+      envResources: new NoBootstrapStackEnvironmentResources(this.resolvedEnvironment, this.sdk, this.msg)
+    }, this.msg);
+    assertIsSuccessfulDeployStackResult(ret);
+    return ret;
+  }
+};
+function bootstrapVersionFromTemplate(template) {
+  const versionSources = [
+    template.Outputs?.[BOOTSTRAP_VERSION_OUTPUT]?.Value,
+    template.Resources?.[BOOTSTRAP_VERSION_RESOURCE]?.Properties?.Value
+  ];
+  for (const vs of versionSources) {
+    if (typeof vs === "number") {
+      return vs;
+    }
+    if (typeof vs === "string" && !isNaN(parseInt(vs, 10))) {
+      return parseInt(vs, 10);
+    }
+  }
+  return 0;
+}
+function bootstrapVariantFromTemplate(template) {
+  return template.Parameters?.[BOOTSTRAP_VARIANT_PARAMETER]?.Default ?? DEFAULT_BOOTSTRAP_VARIANT;
+}
+
+// ../../aws-cdk/lib/api/bootstrap/legacy-template.ts
+function legacyBootstrapTemplate(params) {
+  return {
+    Description: "The CDK Toolkit Stack. It was created by `cdk bootstrap` and manages resources necessary for managing your Cloud Applications with AWS CDK.",
+    Conditions: {
+      UsePublicAccessBlockConfiguration: {
+        "Fn::Equals": [
+          params.publicAccessBlockConfiguration || params.publicAccessBlockConfiguration === void 0 ? "true" : "false",
+          "true"
+        ]
+      }
+    },
+    Resources: {
+      StagingBucket: {
+        Type: "AWS::S3::Bucket",
+        Properties: {
+          BucketName: params.bucketName,
+          AccessControl: "Private",
+          BucketEncryption: {
+            ServerSideEncryptionConfiguration: [{
+              ServerSideEncryptionByDefault: {
+                SSEAlgorithm: "aws:kms",
+                KMSMasterKeyID: params.kmsKeyId
+              }
+            }]
+          },
+          PublicAccessBlockConfiguration: {
+            "Fn::If": [
+              "UsePublicAccessBlockConfiguration",
+              {
+                BlockPublicAcls: true,
+                BlockPublicPolicy: true,
+                IgnorePublicAcls: true,
+                RestrictPublicBuckets: true
+              },
+              { Ref: "AWS::NoValue" }
+            ]
+          }
+        }
+      },
+      StagingBucketPolicy: {
+        Type: "AWS::S3::BucketPolicy",
+        Properties: {
+          Bucket: { Ref: "StagingBucket" },
+          PolicyDocument: {
+            Id: "AccessControl",
+            Version: "2012-10-17",
+            Statement: [
+              {
+                Sid: "AllowSSLRequestsOnly",
+                Action: "s3:*",
+                Effect: "Deny",
+                Resource: [
+                  { "Fn::Sub": "${StagingBucket.Arn}" },
+                  { "Fn::Sub": "${StagingBucket.Arn}/*" }
+                ],
+                Condition: {
+                  Bool: { "aws:SecureTransport": "false" }
+                },
+                Principal: "*"
+              }
+            ]
+          }
+        }
+      }
+    },
+    Outputs: {
+      [BUCKET_NAME_OUTPUT]: {
+        Description: "The name of the S3 bucket owned by the CDK toolkit stack",
+        Value: { Ref: "StagingBucket" }
+      },
+      [BUCKET_DOMAIN_NAME_OUTPUT]: {
+        Description: "The domain name of the S3 bucket owned by the CDK toolkit stack",
+        Value: { "Fn::GetAtt": ["StagingBucket", "RegionalDomainName"] }
+      }
+    }
+  };
+}
+
+// ../../aws-cdk/lib/api/bootstrap/bootstrap-environment.ts
+var Bootstrapper = class {
+  constructor(source = { source: "default" }, msg) {
+    this.source = source;
+    this.msg = msg;
+  }
+  bootstrapEnvironment(environment, sdkProvider, options = {}) {
+    switch (this.source.source) {
+      case "legacy":
+        return this.legacyBootstrap(environment, sdkProvider, options);
+      case "default":
+        return this.modernBootstrap(environment, sdkProvider, options);
+      case "custom":
+        return this.customBootstrap(environment, sdkProvider, options);
+    }
+  }
+  async showTemplate(json) {
+    const template = await this.loadTemplate();
+    process.stdout.write(`${serializeStructure(template, json)}
+`);
+  }
+  /**
+   * Deploy legacy bootstrap stack
+   *
+   */
+  async legacyBootstrap(environment, sdkProvider, options = {}) {
+    const params = options.parameters ?? {};
+    if (params.trustedAccounts?.length) {
+      throw new ToolkitError("--trust can only be passed for the modern bootstrap experience.");
+    }
+    if (params.cloudFormationExecutionPolicies?.length) {
+      throw new ToolkitError("--cloudformation-execution-policies can only be passed for the modern bootstrap experience.");
+    }
+    if (params.createCustomerMasterKey !== void 0) {
+      throw new ToolkitError("--bootstrap-customer-key can only be passed for the modern bootstrap experience.");
+    }
+    if (params.qualifier) {
+      throw new ToolkitError("--qualifier can only be passed for the modern bootstrap experience.");
+    }
+    const toolkitStackName = options.toolkitStackName ?? DEFAULT_TOOLKIT_STACK_NAME;
+    const current = await BootstrapStack.lookup(sdkProvider, environment, toolkitStackName, this.msg);
+    return current.update(
+      await this.loadTemplate(params),
+      {},
+      {
+        ...options,
+        terminationProtection: options.terminationProtection ?? current.terminationProtection
+      }
+    );
+  }
+  /**
+   * Deploy CI/CD-ready bootstrap stack from template
+   *
+   */
+  async modernBootstrap(environment, sdkProvider, options = {}) {
+    const params = options.parameters ?? {};
+    const bootstrapTemplate = await this.loadTemplate();
+    const toolkitStackName = options.toolkitStackName ?? DEFAULT_TOOLKIT_STACK_NAME;
+    const current = await BootstrapStack.lookup(sdkProvider, environment, toolkitStackName, this.msg);
+    const partition = await current.partition();
+    if (params.createCustomerMasterKey !== void 0 && params.kmsKeyId) {
+      throw new ToolkitError(
+        "You cannot pass '--bootstrap-kms-key-id' and '--bootstrap-customer-key' together. Specify one or the other"
+      );
+    }
+    const allTrusted = /* @__PURE__ */ new Set([
+      ...params.trustedAccounts ?? [],
+      ...params.trustedAccountsForLookup ?? []
+    ]);
+    const invalid = intersection(allTrusted, new Set(params.untrustedAccounts));
+    if (invalid.size > 0) {
+      throw new ToolkitError(`Accounts cannot be both trusted and untrusted. Found: ${[...invalid].join(",")}`);
+    }
+    const removeUntrusted = (accounts) => accounts.filter((acc) => !params.untrustedAccounts?.map(String).includes(String(acc)));
+    const trustedAccounts = removeUntrusted(params.trustedAccounts ?? splitCfnArray(current.parameters.TrustedAccounts));
+    (0, import_console.info)(`Trusted accounts for deployment: ${trustedAccounts.length > 0 ? trustedAccounts.join(", ") : "(none)"}`);
+    const trustedAccountsForLookup = removeUntrusted(
+      params.trustedAccountsForLookup ?? splitCfnArray(current.parameters.TrustedAccountsForLookup)
+    );
+    (0, import_console.info)(
+      `Trusted accounts for lookup: ${trustedAccountsForLookup.length > 0 ? trustedAccountsForLookup.join(", ") : "(none)"}`
+    );
+    const cloudFormationExecutionPolicies = params.cloudFormationExecutionPolicies ?? splitCfnArray(current.parameters.CloudFormationExecutionPolicies);
+    if (trustedAccounts.length === 0 && cloudFormationExecutionPolicies.length === 0) {
+      const implicitPolicy = `arn:${partition}:iam::aws:policy/AdministratorAccess`;
+      await this.msg.ioHost.notify(warn(
+        this.msg.action,
+        `Using default execution policy of '${implicitPolicy}'. Pass '--cloudformation-execution-policies' to customize.`
+      ));
+    } else if (cloudFormationExecutionPolicies.length === 0) {
+      throw new ToolkitError(
+        `Please pass '--cloudformation-execution-policies' when using '--trust' to specify deployment permissions. Try a managed policy of the form 'arn:${partition}:iam::aws:policy/<PolicyName>'.`
+      );
+    } else {
+      (0, import_console.info)(`Execution policies: ${cloudFormationExecutionPolicies.join(", ")}`);
+    }
+    const currentKmsKeyId = current.parameters.FileAssetsBucketKmsKeyId;
+    const kmsKeyId = params.kmsKeyId ?? (params.createCustomerMasterKey === true ? CREATE_NEW_KEY : params.createCustomerMasterKey === false || currentKmsKeyId === void 0 ? USE_AWS_MANAGED_KEY : void 0);
+    const currentPermissionsBoundary = current.parameters.InputPermissionsBoundary || void 0;
+    const inputPolicyName = params.examplePermissionsBoundary ? CDK_BOOTSTRAP_PERMISSIONS_BOUNDARY : params.customPermissionsBoundary;
+    let policyName;
+    if (inputPolicyName) {
+      const sdk = (await sdkProvider.forEnvironment(environment, 1 /* ForWriting */)).sdk;
+      policyName = await this.getPolicyName(environment, sdk, inputPolicyName, partition, params);
+    }
+    if (currentPermissionsBoundary !== policyName) {
+      if (!currentPermissionsBoundary) {
+        await this.msg.ioHost.notify(warn(
+          this.msg.action,
+          `Adding new permissions boundary ${policyName}`
+        ));
+      } else if (!policyName) {
+        await this.msg.ioHost.notify(warn(
+          this.msg.action,
+          `Removing existing permissions boundary ${currentPermissionsBoundary}`
+        ));
+      } else {
+        await this.msg.ioHost.notify(warn(
+          this.msg.action,
+          `Changing permissions boundary from ${currentPermissionsBoundary} to ${policyName}`
+        ));
+      }
+    }
+    return current.update(
+      bootstrapTemplate,
+      {
+        FileAssetsBucketName: params.bucketName,
+        FileAssetsBucketKmsKeyId: kmsKeyId,
+        // Empty array becomes empty string
+        TrustedAccounts: trustedAccounts.join(","),
+        TrustedAccountsForLookup: trustedAccountsForLookup.join(","),
+        CloudFormationExecutionPolicies: cloudFormationExecutionPolicies.join(","),
+        Qualifier: params.qualifier,
+        PublicAccessBlockConfiguration: params.publicAccessBlockConfiguration || params.publicAccessBlockConfiguration === void 0 ? "true" : "false",
+        InputPermissionsBoundary: policyName
+      },
+      {
+        ...options,
+        terminationProtection: options.terminationProtection ?? current.terminationProtection
+      }
+    );
+  }
+  async getPolicyName(environment, sdk, permissionsBoundary, partition, params) {
+    if (permissionsBoundary !== CDK_BOOTSTRAP_PERMISSIONS_BOUNDARY) {
+      this.validatePolicyName(permissionsBoundary);
+      return Promise.resolve(permissionsBoundary);
+    }
+    const arn = await this.getExamplePermissionsBoundary(
+      params.qualifier ?? "hnb659fds",
+      partition,
+      environment.account,
+      sdk
+    );
+    const policyName = arn.split("/").pop();
+    if (!policyName) {
+      throw new ToolkitError("Could not retrieve the example permission boundary!");
+    }
+    return Promise.resolve(policyName);
+  }
+  async getExamplePermissionsBoundary(qualifier, partition, account, sdk) {
+    const iam = sdk.iam();
+    let policyName = `cdk-${qualifier}-permissions-boundary`;
+    const arn = `arn:${partition}:iam::${account}:policy/${policyName}`;
+    try {
+      let getPolicyResp = await iam.getPolicy({ PolicyArn: arn });
+      if (getPolicyResp.Policy) {
+        return arn;
+      }
+    } catch (e) {
+      if (e.name === "NoSuchEntity") {
+      } else {
+        throw e;
+      }
+    }
+    const policyDoc = {
+      Version: "2012-10-17",
+      Statement: [
+        {
+          Action: ["*"],
+          Resource: "*",
+          Effect: "Allow",
+          Sid: "ExplicitAllowAll"
+        },
+        {
+          Condition: {
+            StringEquals: {
+              "iam:PermissionsBoundary": `arn:${partition}:iam::${account}:policy/cdk-${qualifier}-permissions-boundary`
+            }
+          },
+          Action: [
+            "iam:CreateUser",
+            "iam:CreateRole",
+            "iam:PutRolePermissionsBoundary",
+            "iam:PutUserPermissionsBoundary"
+          ],
+          Resource: "*",
+          Effect: "Allow",
+          Sid: "DenyAccessIfRequiredPermBoundaryIsNotBeingApplied"
+        },
+        {
+          Action: [
+            "iam:CreatePolicyVersion",
+            "iam:DeletePolicy",
+            "iam:DeletePolicyVersion",
+            "iam:SetDefaultPolicyVersion"
+          ],
+          Resource: `arn:${partition}:iam::${account}:policy/cdk-${qualifier}-permissions-boundary`,
+          Effect: "Deny",
+          Sid: "DenyPermBoundaryIAMPolicyAlteration"
+        },
+        {
+          Action: ["iam:DeleteUserPermissionsBoundary", "iam:DeleteRolePermissionsBoundary"],
+          Resource: "*",
+          Effect: "Deny",
+          Sid: "DenyRemovalOfPermBoundaryFromAnyUserOrRole"
+        }
+      ]
+    };
+    const request = {
+      PolicyName: policyName,
+      PolicyDocument: JSON.stringify(policyDoc)
+    };
+    const createPolicyResponse = await iam.createPolicy(request);
+    if (createPolicyResponse.Policy?.Arn) {
+      return createPolicyResponse.Policy.Arn;
+    } else {
+      throw new ToolkitError(`Could not retrieve the example permission boundary ${arn}!`);
+    }
+  }
+  validatePolicyName(permissionsBoundary) {
+    const regexp = /[\w+\/=,.@-]+/;
+    const matches = regexp.exec(permissionsBoundary);
+    if (!(matches && matches.length === 1 && matches[0] === permissionsBoundary)) {
+      throw new ToolkitError(`The permissions boundary name ${permissionsBoundary} does not match the IAM conventions.`);
+    }
+  }
+  async customBootstrap(environment, sdkProvider, options = {}) {
+    const version = bootstrapVersionFromTemplate(await this.loadTemplate());
+    if (version === 0) {
+      return this.legacyBootstrap(environment, sdkProvider, options);
+    } else {
+      return this.modernBootstrap(environment, sdkProvider, options);
+    }
+  }
+  async loadTemplate(params = {}) {
+    switch (this.source.source) {
+      case "custom":
+        return loadStructuredFile(this.source.templateFile);
+      case "default":
+        return loadStructuredFile(path12.join(bundledPackageRootDir(__dirname), "lib", "api", "bootstrap", "bootstrap-template.yaml"));
+      case "legacy":
+        return legacyBootstrapTemplate(params);
+    }
+  }
+};
+var USE_AWS_MANAGED_KEY = "AWS_MANAGED_KEY";
+var CREATE_NEW_KEY = "";
+var CDK_BOOTSTRAP_PERMISSIONS_BOUNDARY = "CDK_BOOTSTRAP_PERMISSIONS_BOUNDARY";
+function splitCfnArray(xs) {
+  if (xs === "" || xs === void 0) {
+    return [];
+  }
+  return xs.split(",");
+}
+function intersection(xs, ys) {
+  return new Set(Array.from(xs).filter((x) => ys.has(x)));
 }
 
 // ../../aws-cdk/lib/context-providers/index.ts
@@ -8163,27 +8823,6 @@ var AZContextProviderPlugin = class {
   }
 };
 
-// ../../aws-cdk/lib/util/json.ts
-function getResultObj(jsonObject, identifier, propertiesToReturn) {
-  const propsObj = {};
-  propertiesToReturn.forEach((propName) => {
-    Object.assign(propsObj, { [propName]: findJsonValue(jsonObject, propName) });
-  });
-  Object.assign(propsObj, { ["Identifier"]: identifier });
-  return propsObj;
-}
-function findJsonValue(jsonObject, path12) {
-  const paths = path12.split(".");
-  let obj = jsonObject;
-  paths.forEach((p) => {
-    obj = obj[p];
-    if (obj === void 0) {
-      throw new TypeError(`Cannot read field ${path12}. ${p} is not found.`);
-    }
-  });
-  return obj;
-}
-
 // ../../aws-cdk/lib/context-providers/cc-api-provider.ts
 var CcApiContextProviderPlugin = class {
   constructor(aws) {
@@ -8279,7 +8918,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;
   }
@@ -8416,7 +9055,7 @@ var KeyContextProviderPlugin = class {
 };
 
 // ../../aws-cdk/lib/context-providers/load-balancers.ts
-var import_cx_api6 = require("@aws-cdk/cx-api");
+var import_cx_api7 = require("@aws-cdk/cx-api");
 var LoadBalancerContextProviderPlugin = class {
   constructor(aws) {
     this.aws = aws;
@@ -8426,7 +9065,7 @@ var LoadBalancerContextProviderPlugin = class {
       throw new ContextProviderError("The load balancer lookup query must specify either `loadBalancerArn` or `loadBalancerTags`");
     }
     const loadBalancer = await (await LoadBalancerProvider.getClient(this.aws, query)).getLoadBalancer();
-    const ipAddressType = loadBalancer.IpAddressType === "ipv4" ? import_cx_api6.LoadBalancerIpAddressType.IPV4 : import_cx_api6.LoadBalancerIpAddressType.DUAL_STACK;
+    const ipAddressType = loadBalancer.IpAddressType === "ipv4" ? import_cx_api7.LoadBalancerIpAddressType.IPV4 : import_cx_api7.LoadBalancerIpAddressType.DUAL_STACK;
     return {
       loadBalancerArn: loadBalancer.LoadBalancerArn,
       loadBalancerCanonicalHostedZoneId: loadBalancer.CanonicalHostedZoneId,
@@ -8673,7 +9312,7 @@ var SSMContextProviderPlugin = class {
 };
 
 // ../../aws-cdk/lib/context-providers/vpcs.ts
-var import_cx_api7 = require("@aws-cdk/cx-api");
+var import_cx_api8 = require("@aws-cdk/cx-api");
 var VpcNetworkContextProviderPlugin = class {
   constructor(aws) {
     this.aws = aws;
@@ -8910,11 +9549,11 @@ function groupAsymmetricSubnets(subnets) {
 function subnetTypeToVpcSubnetType(type) {
   switch (type) {
     case "Isolated" /* Isolated */:
-      return import_cx_api7.VpcSubnetGroupType.ISOLATED;
+      return import_cx_api8.VpcSubnetGroupType.ISOLATED;
     case "Private" /* Private */:
-      return import_cx_api7.VpcSubnetGroupType.PRIVATE;
+      return import_cx_api8.VpcSubnetGroupType.PRIVATE;
     case "Public" /* Public */:
-      return import_cx_api7.VpcSubnetGroupType.PUBLIC;
+      return import_cx_api8.VpcSubnetGroupType.PUBLIC;
   }
 }
 function isValidSubnetType(val) {
@@ -9008,13 +9647,13 @@ var availableContextProviders = {
 
 // ../../aws-cdk/lib/api/util/rwlock.ts
 var import_fs = require("fs");
-var path10 = __toESM(require("path"));
+var path13 = __toESM(require("path"));
 var RWLock = class {
   constructor(directory) {
     this.directory = directory;
     this.readCounter = 0;
     this.pidString = `${process.pid}`;
-    this.writerFile = path10.join(this.directory, "synth.lock");
+    this.writerFile = path13.join(this.directory, "synth.lock");
   }
   /**
    * Acquire a writer lock.
@@ -9056,7 +9695,7 @@ var RWLock = class {
    * is incremented "atomically" from the point of view of this PID.).
    */
   readerFile() {
-    return path10.join(this.directory, `read.${this.pidString}.${++this.readCounter}.lock`);
+    return path13.join(this.directory, `read.${this.pidString}.${++this.readCounter}.lock`);
   }
   /**
    * Do the actual acquiring of a read lock.
@@ -9113,7 +9752,7 @@ var RWLock = class {
         if (processExists(pid)) {
           ret.push(pid);
         } else {
-          await deleteFile(path10.join(this.directory, fname));
+          await deleteFile(path13.join(this.directory, fname));
         }
       }
     }
@@ -9132,7 +9771,7 @@ async function readFileIfExists(filename) {
 }
 var tmpCounter = 0;
 async function writeFileAtomic(filename, contents) {
-  await import_fs.promises.mkdir(path10.dirname(filename), { recursive: true });
+  await import_fs.promises.mkdir(path13.dirname(filename), { recursive: true });
   const tmpFile = `${filename}.${process.pid}_${++tmpCounter}`;
   await import_fs.promises.writeFile(tmpFile, contents, { encoding: "utf-8" });
   await import_fs.promises.rename(tmpFile, filename);
@@ -9157,8 +9796,8 @@ 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 import_cx_api9 = require("@aws-cdk/cx-api");
+var chalk16 = __toESM(require("chalk"));
 var import_minimatch = require("minimatch");
 var semver5 = __toESM(require("semver"));
 var ExtendedStackSelection = /* @__PURE__ */ ((ExtendedStackSelection2) => {
@@ -9320,15 +9959,15 @@ var StackCollection = class _StackCollection {
     for (const stack of this.stackArtifacts) {
       for (const message of stack.messages) {
         switch (message.level) {
-          case import_cx_api8.SynthesisMessageLevel.WARNING:
+          case import_cx_api9.SynthesisMessageLevel.WARNING:
             warnings = true;
             await logger("warn", message);
             break;
-          case import_cx_api8.SynthesisMessageLevel.ERROR:
+          case import_cx_api9.SynthesisMessageLevel.ERROR:
             errors = true;
             await logger("error", message);
             break;
-          case import_cx_api8.SynthesisMessageLevel.INFO:
+          case import_cx_api9.SynthesisMessageLevel.INFO:
             await logger("info", message);
             break;
         }
@@ -9363,7 +10002,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 +10021,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) {
@@ -9392,10 +10031,10 @@ function sanitizePatterns(patterns) {
 }
 
 // ../../aws-cdk/lib/api/cxapp/exec.ts
-var path11 = __toESM(require("path"));
+var path14 = __toESM(require("path"));
 var cxschema4 = __toESM(require("@aws-cdk/cloud-assembly-schema"));
 var cxapi5 = __toESM(require("@aws-cdk/cx-api"));
-var fs14 = __toESM(require("fs-extra"));
+var fs16 = __toESM(require("fs-extra"));
 var semver6 = __toESM(require("semver"));
 async function prepareDefaultEnvironment(aws, logFn = debug) {
   const env = {};
@@ -9451,14 +10090,14 @@ async function guessExecutable(app) {
   if (commandLine.length === 1) {
     let fstat;
     try {
-      fstat = await fs14.stat(commandLine[0]);
+      fstat = await fs16.stat(commandLine[0]);
     } catch {
       debug(`Not a file: '${commandLine[0]}'. Using '${commandLine}' as command-line`);
       return commandLine;
     }
-    const isExecutable = (fstat.mode & fs14.constants.X_OK) !== 0;
+    const isExecutable = (fstat.mode & fs16.constants.X_OK) !== 0;
     const isWindows = process.platform === "win32";
-    const handler = EXTENSION_MAP.get(path11.extname(commandLine[0]));
+    const handler = EXTENSION_MAP.get(path14.extname(commandLine[0]));
     if (handler && (!isExecutable || isWindows)) {
       return handler(commandLine[0]);
     }
@@ -9472,6 +10111,7 @@ function spaceAvailableForContext(env, limit) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  Bootstrapper,
   CliIoHost,
   CloudAssembly,
   CloudWatchLogEventMonitor,
@@ -9487,26 +10127,19 @@ function spaceAvailableForContext(env, limit) {
   ResourceMigrator,
   SdkProvider,
   Settings,
-  StackActivityProgress,
   StackCollection,
   WorkGraphBuilder,
   contextproviders,
   findCloudWatchLogGroups,
-  formatErrorMessage,
   formatSdkLoggerContent,
-  formatTime,
   guessExecutable,
   loadTree,
-  obscureTemplate,
   prepareContext,
   prepareDefaultEnvironment,
   sanitizePatterns,
-  serializeStructure,
   some,
   spaceAvailableForContext,
-  splitBySize,
   tagsForStack,
-  validateSnsTopicArn,
   versionNumber
 });
 //# sourceMappingURL=aws-cdk.js.map