aws-cdk 2.1029.4 → 2.1031.0

package/lib/index.js

@@ -3478,7 +3478,7 @@ var require_semver2 = __commonJS({
 // ../@aws-cdk/cloud-assembly-schema/cli-version.json
 var require_cli_version = __commonJS({
   "../@aws-cdk/cloud-assembly-schema/cli-version.json"(exports2, module2) {
-    module2.exports = { version: "2.1029.4" };
+    module2.exports = { version: "2.1031.0" };
   }
 });
 
@@ -6781,7 +6781,7 @@ var require_cloud_assembly = __commonJS({
     var jsiiDeprecationWarnings = require_warnings_jsii();
     var JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
     var fs43 = require("fs");
-    var os13 = require("os");
+    var os14 = require("os");
     var path38 = require("path");
     var cloudformation_artifact_1 = require_cloudformation_artifact();
     var nested_cloud_assembly_artifact_1 = require_nested_cloud_assembly_artifact();
@@ -7094,7 +7094,7 @@ var require_cloud_assembly = __commonJS({
     }
     __name(ignore, "ignore");
     function determineOutputDirectory(outdir) {
-      return outdir ?? fs43.mkdtempSync(path38.join(fs43.realpathSync(os13.tmpdir()), "cdk.out"));
+      return outdir ?? fs43.mkdtempSync(path38.join(fs43.realpathSync(os14.tmpdir()), "cdk.out"));
     }
     __name(determineOutputDirectory, "determineOutputDirectory");
     function ensureDirSync(dir) {
@@ -62467,7 +62467,7 @@ var require_dist_cjs2 = __commonJS({
       Fields: /* @__PURE__ */ __name(() => Fields, "Fields"),
       HttpRequest: /* @__PURE__ */ __name(() => HttpRequest10, "HttpRequest"),
       HttpResponse: /* @__PURE__ */ __name(() => HttpResponse4, "HttpResponse"),
-      IHttpRequest: /* @__PURE__ */ __name(() => import_types5.HttpRequest, "IHttpRequest"),
+      IHttpRequest: /* @__PURE__ */ __name(() => import_types6.HttpRequest, "IHttpRequest"),
       getHttpHandlerExtensionConfiguration: /* @__PURE__ */ __name(() => getHttpHandlerExtensionConfiguration3, "getHttpHandlerExtensionConfiguration"),
       isValidHostname: /* @__PURE__ */ __name(() => isValidHostname, "isValidHostname"),
       resolveHttpHandlerRuntimeConfig: /* @__PURE__ */ __name(() => resolveHttpHandlerRuntimeConfig3, "resolveHttpHandlerRuntimeConfig")
@@ -62494,7 +62494,7 @@ var require_dist_cjs2 = __commonJS({
         httpHandler: httpHandlerExtensionConfiguration.httpHandler()
       };
     }, "resolveHttpHandlerRuntimeConfig");
-    var import_types5 = require_dist_cjs();
+    var import_types6 = require_dist_cjs();
     var Field = class {
       static {
         __name(this, "Field");
@@ -62502,7 +62502,7 @@ var require_dist_cjs2 = __commonJS({
       static {
         __name2(this, "Field");
       }
-      constructor({ name, kind = import_types5.FieldPosition.HEADER, values = [] }) {
+      constructor({ name, kind = import_types6.FieldPosition.HEADER, values = [] }) {
         this.name = name;
         this.kind = kind;
         this.values = values;
@@ -63042,8 +63042,8 @@ var require_dist_cjs6 = __commonJS({
       normalizeProvider: /* @__PURE__ */ __name(() => normalizeProvider4, "normalizeProvider")
     });
     module2.exports = __toCommonJS2(index_exports);
-    var import_types5 = require_dist_cjs();
-    var getSmithyContext9 = /* @__PURE__ */ __name2((context) => context[import_types5.SMITHY_CONTEXT_KEY] || (context[import_types5.SMITHY_CONTEXT_KEY] = {}), "getSmithyContext");
+    var import_types6 = require_dist_cjs();
+    var getSmithyContext9 = /* @__PURE__ */ __name2((context) => context[import_types6.SMITHY_CONTEXT_KEY] || (context[import_types6.SMITHY_CONTEXT_KEY] = {}), "getSmithyContext");
     var normalizeProvider4 = /* @__PURE__ */ __name2((input) => {
       if (typeof input === "function") return input;
       const promisified = Promise.resolve(input);
@@ -72765,7 +72765,7 @@ var require_dist_cjs26 = __commonJS({
       }
     };
     var import_protocols12 = (init_protocols(), __toCommonJS(protocols_exports));
-    var import_types5 = require_dist_cjs();
+    var import_types6 = require_dist_cjs();
     var import_schema25 = (init_schema4(), __toCommonJS(schema_exports));
     var SENSITIVE_STRING3 = "***SensitiveInformation***";
     function schemaLogFilter(schema, data3) {
@@ -72841,7 +72841,7 @@ var require_dist_cjs26 = __commonJS({
           commandName,
           inputFilterSensitiveLog,
           outputFilterSensitiveLog,
-          [import_types5.SMITHY_CONTEXT_KEY]: {
+          [import_types6.SMITHY_CONTEXT_KEY]: {
             commandInstance: this,
             ...smithyContext
           },
@@ -73124,8 +73124,8 @@ var require_dist_cjs26 = __commonJS({
     }, "emitWarningIfUnsupportedVersion");
     var getChecksumConfiguration = /* @__PURE__ */ __name2((runtimeConfig) => {
       const checksumAlgorithms = [];
-      for (const id in import_types5.AlgorithmId) {
-        const algorithmId = import_types5.AlgorithmId[id];
+      for (const id in import_types6.AlgorithmId) {
+        const algorithmId = import_types6.AlgorithmId[id];
         if (runtimeConfig[algorithmId] === void 0) {
           continue;
         }
@@ -77291,17 +77291,17 @@ var require_dist_cjs32 = __commonJS({
     var getProfileName = /* @__PURE__ */ __name2((init) => init.profile || process.env[ENV_PROFILE] || DEFAULT_PROFILE, "getProfileName");
     __reExport(index_exports, require_getSSOTokenFilepath(), module2.exports);
     var import_getSSOTokenFromFile2 = require_getSSOTokenFromFile();
-    var import_types5 = require_dist_cjs();
+    var import_types6 = require_dist_cjs();
     var getConfigData = /* @__PURE__ */ __name2((data3) => Object.entries(data3).filter(([key]) => {
       const indexOfSeparator = key.indexOf(CONFIG_PREFIX_SEPARATOR);
       if (indexOfSeparator === -1) {
         return false;
       }
-      return Object.values(import_types5.IniSectionType).includes(key.substring(0, indexOfSeparator));
+      return Object.values(import_types6.IniSectionType).includes(key.substring(0, indexOfSeparator));
     }).reduce(
       (acc, [key, value]) => {
         const indexOfSeparator = key.indexOf(CONFIG_PREFIX_SEPARATOR);
-        const updatedKey = key.substring(0, indexOfSeparator) === import_types5.IniSectionType.PROFILE ? key.substring(indexOfSeparator + 1) : key;
+        const updatedKey = key.substring(0, indexOfSeparator) === import_types6.IniSectionType.PROFILE ? key.substring(indexOfSeparator + 1) : key;
         acc[updatedKey] = value;
         return acc;
       },
@@ -77334,7 +77334,7 @@ var require_dist_cjs32 = __commonJS({
           const matches = prefixKeyRegex.exec(sectionName);
           if (matches) {
             const [, prefix2, , name] = matches;
-            if (Object.values(import_types5.IniSectionType).includes(prefix2)) {
+            if (Object.values(import_types6.IniSectionType).includes(prefix2)) {
               currentSection = [prefix2, name].join(CONFIG_PREFIX_SEPARATOR);
             }
           } else {
@@ -77393,7 +77393,7 @@ var require_dist_cjs32 = __commonJS({
         credentialsFile: parsedFiles[1]
       };
     }, "loadSharedConfigFiles");
-    var getSsoSessionData = /* @__PURE__ */ __name2((data3) => Object.entries(data3).filter(([key]) => key.startsWith(import_types5.IniSectionType.SSO_SESSION + CONFIG_PREFIX_SEPARATOR)).reduce((acc, [key, value]) => ({ ...acc, [key.substring(key.indexOf(CONFIG_PREFIX_SEPARATOR) + 1)]: value }), {}), "getSsoSessionData");
+    var getSsoSessionData = /* @__PURE__ */ __name2((data3) => Object.entries(data3).filter(([key]) => key.startsWith(import_types6.IniSectionType.SSO_SESSION + CONFIG_PREFIX_SEPARATOR)).reduce((acc, [key, value]) => ({ ...acc, [key.substring(key.indexOf(CONFIG_PREFIX_SEPARATOR) + 1)]: value }), {}), "getSsoSessionData");
     var import_slurpFile2 = require_slurpFile();
     var swallowError2 = /* @__PURE__ */ __name2(() => ({}), "swallowError");
     var loadSsoSessionData = /* @__PURE__ */ __name2(async (init = {}) => (0, import_slurpFile2.slurpFile)(init.configFilepath ?? getConfigFilepath()).then(parseIni).then(getSsoSessionData).catch(swallowError2), "loadSsoSessionData");
@@ -111905,13 +111905,13 @@ var require_dist_cjs78 = __commonJS({
     var index_exports = {};
     __export2(index_exports, {
       AbortController: /* @__PURE__ */ __name(() => AbortController2, "AbortController"),
-      AbortHandler: /* @__PURE__ */ __name(() => import_types5.AbortHandler, "AbortHandler"),
+      AbortHandler: /* @__PURE__ */ __name(() => import_types6.AbortHandler, "AbortHandler"),
       AbortSignal: /* @__PURE__ */ __name(() => AbortSignal2, "AbortSignal"),
-      IAbortController: /* @__PURE__ */ __name(() => import_types5.AbortController, "IAbortController"),
-      IAbortSignal: /* @__PURE__ */ __name(() => import_types5.AbortSignal, "IAbortSignal")
+      IAbortController: /* @__PURE__ */ __name(() => import_types6.AbortController, "IAbortController"),
+      IAbortSignal: /* @__PURE__ */ __name(() => import_types6.AbortSignal, "IAbortSignal")
     });
     module2.exports = __toCommonJS2(index_exports);
-    var import_types5 = require_dist_cjs();
+    var import_types6 = require_dist_cjs();
     var AbortSignal2 = class {
       static {
         __name(this, "AbortSignal");
@@ -113760,7 +113760,7 @@ var require_has_flag = __commonJS({
 var require_supports_color = __commonJS({
   "../../node_modules/supports-color/index.js"(exports2, module2) {
     "use strict";
-    var os13 = require("os");
+    var os14 = require("os");
     var tty = require("tty");
     var hasFlag = require_has_flag();
     var { env: env2 } = process;
@@ -113809,7 +113809,7 @@ var require_supports_color = __commonJS({
         return min;
       }
       if (process.platform === "win32") {
-        const osRelease = os13.release().split(".");
+        const osRelease = os14.release().split(".");
         if (Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) {
           return Number(osRelease[2]) >= 14931 ? 3 : 2;
         }
@@ -123645,7 +123645,7 @@ var init_messages = __esm({
         description: "Refactor result",
         interface: "RefactorResult"
       }),
-      CDK_TOOLKIT_I8910: question({
+      CDK_TOOLKIT_I8910: confirm({
         code: "CDK_TOOLKIT_I8910",
         description: "Confirm refactor",
         interface: "ConfirmationRequest"
@@ -330532,7 +330532,7 @@ var require_constants7 = __commonJS({
     "use strict";
     var { sep: sep5 } = require("path");
     var { platform: platform3 } = process;
-    var os13 = require("os");
+    var os14 = require("os");
     exports2.EV_ALL = "all";
     exports2.EV_READY = "ready";
     exports2.EV_ADD = "add";
@@ -330586,7 +330586,7 @@ var require_constants7 = __commonJS({
     exports2.isWindows = platform3 === "win32";
     exports2.isMacos = platform3 === "darwin";
     exports2.isLinux = platform3 === "linux";
-    exports2.isIBMi = os13.type() === "OS400";
+    exports2.isIBMi = os14.type() === "OS400";
   }
 });
 
@@ -335430,7 +335430,7 @@ ${deployResult.stackArn}`));
             if (options.dryRun || context.mappings.length === 0 || context.ambiguousPaths.length > 0) {
               continue;
             }
-            if (process.stdout.isTTY && !await confirm4(options.force ?? false)) {
+            if (process.stdout.isTTY && !await confirm3(options.force ?? false)) {
               await ioHelper.defaults.info(chalk23.red(`Refactoring canceled for environment aws://${environment.account}/${environment.region}
 `));
               continue;
@@ -335472,17 +335472,16 @@ ${deployResult.stackArn}`));
           throw new ToolkitError(`Cannot find resource in location ${location}`);
         }
         __name(getResourceLocation, "getResourceLocation");
-        async function confirm4(force) {
+        async function confirm3(force) {
           if (force) {
             return true;
           }
           const question2 = "Do you wish to refactor these resources?";
-          const response = await ioHelper.requestResponse(IO.CDK_TOOLKIT_I8910.req(question2, {
-            responseDescription: "[Y]es/[n]o"
-          }, "y"));
-          return ["y", "yes"].includes(response.toLowerCase());
+          return ioHelper.requestResponse(IO.CDK_TOOLKIT_I8910.req(question2, {
+            motivation: "User input is needed"
+          }));
         }
-        __name(confirm4, "confirm");
+        __name(confirm3, "confirm");
         function formatError(error5) {
           try {
             const payload2 = JSON.parse(error5.message);
@@ -337518,384 +337517,6 @@ var require_lib13 = __commonJS({
   }
 });
 
-// ../../node_modules/promptly/node_modules/mute-stream/mute.js
-var require_mute = __commonJS({
-  "../../node_modules/promptly/node_modules/mute-stream/mute.js"(exports2, module2) {
-    var Stream2 = require("stream");
-    module2.exports = MuteStream;
-    function MuteStream(opts) {
-      Stream2.apply(this);
-      opts = opts || {};
-      this.writable = this.readable = true;
-      this.muted = false;
-      this.on("pipe", this._onpipe);
-      this.replace = opts.replace;
-      this._prompt = opts.prompt || null;
-      this._hadControl = false;
-    }
-    __name(MuteStream, "MuteStream");
-    MuteStream.prototype = Object.create(Stream2.prototype);
-    Object.defineProperty(MuteStream.prototype, "constructor", {
-      value: MuteStream,
-      enumerable: false
-    });
-    MuteStream.prototype.mute = function() {
-      this.muted = true;
-    };
-    MuteStream.prototype.unmute = function() {
-      this.muted = false;
-    };
-    Object.defineProperty(MuteStream.prototype, "_onpipe", {
-      value: onPipe,
-      enumerable: false,
-      writable: true,
-      configurable: true
-    });
-    function onPipe(src) {
-      this._src = src;
-    }
-    __name(onPipe, "onPipe");
-    Object.defineProperty(MuteStream.prototype, "isTTY", {
-      get: getIsTTY,
-      set: setIsTTY,
-      enumerable: true,
-      configurable: true
-    });
-    function getIsTTY() {
-      return this._dest ? this._dest.isTTY : this._src ? this._src.isTTY : false;
-    }
-    __name(getIsTTY, "getIsTTY");
-    function setIsTTY(isTTY2) {
-      Object.defineProperty(this, "isTTY", {
-        value: isTTY2,
-        enumerable: true,
-        writable: true,
-        configurable: true
-      });
-    }
-    __name(setIsTTY, "setIsTTY");
-    Object.defineProperty(MuteStream.prototype, "rows", {
-      get: /* @__PURE__ */ __name(function() {
-        return this._dest ? this._dest.rows : this._src ? this._src.rows : void 0;
-      }, "get"),
-      enumerable: true,
-      configurable: true
-    });
-    Object.defineProperty(MuteStream.prototype, "columns", {
-      get: /* @__PURE__ */ __name(function() {
-        return this._dest ? this._dest.columns : this._src ? this._src.columns : void 0;
-      }, "get"),
-      enumerable: true,
-      configurable: true
-    });
-    MuteStream.prototype.pipe = function(dest, options) {
-      this._dest = dest;
-      return Stream2.prototype.pipe.call(this, dest, options);
-    };
-    MuteStream.prototype.pause = function() {
-      if (this._src) return this._src.pause();
-    };
-    MuteStream.prototype.resume = function() {
-      if (this._src) return this._src.resume();
-    };
-    MuteStream.prototype.write = function(c3) {
-      if (this.muted) {
-        if (!this.replace) return true;
-        if (c3.match(/^\u001b/)) {
-          if (c3.indexOf(this._prompt) === 0) {
-            c3 = c3.substr(this._prompt.length);
-            c3 = c3.replace(/./g, this.replace);
-            c3 = this._prompt + c3;
-          }
-          this._hadControl = true;
-          return this.emit("data", c3);
-        } else {
-          if (this._prompt && this._hadControl && c3.indexOf(this._prompt) === 0) {
-            this._hadControl = false;
-            this.emit("data", this._prompt);
-            c3 = c3.substr(this._prompt.length);
-          }
-          c3 = c3.toString().replace(/./g, this.replace);
-        }
-      }
-      this.emit("data", c3);
-    };
-    MuteStream.prototype.end = function(c3) {
-      if (this.muted) {
-        if (c3 && this.replace) {
-          c3 = c3.toString().replace(/./g, this.replace);
-        } else {
-          c3 = null;
-        }
-      }
-      if (c3) this.emit("data", c3);
-      this.emit("end");
-    };
-    function proxy(fn) {
-      return function() {
-        var d3 = this._dest;
-        var s3 = this._src;
-        if (d3 && d3[fn]) d3[fn].apply(d3, arguments);
-        if (s3 && s3[fn]) s3[fn].apply(s3, arguments);
-      };
-    }
-    __name(proxy, "proxy");
-    MuteStream.prototype.destroy = proxy("destroy");
-    MuteStream.prototype.destroySoon = proxy("destroySoon");
-    MuteStream.prototype.close = proxy("close");
-  }
-});
-
-// ../../node_modules/promptly/node_modules/read/lib/read.js
-var require_read = __commonJS({
-  "../../node_modules/promptly/node_modules/read/lib/read.js"(exports2, module2) {
-    module2.exports = read;
-    var readline = require("readline");
-    var Mute = require_mute();
-    function read(opts, cb) {
-      if (opts.num) {
-        throw new Error("read() no longer accepts a char number limit");
-      }
-      if (typeof opts.default !== "undefined" && typeof opts.default !== "string" && typeof opts.default !== "number") {
-        throw new Error("default value must be string or number");
-      }
-      var input = opts.input || process.stdin;
-      var output = opts.output || process.stdout;
-      var prompt2 = (opts.prompt || "").trim() + " ";
-      var silent = opts.silent;
-      var editDef = false;
-      var timeout = opts.timeout;
-      var def = opts.default || "";
-      if (def) {
-        if (silent) {
-          prompt2 += "(<default hidden>) ";
-        } else if (opts.edit) {
-          editDef = true;
-        } else {
-          prompt2 += "(" + def + ") ";
-        }
-      }
-      var terminal = !!(opts.terminal || output.isTTY);
-      var m3 = new Mute({ replace: opts.replace, prompt: prompt2 });
-      m3.pipe(output, { end: false });
-      output = m3;
-      var rlOpts = { input, output, terminal };
-      if (process.version.match(/^v0\.6/)) {
-        var rl = readline.createInterface(rlOpts.input, rlOpts.output);
-      } else {
-        var rl = readline.createInterface(rlOpts);
-      }
-      output.unmute();
-      rl.setPrompt(prompt2);
-      rl.prompt();
-      if (silent) {
-        output.mute();
-      } else if (editDef) {
-        rl.line = def;
-        rl.cursor = def.length;
-        rl._refreshLine();
-      }
-      var called = false;
-      rl.on("line", onLine);
-      rl.on("error", onError);
-      rl.on("SIGINT", function() {
-        rl.close();
-        onError(new Error("canceled"));
-      });
-      var timer;
-      if (timeout) {
-        timer = setTimeout(function() {
-          onError(new Error("timed out"));
-        }, timeout);
-      }
-      function done() {
-        called = true;
-        rl.close();
-        if (process.version.match(/^v0\.6/)) {
-          rl.input.removeAllListeners("data");
-          rl.input.removeAllListeners("keypress");
-          rl.input.pause();
-        }
-        clearTimeout(timer);
-        output.mute();
-        output.end();
-      }
-      __name(done, "done");
-      function onError(er) {
-        if (called) return;
-        done();
-        return cb(er);
-      }
-      __name(onError, "onError");
-      function onLine(line) {
-        if (called) return;
-        if (silent && terminal) {
-          output.unmute();
-          output.write("\r\n");
-        }
-        done();
-        line = line.replace(/\r?\n$/, "");
-        var isDefault = !!(editDef && line === def);
-        if (def && !line) {
-          isDefault = true;
-          line = def;
-        }
-        cb(null, line, isDefault);
-      }
-      __name(onLine, "onLine");
-    }
-    __name(read, "read");
-  }
-});
-
-// ../../node_modules/promptly/lib/prompt.js
-var require_prompt = __commonJS({
-  "../../node_modules/promptly/lib/prompt.js"(exports2, module2) {
-    "use strict";
-    var { EOL } = require("os");
-    var { promisify: promisify4 } = require("util");
-    var read = promisify4(require_read());
-    async function prompt2(message2, options) {
-      let value;
-      try {
-        value = await read({
-          prompt: message2,
-          silent: options.silent,
-          replace: options.replace,
-          input: options.input,
-          output: options.output,
-          timeout: options.timeout
-        });
-      } catch (err) {
-        if (err.message !== "timed out" || options.default === void 0 || !options.useDefaultOnTimeout) {
-          throw Object.assign(new Error(err.message), { code: "TIMEDOUT" });
-        }
-        value = options.default;
-      }
-      if (options.trim) {
-        value = value.trim();
-      }
-      if (!value) {
-        if (options.default === void 0) {
-          return prompt2(message2, options);
-        }
-        value = options.default;
-      }
-      try {
-        for (const i3 in options.validator) {
-          value = await options.validator[i3](value);
-        }
-      } catch (err) {
-        if (options.retry) {
-          err.message && options.output.write(err.message + EOL);
-          return prompt2(message2, options);
-        }
-        throw err;
-      }
-      return value;
-    }
-    __name(prompt2, "prompt");
-    module2.exports = prompt2;
-  }
-});
-
-// ../../node_modules/promptly/lib/getOptions.js
-var require_getOptions = __commonJS({
-  "../../node_modules/promptly/lib/getOptions.js"(exports2, module2) {
-    "use strict";
-    function getOptions(options) {
-      options = {
-        // Own options
-        validator: void 0,
-        retry: true,
-        trim: true,
-        default: void 0,
-        useDefaultOnTimeout: false,
-        // `read` package options
-        silent: false,
-        replace: "",
-        input: process.stdin,
-        output: process.stdout,
-        timeout: 0,
-        ...options
-      };
-      if (options.default !== void 0 && typeof options.default !== "string") {
-        throw new Error("The default option value must be a string");
-      }
-      if (!Array.isArray(options.validator)) {
-        options.validator = options.validator ? [options.validator] : [];
-      }
-      return options;
-    }
-    __name(getOptions, "getOptions");
-    module2.exports = getOptions;
-  }
-});
-
-// ../../node_modules/promptly/index.js
-var require_promptly = __commonJS({
-  "../../node_modules/promptly/index.js"(exports2, module2) {
-    "use strict";
-    var prompt2 = require_prompt();
-    var getOptions = require_getOptions();
-    var promptly3 = module2.exports;
-    promptly3.prompt = (message2, options) => {
-      options = getOptions(options);
-      return prompt2(message2, options);
-    };
-    promptly3.password = (message2, options) => {
-      options = getOptions({
-        silent: true,
-        // Hide password chars
-        trim: false,
-        // Do not trim so that spaces can be part of the password
-        default: "",
-        // Allow empty passwords
-        ...options
-      });
-      return prompt2(message2, options);
-    };
-    promptly3.confirm = (message2, options) => {
-      options = getOptions({
-        trim: false,
-        // Do not trim so that only exact matches pass the validator
-        ...options
-      });
-      options.validator.unshift((value) => {
-        value = value.toLowerCase();
-        switch (value) {
-          case "y":
-          case "yes":
-          case "1":
-            return true;
-          case "n":
-          case "no":
-          case "0":
-            return false;
-          default:
-            throw new Error(`Invalid choice: ${value}`);
-        }
-      });
-      return prompt2(message2, options);
-    };
-    promptly3.choose = (message2, choices, options) => {
-      options = getOptions({
-        trim: false,
-        // Do not trim so that only exact matches pass the validator
-        ...options
-      });
-      options.validator.unshift((value) => {
-        const index = choices.findIndex((choice) => value == choice);
-        if (index === -1) {
-          throw new Error(`Invalid choice: ${value}`);
-        }
-        return choices[index];
-      });
-      return prompt2(message2, options);
-    };
-  }
-});
-
 // node_modules/uuid/dist/esm/stringify.js
 function unsafeStringify3(arr, offset = 0) {
   return (byteToHex3[arr[offset + 0]] + byteToHex3[arr[offset + 1]] + byteToHex3[arr[offset + 2]] + byteToHex3[arr[offset + 3]] + "-" + byteToHex3[arr[offset + 4]] + byteToHex3[arr[offset + 5]] + "-" + byteToHex3[arr[offset + 6]] + byteToHex3[arr[offset + 7]] + "-" + byteToHex3[arr[offset + 8]] + byteToHex3[arr[offset + 9]] + "-" + byteToHex3[arr[offset + 10]] + byteToHex3[arr[offset + 11]] + byteToHex3[arr[offset + 12]] + byteToHex3[arr[offset + 13]] + byteToHex3[arr[offset + 14]] + byteToHex3[arr[offset + 15]]).toLowerCase();
@@ -337980,6 +337601,384 @@ var init_esm10 = __esm({
   }
 });
 
+// ../../node_modules/promptly/node_modules/mute-stream/mute.js
+var require_mute = __commonJS({
+  "../../node_modules/promptly/node_modules/mute-stream/mute.js"(exports2, module2) {
+    var Stream2 = require("stream");
+    module2.exports = MuteStream;
+    function MuteStream(opts) {
+      Stream2.apply(this);
+      opts = opts || {};
+      this.writable = this.readable = true;
+      this.muted = false;
+      this.on("pipe", this._onpipe);
+      this.replace = opts.replace;
+      this._prompt = opts.prompt || null;
+      this._hadControl = false;
+    }
+    __name(MuteStream, "MuteStream");
+    MuteStream.prototype = Object.create(Stream2.prototype);
+    Object.defineProperty(MuteStream.prototype, "constructor", {
+      value: MuteStream,
+      enumerable: false
+    });
+    MuteStream.prototype.mute = function() {
+      this.muted = true;
+    };
+    MuteStream.prototype.unmute = function() {
+      this.muted = false;
+    };
+    Object.defineProperty(MuteStream.prototype, "_onpipe", {
+      value: onPipe,
+      enumerable: false,
+      writable: true,
+      configurable: true
+    });
+    function onPipe(src) {
+      this._src = src;
+    }
+    __name(onPipe, "onPipe");
+    Object.defineProperty(MuteStream.prototype, "isTTY", {
+      get: getIsTTY,
+      set: setIsTTY,
+      enumerable: true,
+      configurable: true
+    });
+    function getIsTTY() {
+      return this._dest ? this._dest.isTTY : this._src ? this._src.isTTY : false;
+    }
+    __name(getIsTTY, "getIsTTY");
+    function setIsTTY(isTTY2) {
+      Object.defineProperty(this, "isTTY", {
+        value: isTTY2,
+        enumerable: true,
+        writable: true,
+        configurable: true
+      });
+    }
+    __name(setIsTTY, "setIsTTY");
+    Object.defineProperty(MuteStream.prototype, "rows", {
+      get: /* @__PURE__ */ __name(function() {
+        return this._dest ? this._dest.rows : this._src ? this._src.rows : void 0;
+      }, "get"),
+      enumerable: true,
+      configurable: true
+    });
+    Object.defineProperty(MuteStream.prototype, "columns", {
+      get: /* @__PURE__ */ __name(function() {
+        return this._dest ? this._dest.columns : this._src ? this._src.columns : void 0;
+      }, "get"),
+      enumerable: true,
+      configurable: true
+    });
+    MuteStream.prototype.pipe = function(dest, options) {
+      this._dest = dest;
+      return Stream2.prototype.pipe.call(this, dest, options);
+    };
+    MuteStream.prototype.pause = function() {
+      if (this._src) return this._src.pause();
+    };
+    MuteStream.prototype.resume = function() {
+      if (this._src) return this._src.resume();
+    };
+    MuteStream.prototype.write = function(c3) {
+      if (this.muted) {
+        if (!this.replace) return true;
+        if (c3.match(/^\u001b/)) {
+          if (c3.indexOf(this._prompt) === 0) {
+            c3 = c3.substr(this._prompt.length);
+            c3 = c3.replace(/./g, this.replace);
+            c3 = this._prompt + c3;
+          }
+          this._hadControl = true;
+          return this.emit("data", c3);
+        } else {
+          if (this._prompt && this._hadControl && c3.indexOf(this._prompt) === 0) {
+            this._hadControl = false;
+            this.emit("data", this._prompt);
+            c3 = c3.substr(this._prompt.length);
+          }
+          c3 = c3.toString().replace(/./g, this.replace);
+        }
+      }
+      this.emit("data", c3);
+    };
+    MuteStream.prototype.end = function(c3) {
+      if (this.muted) {
+        if (c3 && this.replace) {
+          c3 = c3.toString().replace(/./g, this.replace);
+        } else {
+          c3 = null;
+        }
+      }
+      if (c3) this.emit("data", c3);
+      this.emit("end");
+    };
+    function proxy(fn) {
+      return function() {
+        var d3 = this._dest;
+        var s3 = this._src;
+        if (d3 && d3[fn]) d3[fn].apply(d3, arguments);
+        if (s3 && s3[fn]) s3[fn].apply(s3, arguments);
+      };
+    }
+    __name(proxy, "proxy");
+    MuteStream.prototype.destroy = proxy("destroy");
+    MuteStream.prototype.destroySoon = proxy("destroySoon");
+    MuteStream.prototype.close = proxy("close");
+  }
+});
+
+// ../../node_modules/promptly/node_modules/read/lib/read.js
+var require_read = __commonJS({
+  "../../node_modules/promptly/node_modules/read/lib/read.js"(exports2, module2) {
+    module2.exports = read;
+    var readline = require("readline");
+    var Mute = require_mute();
+    function read(opts, cb) {
+      if (opts.num) {
+        throw new Error("read() no longer accepts a char number limit");
+      }
+      if (typeof opts.default !== "undefined" && typeof opts.default !== "string" && typeof opts.default !== "number") {
+        throw new Error("default value must be string or number");
+      }
+      var input = opts.input || process.stdin;
+      var output = opts.output || process.stdout;
+      var prompt2 = (opts.prompt || "").trim() + " ";
+      var silent = opts.silent;
+      var editDef = false;
+      var timeout = opts.timeout;
+      var def = opts.default || "";
+      if (def) {
+        if (silent) {
+          prompt2 += "(<default hidden>) ";
+        } else if (opts.edit) {
+          editDef = true;
+        } else {
+          prompt2 += "(" + def + ") ";
+        }
+      }
+      var terminal = !!(opts.terminal || output.isTTY);
+      var m3 = new Mute({ replace: opts.replace, prompt: prompt2 });
+      m3.pipe(output, { end: false });
+      output = m3;
+      var rlOpts = { input, output, terminal };
+      if (process.version.match(/^v0\.6/)) {
+        var rl = readline.createInterface(rlOpts.input, rlOpts.output);
+      } else {
+        var rl = readline.createInterface(rlOpts);
+      }
+      output.unmute();
+      rl.setPrompt(prompt2);
+      rl.prompt();
+      if (silent) {
+        output.mute();
+      } else if (editDef) {
+        rl.line = def;
+        rl.cursor = def.length;
+        rl._refreshLine();
+      }
+      var called = false;
+      rl.on("line", onLine);
+      rl.on("error", onError);
+      rl.on("SIGINT", function() {
+        rl.close();
+        onError(new Error("canceled"));
+      });
+      var timer;
+      if (timeout) {
+        timer = setTimeout(function() {
+          onError(new Error("timed out"));
+        }, timeout);
+      }
+      function done() {
+        called = true;
+        rl.close();
+        if (process.version.match(/^v0\.6/)) {
+          rl.input.removeAllListeners("data");
+          rl.input.removeAllListeners("keypress");
+          rl.input.pause();
+        }
+        clearTimeout(timer);
+        output.mute();
+        output.end();
+      }
+      __name(done, "done");
+      function onError(er) {
+        if (called) return;
+        done();
+        return cb(er);
+      }
+      __name(onError, "onError");
+      function onLine(line) {
+        if (called) return;
+        if (silent && terminal) {
+          output.unmute();
+          output.write("\r\n");
+        }
+        done();
+        line = line.replace(/\r?\n$/, "");
+        var isDefault = !!(editDef && line === def);
+        if (def && !line) {
+          isDefault = true;
+          line = def;
+        }
+        cb(null, line, isDefault);
+      }
+      __name(onLine, "onLine");
+    }
+    __name(read, "read");
+  }
+});
+
+// ../../node_modules/promptly/lib/prompt.js
+var require_prompt = __commonJS({
+  "../../node_modules/promptly/lib/prompt.js"(exports2, module2) {
+    "use strict";
+    var { EOL } = require("os");
+    var { promisify: promisify4 } = require("util");
+    var read = promisify4(require_read());
+    async function prompt2(message2, options) {
+      let value;
+      try {
+        value = await read({
+          prompt: message2,
+          silent: options.silent,
+          replace: options.replace,
+          input: options.input,
+          output: options.output,
+          timeout: options.timeout
+        });
+      } catch (err) {
+        if (err.message !== "timed out" || options.default === void 0 || !options.useDefaultOnTimeout) {
+          throw Object.assign(new Error(err.message), { code: "TIMEDOUT" });
+        }
+        value = options.default;
+      }
+      if (options.trim) {
+        value = value.trim();
+      }
+      if (!value) {
+        if (options.default === void 0) {
+          return prompt2(message2, options);
+        }
+        value = options.default;
+      }
+      try {
+        for (const i3 in options.validator) {
+          value = await options.validator[i3](value);
+        }
+      } catch (err) {
+        if (options.retry) {
+          err.message && options.output.write(err.message + EOL);
+          return prompt2(message2, options);
+        }
+        throw err;
+      }
+      return value;
+    }
+    __name(prompt2, "prompt");
+    module2.exports = prompt2;
+  }
+});
+
+// ../../node_modules/promptly/lib/getOptions.js
+var require_getOptions = __commonJS({
+  "../../node_modules/promptly/lib/getOptions.js"(exports2, module2) {
+    "use strict";
+    function getOptions(options) {
+      options = {
+        // Own options
+        validator: void 0,
+        retry: true,
+        trim: true,
+        default: void 0,
+        useDefaultOnTimeout: false,
+        // `read` package options
+        silent: false,
+        replace: "",
+        input: process.stdin,
+        output: process.stdout,
+        timeout: 0,
+        ...options
+      };
+      if (options.default !== void 0 && typeof options.default !== "string") {
+        throw new Error("The default option value must be a string");
+      }
+      if (!Array.isArray(options.validator)) {
+        options.validator = options.validator ? [options.validator] : [];
+      }
+      return options;
+    }
+    __name(getOptions, "getOptions");
+    module2.exports = getOptions;
+  }
+});
+
+// ../../node_modules/promptly/index.js
+var require_promptly = __commonJS({
+  "../../node_modules/promptly/index.js"(exports2, module2) {
+    "use strict";
+    var prompt2 = require_prompt();
+    var getOptions = require_getOptions();
+    var promptly2 = module2.exports;
+    promptly2.prompt = (message2, options) => {
+      options = getOptions(options);
+      return prompt2(message2, options);
+    };
+    promptly2.password = (message2, options) => {
+      options = getOptions({
+        silent: true,
+        // Hide password chars
+        trim: false,
+        // Do not trim so that spaces can be part of the password
+        default: "",
+        // Allow empty passwords
+        ...options
+      });
+      return prompt2(message2, options);
+    };
+    promptly2.confirm = (message2, options) => {
+      options = getOptions({
+        trim: false,
+        // Do not trim so that only exact matches pass the validator
+        ...options
+      });
+      options.validator.unshift((value) => {
+        value = value.toLowerCase();
+        switch (value) {
+          case "y":
+          case "yes":
+          case "1":
+            return true;
+          case "n":
+          case "no":
+          case "0":
+            return false;
+          default:
+            throw new Error(`Invalid choice: ${value}`);
+        }
+      });
+      return prompt2(message2, options);
+    };
+    promptly2.choose = (message2, choices, options) => {
+      options = getOptions({
+        trim: false,
+        // Do not trim so that only exact matches pass the validator
+        ...options
+      });
+      options.validator.unshift((value) => {
+        const index = choices.findIndex((choice) => value == choice);
+        if (index === -1) {
+          throw new Error(`Invalid choice: ${value}`);
+        }
+        return choices[index];
+      });
+      return prompt2(message2, options);
+    };
+  }
+});
+
 // lib/api-private.ts
 var init_api_private = __esm({
   "lib/api-private.ts"() {
@@ -338629,8 +338628,21 @@ var require_cli_type_registry = __commonJS({
               alias: [
                 "i"
               ],
-              desc: "Interactive option for the flags command",
+              desc: "Interactive option for the flags command"
+            },
+            safe: {
+              type: "boolean",
+              desc: "Enable all feature flags that do not impact the user's application",
               requiresArg: false
+            },
+            concurrency: {
+              type: "number",
+              alias: [
+                "n"
+              ],
+              desc: "Maximum number of simultaneous synths to execute.",
+              default: 4,
+              requiresArg: true
             }
           }
         },
@@ -342482,20 +342494,24 @@ var init_init_hooks = __esm({
 function getLanguageFromAlias(alias) {
   return SUPPORTED_LANGUAGES.find((l3) => l3.alias === alias || l3.name === alias)?.name;
 }
+function getLanguageExtensions(language) {
+  return SUPPORTED_LANGUAGES.find((l3) => l3.name === language || l3.alias === language)?.extensions ?? [];
+}
 var SUPPORTED_LANGUAGES;
 var init_language = __esm({
   "lib/commands/language.ts"() {
     "use strict";
     SUPPORTED_LANGUAGES = [
-      { name: "csharp", alias: "cs" },
-      { name: "fsharp", alias: "fs" },
-      { name: "go", alias: "go" },
-      { name: "java", alias: "java" },
-      { name: "javascript", alias: "js" },
-      { name: "python", alias: "py" },
-      { name: "typescript", alias: "ts" }
+      { name: "csharp", alias: "cs", extensions: [".cs"] },
+      { name: "fsharp", alias: "fs", extensions: [".fs"] },
+      { name: "go", alias: "go", extensions: [".go"] },
+      { name: "java", alias: "java", extensions: [".java"] },
+      { name: "javascript", alias: "js", extensions: [".js"] },
+      { name: "python", alias: "py", extensions: [".py"] },
+      { name: "typescript", alias: "ts", extensions: [".ts", ".js"] }
     ];
     __name(getLanguageFromAlias, "getLanguageFromAlias");
+    __name(getLanguageExtensions, "getLanguageExtensions");
   }
 });
 
@@ -342719,47 +342735,36 @@ async function resolveLanguage(ioHelper, template, requestedLanguage, type) {
   })();
 }
 async function findPotentialTemplates(repositoryPath) {
-  try {
-    const entries = await fs35.readdir(repositoryPath, { withFileTypes: true });
-    const potentialTemplates = [];
-    for (const entry of entries) {
-      if (entry.isDirectory() && !entry.name.startsWith(".")) {
-        const templatePath = path33.join(repositoryPath, entry.name);
-        const languages = await getLanguageDirectories(templatePath);
-        if (languages.length > 0) {
-          potentialTemplates.push(entry.name);
-        }
-      }
+  const entries = await fs35.readdir(repositoryPath, { withFileTypes: true });
+  const templateValidationPromises = entries.filter((entry) => entry.isDirectory() && !entry.name.startsWith(".")).map(async (entry) => {
+    try {
+      const templatePath = path33.join(repositoryPath, entry.name);
+      const { languages } = await getLanguageDirectories(templatePath);
+      return languages.length > 0 ? entry.name : null;
+    } catch (error5) {
+      return null;
     }
-    return potentialTemplates;
-  } catch (error5) {
-    return [];
-  }
+  });
+  const validationResults = await Promise.all(templateValidationPromises);
+  return validationResults.filter((templateName) => templateName !== null);
 }
 async function getLanguageDirectories(templatePath) {
-  const cdkSupportedLanguages = ["typescript", "javascript", "python", "java", "csharp", "fsharp", "go"];
-  const languageExtensions = {
-    typescript: [".ts", ".js"],
-    javascript: [".js"],
-    python: [".py"],
-    java: [".java"],
-    csharp: [".cs"],
-    fsharp: [".fs"],
-    go: [".go"]
-  };
   try {
     const entries = await fs35.readdir(templatePath, { withFileTypes: true });
-    const languageValidationPromises = entries.filter((directoryEntry) => directoryEntry.isDirectory() && cdkSupportedLanguages.includes(directoryEntry.name)).map(async (directoryEntry) => {
+    const languageValidationPromises = entries.filter((directoryEntry) => directoryEntry.isDirectory() && SUPPORTED_LANGUAGE_NAMES.includes(directoryEntry.name)).map(async (directoryEntry) => {
       const languageDirectoryPath = path33.join(templatePath, directoryEntry.name);
       try {
-        const hasValidLanguageFiles = await hasLanguageFiles(languageDirectoryPath, languageExtensions[directoryEntry.name]);
+        const hasValidLanguageFiles = await hasLanguageFiles(languageDirectoryPath, getLanguageExtensions(directoryEntry.name));
         return hasValidLanguageFiles ? directoryEntry.name : null;
       } catch (error5) {
         throw new import_toolkit_lib12.ToolkitError(`Cannot read language directory '${directoryEntry.name}': ${error5.message}`);
       }
     });
     const validationResults = await Promise.all(languageValidationPromises);
-    return validationResults.filter((languageName) => languageName !== null);
+    return {
+      languages: validationResults.filter((languageName) => languageName !== null),
+      entries
+    };
   } catch (error5) {
     throw new import_toolkit_lib12.ToolkitError(`Cannot read template directory '${templatePath}': ${error5.message}`);
   }
@@ -342860,16 +342865,27 @@ async function initializeProject(ioHelper, template, language, canUseNetwork, ge
 }
 async function assertIsEmptyDirectory(workDir) {
   try {
+    const stats = await fs35.stat(workDir);
+    if (!stats.isDirectory()) {
+      throw new import_toolkit_lib12.ToolkitError(`Path exists but is not a directory: ${workDir}`);
+    }
     const files = await fs35.readdir(workDir);
-    if (files.filter((f3) => !f3.startsWith(".")).length !== 0) {
-      throw new import_toolkit_lib12.ToolkitError("`cdk init` cannot be run in a non-empty directory!");
+    const visibleFiles = files.filter((f3) => !f3.startsWith("."));
+    if (visibleFiles.length > 0) {
+      throw new import_toolkit_lib12.ToolkitError(
+        `\`cdk init\` cannot be run in a non-empty directory!
+Found ${visibleFiles.length} visible files in ${workDir}:
+` + visibleFiles.map((f3) => `  - ${f3}`).join("\n")
+      );
     }
   } catch (e3) {
     if (e3.code === "ENOENT") {
-      throw new import_toolkit_lib12.ToolkitError(`Directory does not exist: ${workDir}. Please create the directory first.`);
-    } else {
-      throw e3;
+      throw new import_toolkit_lib12.ToolkitError(
+        `Directory does not exist: ${workDir}
+Please create the directory first using: mkdir -p ` + workDir
+      );
     }
+    throw new import_toolkit_lib12.ToolkitError(`Failed to validate directory ${workDir}: ${e3.message}`);
   }
 }
 async function initializeGitRepository(ioHelper, workDir) {
@@ -343056,7 +343072,7 @@ async function currentlyRecommendedAwsCdkLibFlags() {
   const recommendedFlagsFile = path33.join(cliRootDir(), "lib", "init-templates", ".recommended-feature-flags.json");
   return JSON.parse(await fs35.readFile(recommendedFlagsFile, { encoding: "utf-8" }));
 }
-var childProcess2, path33, import_toolkit_lib12, chalk26, fs35, camelCase, decamelize, INFO_DOT_JSON, InitTemplate;
+var childProcess2, path33, import_toolkit_lib12, chalk26, fs35, camelCase, decamelize, SUPPORTED_LANGUAGE_NAMES, INFO_DOT_JSON, InitTemplate;
 var init_init = __esm({
   "lib/commands/init/init.ts"() {
     "use strict";
@@ -343072,6 +343088,7 @@ var init_init = __esm({
     init_language();
     camelCase = require_camelcase();
     decamelize = require_decamelize();
+    SUPPORTED_LANGUAGE_NAMES = SUPPORTED_LANGUAGES.map((l3) => l3.name);
     __name(cliInit, "cliInit");
     __name(loadLocalTemplate, "loadLocalTemplate");
     __name(loadBuiltinTemplate, "loadBuiltinTemplate");
@@ -343109,9 +343126,23 @@ var init_init = __esm({
         if (!await fs35.pathExists(basePath)) {
           throw new import_toolkit_lib12.ToolkitError(`Template path does not exist: ${basePath}`);
         }
-        const languages = await getLanguageDirectories(basePath);
+        let templateSourcePath = basePath;
+        let { languages, entries } = await getLanguageDirectories(basePath);
+        if (languages.length === 0) {
+          const languageDirs = entries.filter(
+            (entry) => entry.isDirectory() && SUPPORTED_LANGUAGE_NAMES.includes(entry.name)
+          );
+          if (languageDirs.length === 1) {
+            const langDir = languageDirs[0].name;
+            templateSourcePath = path33.join(basePath, langDir);
+            const hasValidFiles = await hasLanguageFiles(templateSourcePath, getLanguageExtensions(langDir));
+            if (!hasValidFiles) {
+              throw new import_toolkit_lib12.ToolkitError(`Found '${langDir}' directory but it doesn't contain the expected language files. Ensure the template contains ${langDir} source files.`);
+            }
+          }
+        }
         const name = path33.basename(basePath);
-        return new _InitTemplate(basePath, name, languages, null, "custom" /* CUSTOM */);
+        return new _InitTemplate(templateSourcePath, name, languages, null, "custom" /* CUSTOM */);
       }
       /**
        * @param name - the name that is being checked
@@ -343145,7 +343176,10 @@ var init_init = __esm({
         if (libVersion) {
           projectInfo.versions["aws-cdk-lib"] = libVersion;
         }
-        const sourceDirectory = path33.join(this.basePath, language);
+        let sourceDirectory = path33.join(this.basePath, language);
+        if (this.templateType === "custom" /* CUSTOM */ && this.languages.length === 1 && path33.basename(this.basePath) === language) {
+          sourceDirectory = this.basePath;
+        }
         if (this.templateType === "custom" /* CUSTOM */) {
           await this.installFilesWithoutProcessing(sourceDirectory, targetDirectory);
         } else {
@@ -343916,18 +343950,9 @@ function buildParameterMap2(parameters) {
   }
   return parameterMap;
 }
-async function askUserConfirmation(ioHost, concurrency, motivation, question2) {
+async function askUserConfirmation(ioHost, req) {
   await ioHost.withCorkedLogging(async () => {
-    if (!TESTING && !process.stdin.isTTY) {
-      throw new import_toolkit_lib14.ToolkitError(`${motivation}, but terminal (TTY) is not attached so we are unable to get a confirmation from the user`);
-    }
-    if (concurrency > 1) {
-      throw new import_toolkit_lib14.ToolkitError(`${motivation}, but concurrency is greater than 1 so we are unable to get a confirmation from the user`);
-    }
-    const confirmed = await promptly2.confirm(`${chalk28.cyan(question2)} (y/n)?`);
-    if (!confirmed) {
-      throw new import_toolkit_lib14.ToolkitError("Aborted by user");
-    }
+    await ioHost.asIoHelper().requestResponse(req);
   });
 }
 async function displayFlagsMessage(ioHost, toolkit, cloudExecutable) {
@@ -343963,7 +343988,7 @@ function stackMetadataLogger(ioHelper, verbose) {
 function requiresApproval(requireApproval, permissionChangeType) {
   return requireApproval === import_cloud_assembly_schema8.RequireApproval.ANYCHANGE || requireApproval === import_cloud_assembly_schema8.RequireApproval.BROADENING && permissionChangeType === import_toolkit_lib14.PermissionChangeType.BROADENING;
 }
-var path35, import_util71, import_cloud_assembly_schema8, cxapi10, import_toolkit_lib14, chalk28, chokidar2, fs37, promptly2, pLimit5, TESTING, InternalToolkit, CdkToolkit;
+var path35, import_util71, import_cloud_assembly_schema8, cxapi10, import_toolkit_lib14, chalk28, chokidar2, fs37, pLimit5, InternalToolkit, CdkToolkit;
 var init_cdk_toolkit = __esm({
   "lib/cli/cdk-toolkit.ts"() {
     "use strict";
@@ -343975,7 +344000,6 @@ var init_cdk_toolkit = __esm({
     chalk28 = __toESM(require_source());
     chokidar2 = __toESM(require_chokidar());
     fs37 = __toESM(require_lib13());
-    promptly2 = __toESM(require_promptly());
     init_esm10();
     init_io_host2();
     init_user_configuration();
@@ -343994,7 +344018,6 @@ var init_cdk_toolkit = __esm({
     init_error();
     init_messages2();
     pLimit5 = require_p_limit();
-    TESTING = false;
     InternalToolkit = class extends import_toolkit_lib14.Toolkit {
       static {
         __name(this, "InternalToolkit");
@@ -344279,12 +344302,16 @@ var init_cdk_toolkit = __esm({
             });
             const securityDiff = formatter.formatSecurityDiff();
             if (requiresApproval(requireApproval, securityDiff.permissionChangeType)) {
+              const motivation = '"--require-approval" is enabled and stack includes security-sensitive updates';
               await this.ioHost.asIoHelper().defaults.info(securityDiff.formattedDiff);
               await askUserConfirmation(
                 this.ioHost,
-                concurrency,
-                '"--require-approval" is enabled and stack includes security-sensitive updates',
-                "Do you wish to deploy these changes"
+                IO.CDK_TOOLKIT_I5060.req(`${motivation}: 'Do you wish to deploy these changes'`, {
+                  motivation,
+                  concurrency,
+                  permissionChangeType: securityDiff.permissionChangeType,
+                  templateDiffs: formatter.diffs
+                })
               );
             }
           }
@@ -344342,9 +344369,10 @@ var init_cdk_toolkit = __esm({
                   } else {
                     await askUserConfirmation(
                       this.ioHost,
-                      concurrency,
-                      motivation,
-                      `${motivation}. Roll back first and then proceed with deployment`
+                      IO.CDK_TOOLKIT_I5050.req(`${motivation}. Roll back first and then proceed with deployment`, {
+                        motivation,
+                        concurrency
+                      })
                     );
                   }
                   await this.rollback({
@@ -344362,9 +344390,10 @@ var init_cdk_toolkit = __esm({
                   } else {
                     await askUserConfirmation(
                       this.ioHost,
-                      concurrency,
-                      motivation,
-                      `${motivation}. Perform a regular deployment`
+                      IO.CDK_TOOLKIT_I5050.req(`${motivation}. Perform a regular deployment`, {
+                        concurrency,
+                        motivation
+                      })
                     );
                   }
                   rollback = true;
@@ -344639,29 +344668,34 @@ var init_cdk_toolkit = __esm({
         }
       }
       async destroy(options) {
-        let stacks = await this.selectStacksForDestroy(options.selector, options.exclusively);
-        stacks = stacks.reversed();
+        const ioHelper = this.ioHost.asIoHelper();
+        const stacks = (await this.selectStacksForDestroy(options.selector, options.exclusively)).reversed();
         if (!options.force) {
-          const confirmed = await promptly2.confirm(
-            `Are you sure you want to delete: ${chalk28.blue(stacks.stackArtifacts.map((s3) => s3.hierarchicalId).join(", "))} (y/n)?`
-          );
-          if (!confirmed) {
+          const motivation = "Destroying stacks is an irreversible action";
+          const question2 = `Are you sure you want to delete: ${chalk28.blue(stacks.stackArtifacts.map((s3) => s3.hierarchicalId).join(", "))}`;
+          try {
+            await ioHelper.requestResponse(IO.CDK_TOOLKIT_I7010.req(question2, { motivation }));
+          } catch (err) {
+            if (!import_toolkit_lib14.ToolkitError.isToolkitError(err) || err.message != "Aborted by user") {
+              throw err;
+            }
+            await ioHelper.notify(IO.CDK_TOOLKIT_E7010.msg(err.message));
             return;
           }
         }
         const action = options.fromDeploy ? "deploy" : "destroy";
         for (const [index, stack] of stacks.stackArtifacts.entries()) {
-          await this.ioHost.asIoHelper().defaults.info(chalk28.green("%s: destroying... [%s/%s]"), chalk28.blue(stack.displayName), index + 1, stacks.stackCount);
+          await ioHelper.defaults.info(chalk28.green("%s: destroying... [%s/%s]"), chalk28.blue(stack.displayName), index + 1, stacks.stackCount);
           try {
             await this.props.deployments.destroyStack({
               stack,
               deployName: stack.stackName,
               roleArn: options.roleArn
             });
-            await this.ioHost.asIoHelper().defaults.info(chalk28.green(`
+            await ioHelper.defaults.info(chalk28.green(`
  \u2705  %s: ${action}ed`), chalk28.blue(stack.displayName));
           } catch (e3) {
-            await this.ioHost.asIoHelper().defaults.error(`
+            await ioHelper.defaults.error(`
  \u274C  %s: ${action} failed`, chalk28.blue(stack.displayName), e3);
             throw e3;
           }
@@ -344815,7 +344849,7 @@ var init_cdk_toolkit = __esm({
           } else if (scanType == "path" /* PATH */) {
             const templateBody = readFromPath(options.fromPath);
             const parsedTemplate = deserializeStructure(templateBody);
-            const templateId = parsedTemplate.Metadata?.TemplateId?.toString();
+            const templateId = parsedTemplate.Metadata?.AWSToolsMetrics?.IaC_Generator?.toString();
             if (templateId) {
               cfn = new CfnTemplateGeneratorProvider(await buildCfnClient(this.props.sdkProvider, environment), this.ioHost.asIoHelper());
               const generatedTemplateSummary = await cfn.describeGeneratedTemplate(templateId);
@@ -350331,8 +350365,18 @@ function parseCommandLineArguments(args) {
       default: void 0,
       type: "boolean",
       alias: ["i"],
-      desc: "Interactive option for the flags command",
+      desc: "Interactive option for the flags command"
+    }).option("safe", {
+      default: void 0,
+      type: "boolean",
+      desc: "Enable all feature flags that do not impact the user's application",
       requiresArg: false
+    }).option("concurrency", {
+      default: 4,
+      type: "number",
+      alias: ["n"],
+      desc: "Maximum number of simultaneous synths to execute.",
+      requiresArg: true
     })
   ).command(
     "deploy [STACKS..]",
@@ -355853,412 +355897,1270 @@ var require_enquirer = __commonJS({
   }
 });
 
-// lib/commands/flag-operations.ts
-async function handleFlags(flagData, ioHelper, options, toolkit) {
-  flagData = flagData.filter((flag) => !OBSOLETE_FLAGS.includes(flag.name));
-  if (flagData.length == 0) {
-    await ioHelper.defaults.error("The 'cdk flags' command is not compatible with the AWS CDK library used by your application. Please upgrade to 2.212.0 or above.");
-    return;
-  }
-  let params = {
-    flagData,
-    toolkit,
-    ioHelper,
-    recommended: options.recommended,
-    all: options.all,
-    value: options.value,
-    flagName: options.FLAGNAME,
-    default: options.default,
-    unconfigured: options.unconfigured
-  };
-  const interactiveOptions = Object.values(FlagsMenuOptions);
-  if (options.interactive) {
-    const prompt2 = new import_enquirer.Select({
-      name: "option",
-      message: "Menu",
-      choices: interactiveOptions
-    });
-    const answer = await prompt2.run();
-    if (answer == "Set all flags to recommended values" /* ALL_TO_RECOMMENDED */) {
-      params = {
-        ...params,
-        recommended: true,
-        all: true
-      };
-      await setMultipleFlags(params);
-    } else if (answer == "Set unconfigured flags to recommended values" /* UNCONFIGURED_TO_RECOMMENDED */) {
-      params = {
-        ...params,
-        recommended: true,
-        unconfigured: true
-      };
-      await setMultipleFlags(params);
-    } else if (answer == "Set unconfigured flags to their implied configuration (record current behavior)" /* UNCONFIGURED_TO_DEFAULT */) {
-      params = {
-        ...params,
-        default: true,
-        unconfigured: true
-      };
-      await setMultipleFlagsIfSupported(params);
-    } else if (answer == "Modify a specific flag" /* MODIFY_SPECIFIC_FLAG */) {
-      await setFlag(params, true);
-    } else if (answer == "Exit" /* EXIT */) {
-      return;
-    }
-    return;
-  }
-  if (options.FLAGNAME && options.all) {
-    await ioHelper.defaults.error("Error: Cannot use both --all and a specific flag name. Please use either --all to show all flags or specify a single flag name.");
-    return;
-  }
-  if ((options.value || options.recommended || options.default || options.unconfigured) && !options.set) {
-    await ioHelper.defaults.error("Error: This option can only be used with --set.");
-    return;
-  }
-  if (options.value && !options.FLAGNAME) {
-    await ioHelper.defaults.error("Error: --value requires a specific flag name. Please specify a flag name when providing a value.");
-    return;
-  }
-  if (options.recommended && options.default) {
-    await ioHelper.defaults.error("Error: Cannot use both --recommended and --default. Please choose one option.");
-    return;
-  }
-  if (options.unconfigured && options.all) {
-    await ioHelper.defaults.error("Error: Cannot use both --unconfigured and --all. Please choose one option.");
-    return;
-  }
-  if (options.unconfigured && options.FLAGNAME) {
-    await ioHelper.defaults.error("Error: Cannot use --unconfigured with a specific flag name. --unconfigured works with multiple flags.");
-    return;
-  }
-  if (options.set && options.FLAGNAME && !options.value) {
-    await ioHelper.defaults.error("Error: When setting a specific flag, you must provide a --value.");
-    return;
-  }
-  if (options.set && options.all && !options.recommended && !options.default) {
-    await ioHelper.defaults.error("Error: When using --set with --all, you must specify either --recommended or --default.");
-    return;
-  }
-  if (options.set && options.unconfigured && !options.recommended && !options.default) {
-    await ioHelper.defaults.error("Error: When using --set with --unconfigured, you must specify either --recommended or --default.");
-    return;
-  }
-  if (options.set && !options.all && !options.unconfigured && !options.FLAGNAME) {
-    await ioHelper.defaults.error("Error: When using --set, you must specify either --all, --unconfigured, or provide a specific flag name.");
-    return;
-  }
-  if (options.FLAGNAME && !options.set && !options.value) {
-    await displayFlags(params);
-    return;
-  }
-  if (options.all && !options.set) {
-    await displayFlags(params);
-    return;
-  }
-  if (options.set && options.FLAGNAME && options.value) {
-    await setFlag(params);
-    return;
-  }
-  if (!options.FLAGNAME && !options.all && !options.set) {
-    await displayFlags(params);
-    return;
-  }
-  if (options.set && options.all && options.recommended) {
-    await setMultipleFlags(params);
-    return;
-  }
-  if (options.set && options.all && options.default) {
-    await setMultipleFlagsIfSupported(params);
-  }
-  if (options.set && options.unconfigured && options.recommended) {
-    await setMultipleFlags(params);
-    return;
-  }
-  if (options.set && options.unconfigured && options.default) {
-    await setMultipleFlagsIfSupported(params);
-  }
-}
-async function setMultipleFlagsIfSupported(params) {
-  const { flagData, ioHelper } = params;
-  if (flagData[0].unconfiguredBehavesLike) {
-    await setMultipleFlags(params);
-    return;
+// lib/commands/flags/types.ts
+var FlagsMenuOptions;
+var init_types9 = __esm({
+  "lib/commands/flags/types.ts"() {
+    "use strict";
+    FlagsMenuOptions = /* @__PURE__ */ ((FlagsMenuOptions2) => {
+      FlagsMenuOptions2["ALL_TO_RECOMMENDED"] = "Set all flags to recommended values";
+      FlagsMenuOptions2["UNCONFIGURED_TO_RECOMMENDED"] = "Set unconfigured flags to recommended values";
+      FlagsMenuOptions2["UNCONFIGURED_TO_DEFAULT"] = "Set unconfigured flags to their implied configuration (record current behavior)";
+      FlagsMenuOptions2["MODIFY_SPECIFIC_FLAG"] = "Modify a specific flag";
+      FlagsMenuOptions2["EXIT"] = "Exit";
+      return FlagsMenuOptions2;
+    })(FlagsMenuOptions || {});
   }
-  await ioHelper.defaults.error("The --default options are not compatible with the AWS CDK library used by your application. Please upgrade to 2.212.0 or above.");
-}
-async function setFlag(params, interactive) {
-  const { flagData, ioHelper, flagName } = params;
-  let updatedParams = params;
-  let updatedFlagName = flagName;
-  if (interactive) {
-    const allFlagNames = flagData.filter((flag) => isBooleanFlag(flag) == true).map((flag) => flag.name);
-    const prompt2 = new import_enquirer.Select({
-      name: "flag",
-      message: "Select which flag you would like to modify:",
-      limit: 100,
-      choices: allFlagNames
-    });
-    const selectedFlagName = await prompt2.run();
-    updatedFlagName = [selectedFlagName];
-    const valuePrompt = new import_enquirer.Select({
-      name: "value",
-      message: "Select a value:",
-      choices: ["true", "false"]
-    });
-    const updatedValue = await valuePrompt.run();
-    updatedParams = {
-      ...params,
-      value: updatedValue,
-      flagName: updatedFlagName
+});
+
+// lib/commands/flags/interactive-handler.ts
+var import_enquirer, InteractiveHandler;
+var init_interactive_handler = __esm({
+  "lib/commands/flags/interactive-handler.ts"() {
+    "use strict";
+    import_enquirer = __toESM(require_enquirer());
+    init_types9();
+    InteractiveHandler = class {
+      constructor(flags, flagOperations) {
+        this.flags = flags;
+        this.flagOperations = flagOperations;
+      }
+      static {
+        __name(this, "InteractiveHandler");
+      }
+      /** Displays flags that have differences between user and recommended values */
+      async displayFlagsWithDifferences() {
+        const flagsWithDifferences = this.flags.filter((flag) => flag.userValue === void 0 || !this.isUserValueEqualToRecommended(flag));
+        if (flagsWithDifferences.length > 0) {
+          await this.flagOperations.displayFlagTable(flagsWithDifferences);
+        }
+      }
+      /** Checks if user value matches recommended value */
+      isUserValueEqualToRecommended(flag) {
+        return String(flag.userValue) === String(flag.recommendedValue);
+      }
+      /** Main interactive mode handler that shows menu and processes user selection */
+      async handleInteractiveMode() {
+        await this.displayFlagsWithDifferences();
+        const prompt2 = new import_enquirer.Select({
+          name: "option",
+          message: "Menu",
+          choices: Object.values(FlagsMenuOptions)
+        });
+        const answer = await prompt2.run();
+        switch (answer) {
+          case "Set all flags to recommended values" /* ALL_TO_RECOMMENDED */:
+            return { recommended: true, all: true, set: true };
+          case "Set unconfigured flags to recommended values" /* UNCONFIGURED_TO_RECOMMENDED */:
+            return { recommended: true, unconfigured: true, set: true };
+          case "Set unconfigured flags to their implied configuration (record current behavior)" /* UNCONFIGURED_TO_DEFAULT */:
+            return { default: true, unconfigured: true, set: true };
+          case "Modify a specific flag" /* MODIFY_SPECIFIC_FLAG */:
+            return this.handleSpecificFlagSelection();
+          case "Exit" /* EXIT */:
+            return null;
+          default:
+            return null;
+        }
+      }
+      /** Handles the specific flag selection flow with flag and value prompts */
+      async handleSpecificFlagSelection() {
+        const booleanFlags = this.flags.filter((flag) => this.flagOperations.isBooleanFlag(flag));
+        const flagPrompt = new import_enquirer.Select({
+          name: "flag",
+          message: "Select which flag you would like to modify:",
+          limit: 100,
+          choices: booleanFlags.map((flag) => flag.name)
+        });
+        const selectedFlagName = await flagPrompt.run();
+        const valuePrompt = new import_enquirer.Select({
+          name: "value",
+          message: "Select a value:",
+          choices: ["true", "false"]
+        });
+        const value = await valuePrompt.run();
+        return {
+          FLAGNAME: [selectedFlagName],
+          value,
+          set: true
+        };
+      }
     };
-  } else {
-    const flag = flagData.find((f3) => f3.name === flagName[0]);
-    if (!flag) {
-      await ioHelper.defaults.error("Flag not found.");
-      return;
+  }
+});
+
+// ../../node_modules/eventemitter3/index.js
+var require_eventemitter3 = __commonJS({
+  "../../node_modules/eventemitter3/index.js"(exports2, module2) {
+    "use strict";
+    var has = Object.prototype.hasOwnProperty;
+    var prefix2 = "~";
+    function Events() {
     }
-    if (!isBooleanFlag(flag)) {
-      await ioHelper.defaults.error(`Flag '${flagName}' is not a boolean flag. Only boolean flags are currently supported.`);
-      return;
+    __name(Events, "Events");
+    if (Object.create) {
+      Events.prototype = /* @__PURE__ */ Object.create(null);
+      if (!new Events().__proto__) prefix2 = false;
     }
-  }
-  const prototypeSuccess = await prototypeChanges(updatedParams, updatedFlagName);
-  if (prototypeSuccess) {
-    await handleUserResponse(updatedParams, updatedFlagName);
-  }
-}
-async function prototypeChanges(params, flagNames) {
-  const { flagData, toolkit, ioHelper, recommended, value } = params;
-  const baseContext = new import_toolkit_lib18.CdkAppMultiContext(process.cwd());
-  const baseContextValues = await baseContext.read();
-  const memoryContext = new import_toolkit_lib18.MemoryContext(baseContextValues);
-  const cdkJson = await JSON.parse(await fs40.readFile(path37.join(process.cwd(), "cdk.json"), "utf-8"));
-  const app = cdkJson.app;
-  const source = await toolkit.fromCdkApp(app, {
-    contextStore: baseContext,
-    outdir: path37.join(process.cwd(), "original")
-  });
-  const updateObj = {};
-  const boolValue = toBooleanValue(value);
-  if (flagNames.length === 1 && value !== void 0) {
-    const flagName = flagNames[0];
-    if (baseContextValues[flagName] == boolValue) {
-      await ioHelper.defaults.info("Flag is already set to the specified value. No changes needed.");
-      return false;
+    function EE(fn, context, once) {
+      this.fn = fn;
+      this.context = context;
+      this.once = once || false;
     }
-    updateObj[flagName] = boolValue;
-  } else {
-    for (const flagName of flagNames) {
-      const flag = flagData.find((f3) => f3.name === flagName);
-      if (!flag) {
-        await ioHelper.defaults.error(`Flag ${flagName} not found.`);
-        return false;
+    __name(EE, "EE");
+    function addListener(emitter, event, fn, context, once) {
+      if (typeof fn !== "function") {
+        throw new TypeError("The listener must be a function");
+      }
+      var listener = new EE(fn, context || emitter, once), evt = prefix2 ? prefix2 + event : event;
+      if (!emitter._events[evt]) emitter._events[evt] = listener, emitter._eventsCount++;
+      else if (!emitter._events[evt].fn) emitter._events[evt].push(listener);
+      else emitter._events[evt] = [emitter._events[evt], listener];
+      return emitter;
+    }
+    __name(addListener, "addListener");
+    function clearEvent(emitter, evt) {
+      if (--emitter._eventsCount === 0) emitter._events = new Events();
+      else delete emitter._events[evt];
+    }
+    __name(clearEvent, "clearEvent");
+    function EventEmitter2() {
+      this._events = new Events();
+      this._eventsCount = 0;
+    }
+    __name(EventEmitter2, "EventEmitter");
+    EventEmitter2.prototype.eventNames = /* @__PURE__ */ __name(function eventNames() {
+      var names = [], events, name;
+      if (this._eventsCount === 0) return names;
+      for (name in events = this._events) {
+        if (has.call(events, name)) names.push(prefix2 ? name.slice(1) : name);
       }
-      const newValue = recommended ? toBooleanValue(flag.recommendedValue) : String(flag.unconfiguredBehavesLike?.v2) === "true";
-      updateObj[flagName] = newValue;
-    }
-  }
-  await memoryContext.update(updateObj);
-  const cx = await toolkit.synth(source);
-  const assembly = cx.cloudAssembly;
-  const modifiedSource = await toolkit.fromCdkApp(app, {
-    contextStore: memoryContext,
-    outdir: path37.join(process.cwd(), "temp")
-  });
-  const modifiedCx = await toolkit.synth(modifiedSource);
-  const allStacks = assembly.stacksRecursively;
-  for (const stack of allStacks) {
-    const templatePath = stack.templateFullPath;
-    await toolkit.diff(modifiedCx, {
-      method: import_toolkit_lib18.DiffMethod.LocalFile(templatePath),
-      stacks: {
-        strategy: "pattern-must-match-single" /* PATTERN_MUST_MATCH_SINGLE */,
-        patterns: [stack.hierarchicalId]
+      if (Object.getOwnPropertySymbols) {
+        return names.concat(Object.getOwnPropertySymbols(events));
+      }
+      return names;
+    }, "eventNames");
+    EventEmitter2.prototype.listeners = /* @__PURE__ */ __name(function listeners(event) {
+      var evt = prefix2 ? prefix2 + event : event, handlers = this._events[evt];
+      if (!handlers) return [];
+      if (handlers.fn) return [handlers.fn];
+      for (var i3 = 0, l3 = handlers.length, ee = new Array(l3); i3 < l3; i3++) {
+        ee[i3] = handlers[i3].fn;
+      }
+      return ee;
+    }, "listeners");
+    EventEmitter2.prototype.listenerCount = /* @__PURE__ */ __name(function listenerCount(event) {
+      var evt = prefix2 ? prefix2 + event : event, listeners = this._events[evt];
+      if (!listeners) return 0;
+      if (listeners.fn) return 1;
+      return listeners.length;
+    }, "listenerCount");
+    EventEmitter2.prototype.emit = /* @__PURE__ */ __name(function emit(event, a1, a22, a3, a4, a5) {
+      var evt = prefix2 ? prefix2 + event : event;
+      if (!this._events[evt]) return false;
+      var listeners = this._events[evt], len = arguments.length, args, i3;
+      if (listeners.fn) {
+        if (listeners.once) this.removeListener(event, listeners.fn, void 0, true);
+        switch (len) {
+          case 1:
+            return listeners.fn.call(listeners.context), true;
+          case 2:
+            return listeners.fn.call(listeners.context, a1), true;
+          case 3:
+            return listeners.fn.call(listeners.context, a1, a22), true;
+          case 4:
+            return listeners.fn.call(listeners.context, a1, a22, a3), true;
+          case 5:
+            return listeners.fn.call(listeners.context, a1, a22, a3, a4), true;
+          case 6:
+            return listeners.fn.call(listeners.context, a1, a22, a3, a4, a5), true;
+        }
+        for (i3 = 1, args = new Array(len - 1); i3 < len; i3++) {
+          args[i3 - 1] = arguments[i3];
+        }
+        listeners.fn.apply(listeners.context, args);
+      } else {
+        var length = listeners.length, j3;
+        for (i3 = 0; i3 < length; i3++) {
+          if (listeners[i3].once) this.removeListener(event, listeners[i3].fn, void 0, true);
+          switch (len) {
+            case 1:
+              listeners[i3].fn.call(listeners[i3].context);
+              break;
+            case 2:
+              listeners[i3].fn.call(listeners[i3].context, a1);
+              break;
+            case 3:
+              listeners[i3].fn.call(listeners[i3].context, a1, a22);
+              break;
+            case 4:
+              listeners[i3].fn.call(listeners[i3].context, a1, a22, a3);
+              break;
+            default:
+              if (!args) for (j3 = 1, args = new Array(len - 1); j3 < len; j3++) {
+                args[j3 - 1] = arguments[j3];
+              }
+              listeners[i3].fn.apply(listeners[i3].context, args);
+          }
+        }
       }
-    });
-  }
-  return true;
-}
-async function setMultipleFlags(params) {
-  const { flagData, all } = params;
-  let flagsToSet;
-  if (all) {
-    flagsToSet = flagData.filter((flag) => flag.userValue === void 0 || !isUserValueEqualToRecommended(flag)).filter((flag) => isBooleanFlag(flag)).map((flag) => flag.name);
-  } else {
-    flagsToSet = flagData.filter((flag) => flag.userValue === void 0).filter((flag) => isBooleanFlag(flag)).map((flag) => flag.name);
-  }
-  const prototypeSuccess = await prototypeChanges(params, flagsToSet);
-  if (prototypeSuccess) {
-    await handleUserResponse(params, flagsToSet);
-  }
-}
-async function handleUserResponse(params, flagNames) {
-  const { ioHelper } = params;
-  const userAccepted = await ioHelper.requestResponse({
-    time: /* @__PURE__ */ new Date(),
-    level: "info",
-    code: "CDK_TOOLKIT_I9300",
-    message: "Do you want to accept these changes?",
-    data: {
-      flagNames,
-      responseDescription: 'Enter "y" to apply changes or "n" to cancel'
-    },
-    defaultResponse: false
-  });
-  if (userAccepted) {
-    await modifyValues(params, flagNames);
-    await ioHelper.defaults.info("Flag value(s) updated successfully.");
-  } else {
-    await ioHelper.defaults.info("Operation cancelled");
-  }
-  const originalDir = path37.join(process.cwd(), "original");
-  const tempDir = path37.join(process.cwd(), "temp");
-  await fs40.remove(originalDir);
-  await fs40.remove(tempDir);
-}
-async function modifyValues(params, flagNames) {
-  const { flagData, ioHelper, value, recommended } = params;
-  const cdkJsonPath = path37.join(process.cwd(), "cdk.json");
-  const cdkJsonContent = await fs40.readFile(cdkJsonPath, "utf-8");
-  const cdkJson = JSON.parse(cdkJsonContent);
-  if (flagNames.length == 1) {
-    const boolValue = toBooleanValue(value);
-    cdkJson.context[String(flagNames[0])] = boolValue;
-    await ioHelper.defaults.info(`Setting flag '${flagNames}' to: ${boolValue}`);
-  } else {
-    for (const flagName of flagNames) {
-      const flag = flagData.find((f3) => f3.name === flagName);
-      const newValue = recommended ? toBooleanValue(flag.recommendedValue) : String(flag.unconfiguredBehavesLike?.v2) === "true";
-      cdkJson.context[flagName] = newValue;
+      return true;
+    }, "emit");
+    EventEmitter2.prototype.on = /* @__PURE__ */ __name(function on(event, fn, context) {
+      return addListener(this, event, fn, context, false);
+    }, "on");
+    EventEmitter2.prototype.once = /* @__PURE__ */ __name(function once(event, fn, context) {
+      return addListener(this, event, fn, context, true);
+    }, "once");
+    EventEmitter2.prototype.removeListener = /* @__PURE__ */ __name(function removeListener(event, fn, context, once) {
+      var evt = prefix2 ? prefix2 + event : event;
+      if (!this._events[evt]) return this;
+      if (!fn) {
+        clearEvent(this, evt);
+        return this;
+      }
+      var listeners = this._events[evt];
+      if (listeners.fn) {
+        if (listeners.fn === fn && (!once || listeners.once) && (!context || listeners.context === context)) {
+          clearEvent(this, evt);
+        }
+      } else {
+        for (var i3 = 0, events = [], length = listeners.length; i3 < length; i3++) {
+          if (listeners[i3].fn !== fn || once && !listeners[i3].once || context && listeners[i3].context !== context) {
+            events.push(listeners[i3]);
+          }
+        }
+        if (events.length) this._events[evt] = events.length === 1 ? events[0] : events;
+        else clearEvent(this, evt);
+      }
+      return this;
+    }, "removeListener");
+    EventEmitter2.prototype.removeAllListeners = /* @__PURE__ */ __name(function removeAllListeners(event) {
+      var evt;
+      if (event) {
+        evt = prefix2 ? prefix2 + event : event;
+        if (this._events[evt]) clearEvent(this, evt);
+      } else {
+        this._events = new Events();
+        this._eventsCount = 0;
+      }
+      return this;
+    }, "removeAllListeners");
+    EventEmitter2.prototype.off = EventEmitter2.prototype.removeListener;
+    EventEmitter2.prototype.addListener = EventEmitter2.prototype.on;
+    EventEmitter2.prefixed = prefix2;
+    EventEmitter2.EventEmitter = EventEmitter2;
+    if ("undefined" !== typeof module2) {
+      module2.exports = EventEmitter2;
     }
   }
-  await fs40.writeFile(cdkJsonPath, JSON.stringify(cdkJson, null, 2), "utf-8");
-}
-function getFlagSortOrder(flag) {
-  if (flag.userValue === void 0) {
-    return 3;
-  } else if (isUserValueEqualToRecommended(flag)) {
-    return 1;
-  } else {
-    return 2;
-  }
-}
-async function displayFlagTable(flags, ioHelper) {
-  const filteredFlags = flags.filter((flag) => flag.unconfiguredBehavesLike?.v2 !== flag.recommendedValue);
-  const sortedFlags = [...filteredFlags].sort((a3, b3) => {
-    const orderA = getFlagSortOrder(a3);
-    const orderB = getFlagSortOrder(b3);
-    if (orderA !== orderB) {
-      return orderA - orderB;
-    }
-    if (a3.module !== b3.module) {
-      return a3.module.localeCompare(b3.module);
-    }
-    return a3.name.localeCompare(b3.name);
-  });
-  const rows = [];
-  rows.push(["Feature Flag Name", "Recommended Value", "User Value"]);
-  let currentModule = "";
-  sortedFlags.forEach((flag) => {
-    if (flag.module !== currentModule) {
-      rows.push([chalk34.bold(`Module: ${flag.module}`), "", ""]);
-      currentModule = flag.module;
-    }
-    rows.push([
-      `  ${flag.name}`,
-      String(flag.recommendedValue),
-      flag.userValue === void 0 ? "<unset>" : String(flag.userValue)
-    ]);
-  });
-  const formattedTable = (0, import_cloudformation_diff4.formatTable)(rows, void 0, true);
-  await ioHelper.defaults.info(formattedTable);
-}
-async function displayFlags(params) {
-  const { flagData, ioHelper, flagName, all } = params;
-  if (flagName && flagName.length > 0) {
-    const matchingFlags = flagData.filter(
-      (f3) => flagName.some((searchTerm) => f3.name.toLowerCase().includes(searchTerm.toLowerCase()))
-    );
-    if (matchingFlags.length === 0) {
-      await ioHelper.defaults.error(`Flag matching "${flagName.join(", ")}" not found.`);
-      return;
-    }
-    if (matchingFlags.length === 1) {
-      const flag = matchingFlags[0];
-      await ioHelper.defaults.info(`Flag name: ${flag.name}`);
-      await ioHelper.defaults.info(`Description: ${flag.explanation}`);
-      await ioHelper.defaults.info(`Recommended value: ${flag.recommendedValue}`);
-      await ioHelper.defaults.info(`User value: ${flag.userValue}`);
-      return;
-    }
-    await ioHelper.defaults.info(`Found ${matchingFlags.length} flags matching "${flagName.join(", ")}":`);
-    await displayFlagTable(matchingFlags, ioHelper);
-    return;
+});
+
+// ../../node_modules/p-finally/index.js
+var require_p_finally = __commonJS({
+  "../../node_modules/p-finally/index.js"(exports2, module2) {
+    "use strict";
+    module2.exports = (promise, onFinally) => {
+      onFinally = onFinally || (() => {
+      });
+      return promise.then(
+        (val) => new Promise((resolve13) => {
+          resolve13(onFinally());
+        }).then(() => val),
+        (err) => new Promise((resolve13) => {
+          resolve13(onFinally());
+        }).then(() => {
+          throw err;
+        })
+      );
+    };
   }
-  let flagsToDisplay;
-  if (all) {
-    flagsToDisplay = flagData;
-  } else {
-    flagsToDisplay = flagData.filter(
-      (flag) => flag.userValue === void 0 || !isUserValueEqualToRecommended(flag)
-    );
+});
+
+// ../../node_modules/p-timeout/index.js
+var require_p_timeout = __commonJS({
+  "../../node_modules/p-timeout/index.js"(exports2, module2) {
+    "use strict";
+    var pFinally = require_p_finally();
+    var TimeoutError = class extends Error {
+      static {
+        __name(this, "TimeoutError");
+      }
+      constructor(message2) {
+        super(message2);
+        this.name = "TimeoutError";
+      }
+    };
+    var pTimeout = /* @__PURE__ */ __name((promise, milliseconds, fallback) => new Promise((resolve13, reject) => {
+      if (typeof milliseconds !== "number" || milliseconds < 0) {
+        throw new TypeError("Expected `milliseconds` to be a positive number");
+      }
+      if (milliseconds === Infinity) {
+        resolve13(promise);
+        return;
+      }
+      const timer = setTimeout(() => {
+        if (typeof fallback === "function") {
+          try {
+            resolve13(fallback());
+          } catch (error5) {
+            reject(error5);
+          }
+          return;
+        }
+        const message2 = typeof fallback === "string" ? fallback : `Promise timed out after ${milliseconds} milliseconds`;
+        const timeoutError = fallback instanceof Error ? fallback : new TimeoutError(message2);
+        if (typeof promise.cancel === "function") {
+          promise.cancel();
+        }
+        reject(timeoutError);
+      }, milliseconds);
+      pFinally(
+        // eslint-disable-next-line promise/prefer-await-to-then
+        promise.then(resolve13, reject),
+        () => {
+          clearTimeout(timer);
+        }
+      );
+    }), "pTimeout");
+    module2.exports = pTimeout;
+    module2.exports.default = pTimeout;
+    module2.exports.TimeoutError = TimeoutError;
   }
-  await displayFlagTable(flagsToDisplay, ioHelper);
-  if (!all && flagsToDisplay.length === 0) {
-    await ioHelper.defaults.info("");
-    await ioHelper.defaults.info("\u2705 All feature flags are already set to their recommended values.");
-    await ioHelper.defaults.info("Use 'cdk flags --all --unstable=flags' to see all flags and their current values.");
+});
+
+// ../../node_modules/p-queue/dist/lower-bound.js
+var require_lower_bound = __commonJS({
+  "../../node_modules/p-queue/dist/lower-bound.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    function lowerBound(array, value, comparator) {
+      let first = 0;
+      let count = array.length;
+      while (count > 0) {
+        const step = count / 2 | 0;
+        let it = first + step;
+        if (comparator(array[it], value) <= 0) {
+          first = ++it;
+          count -= step + 1;
+        } else {
+          count = step;
+        }
+      }
+      return first;
+    }
+    __name(lowerBound, "lowerBound");
+    exports2.default = lowerBound;
   }
-}
-function isUserValueEqualToRecommended(flag) {
-  return String(flag.userValue) === String(flag.recommendedValue);
-}
-function toBooleanValue(value) {
-  if (typeof value === "boolean") {
-    return value;
+});
+
+// ../../node_modules/p-queue/dist/priority-queue.js
+var require_priority_queue = __commonJS({
+  "../../node_modules/p-queue/dist/priority-queue.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    var lower_bound_1 = require_lower_bound();
+    var PriorityQueue = class {
+      static {
+        __name(this, "PriorityQueue");
+      }
+      constructor() {
+        this._queue = [];
+      }
+      enqueue(run, options) {
+        options = Object.assign({ priority: 0 }, options);
+        const element = {
+          priority: options.priority,
+          run
+        };
+        if (this.size && this._queue[this.size - 1].priority >= options.priority) {
+          this._queue.push(element);
+          return;
+        }
+        const index = lower_bound_1.default(this._queue, element, (a3, b3) => b3.priority - a3.priority);
+        this._queue.splice(index, 0, element);
+      }
+      dequeue() {
+        const item = this._queue.shift();
+        return item === null || item === void 0 ? void 0 : item.run;
+      }
+      filter(options) {
+        return this._queue.filter((element) => element.priority === options.priority).map((element) => element.run);
+      }
+      get size() {
+        return this._queue.length;
+      }
+    };
+    exports2.default = PriorityQueue;
   }
-  if (typeof value === "string") {
-    return value.toLowerCase() === "true";
+});
+
+// ../../node_modules/p-queue/dist/index.js
+var require_dist3 = __commonJS({
+  "../../node_modules/p-queue/dist/index.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    var EventEmitter2 = require_eventemitter3();
+    var p_timeout_1 = require_p_timeout();
+    var priority_queue_1 = require_priority_queue();
+    var empty = /* @__PURE__ */ __name(() => {
+    }, "empty");
+    var timeoutError = new p_timeout_1.TimeoutError();
+    var PQueue2 = class extends EventEmitter2 {
+      static {
+        __name(this, "PQueue");
+      }
+      constructor(options) {
+        var _a2, _b, _c, _d;
+        super();
+        this._intervalCount = 0;
+        this._intervalEnd = 0;
+        this._pendingCount = 0;
+        this._resolveEmpty = empty;
+        this._resolveIdle = empty;
+        options = Object.assign({ carryoverConcurrencyCount: false, intervalCap: Infinity, interval: 0, concurrency: Infinity, autoStart: true, queueClass: priority_queue_1.default }, options);
+        if (!(typeof options.intervalCap === "number" && options.intervalCap >= 1)) {
+          throw new TypeError(`Expected \`intervalCap\` to be a number from 1 and up, got \`${(_b = (_a2 = options.intervalCap) === null || _a2 === void 0 ? void 0 : _a2.toString()) !== null && _b !== void 0 ? _b : ""}\` (${typeof options.intervalCap})`);
+        }
+        if (options.interval === void 0 || !(Number.isFinite(options.interval) && options.interval >= 0)) {
+          throw new TypeError(`Expected \`interval\` to be a finite number >= 0, got \`${(_d = (_c = options.interval) === null || _c === void 0 ? void 0 : _c.toString()) !== null && _d !== void 0 ? _d : ""}\` (${typeof options.interval})`);
+        }
+        this._carryoverConcurrencyCount = options.carryoverConcurrencyCount;
+        this._isIntervalIgnored = options.intervalCap === Infinity || options.interval === 0;
+        this._intervalCap = options.intervalCap;
+        this._interval = options.interval;
+        this._queue = new options.queueClass();
+        this._queueClass = options.queueClass;
+        this.concurrency = options.concurrency;
+        this._timeout = options.timeout;
+        this._throwOnTimeout = options.throwOnTimeout === true;
+        this._isPaused = options.autoStart === false;
+      }
+      get _doesIntervalAllowAnother() {
+        return this._isIntervalIgnored || this._intervalCount < this._intervalCap;
+      }
+      get _doesConcurrentAllowAnother() {
+        return this._pendingCount < this._concurrency;
+      }
+      _next() {
+        this._pendingCount--;
+        this._tryToStartAnother();
+        this.emit("next");
+      }
+      _resolvePromises() {
+        this._resolveEmpty();
+        this._resolveEmpty = empty;
+        if (this._pendingCount === 0) {
+          this._resolveIdle();
+          this._resolveIdle = empty;
+          this.emit("idle");
+        }
+      }
+      _onResumeInterval() {
+        this._onInterval();
+        this._initializeIntervalIfNeeded();
+        this._timeoutId = void 0;
+      }
+      _isIntervalPaused() {
+        const now = Date.now();
+        if (this._intervalId === void 0) {
+          const delay = this._intervalEnd - now;
+          if (delay < 0) {
+            this._intervalCount = this._carryoverConcurrencyCount ? this._pendingCount : 0;
+          } else {
+            if (this._timeoutId === void 0) {
+              this._timeoutId = setTimeout(() => {
+                this._onResumeInterval();
+              }, delay);
+            }
+            return true;
+          }
+        }
+        return false;
+      }
+      _tryToStartAnother() {
+        if (this._queue.size === 0) {
+          if (this._intervalId) {
+            clearInterval(this._intervalId);
+          }
+          this._intervalId = void 0;
+          this._resolvePromises();
+          return false;
+        }
+        if (!this._isPaused) {
+          const canInitializeInterval = !this._isIntervalPaused();
+          if (this._doesIntervalAllowAnother && this._doesConcurrentAllowAnother) {
+            const job = this._queue.dequeue();
+            if (!job) {
+              return false;
+            }
+            this.emit("active");
+            job();
+            if (canInitializeInterval) {
+              this._initializeIntervalIfNeeded();
+            }
+            return true;
+          }
+        }
+        return false;
+      }
+      _initializeIntervalIfNeeded() {
+        if (this._isIntervalIgnored || this._intervalId !== void 0) {
+          return;
+        }
+        this._intervalId = setInterval(() => {
+          this._onInterval();
+        }, this._interval);
+        this._intervalEnd = Date.now() + this._interval;
+      }
+      _onInterval() {
+        if (this._intervalCount === 0 && this._pendingCount === 0 && this._intervalId) {
+          clearInterval(this._intervalId);
+          this._intervalId = void 0;
+        }
+        this._intervalCount = this._carryoverConcurrencyCount ? this._pendingCount : 0;
+        this._processQueue();
+      }
+      /**
+      Executes all queued functions until it reaches the limit.
+      */
+      _processQueue() {
+        while (this._tryToStartAnother()) {
+        }
+      }
+      get concurrency() {
+        return this._concurrency;
+      }
+      set concurrency(newConcurrency) {
+        if (!(typeof newConcurrency === "number" && newConcurrency >= 1)) {
+          throw new TypeError(`Expected \`concurrency\` to be a number from 1 and up, got \`${newConcurrency}\` (${typeof newConcurrency})`);
+        }
+        this._concurrency = newConcurrency;
+        this._processQueue();
+      }
+      /**
+      Adds a sync or async task to the queue. Always returns a promise.
+      */
+      async add(fn, options = {}) {
+        return new Promise((resolve13, reject) => {
+          const run = /* @__PURE__ */ __name(async () => {
+            this._pendingCount++;
+            this._intervalCount++;
+            try {
+              const operation = this._timeout === void 0 && options.timeout === void 0 ? fn() : p_timeout_1.default(Promise.resolve(fn()), options.timeout === void 0 ? this._timeout : options.timeout, () => {
+                if (options.throwOnTimeout === void 0 ? this._throwOnTimeout : options.throwOnTimeout) {
+                  reject(timeoutError);
+                }
+                return void 0;
+              });
+              resolve13(await operation);
+            } catch (error5) {
+              reject(error5);
+            }
+            this._next();
+          }, "run");
+          this._queue.enqueue(run, options);
+          this._tryToStartAnother();
+          this.emit("add");
+        });
+      }
+      /**
+          Same as `.add()`, but accepts an array of sync or async functions.
+      
+          @returns A promise that resolves when all functions are resolved.
+          */
+      async addAll(functions, options) {
+        return Promise.all(functions.map(async (function_) => this.add(function_, options)));
+      }
+      /**
+      Start (or resume) executing enqueued tasks within concurrency limit. No need to call this if queue is not paused (via `options.autoStart = false` or by `.pause()` method.)
+      */
+      start() {
+        if (!this._isPaused) {
+          return this;
+        }
+        this._isPaused = false;
+        this._processQueue();
+        return this;
+      }
+      /**
+      Put queue execution on hold.
+      */
+      pause() {
+        this._isPaused = true;
+      }
+      /**
+      Clear the queue.
+      */
+      clear() {
+        this._queue = new this._queueClass();
+      }
+      /**
+          Can be called multiple times. Useful if you for example add additional items at a later time.
+      
+          @returns A promise that settles when the queue becomes empty.
+          */
+      async onEmpty() {
+        if (this._queue.size === 0) {
+          return;
+        }
+        return new Promise((resolve13) => {
+          const existingResolve = this._resolveEmpty;
+          this._resolveEmpty = () => {
+            existingResolve();
+            resolve13();
+          };
+        });
+      }
+      /**
+          The difference with `.onEmpty` is that `.onIdle` guarantees that all work from the queue has finished. `.onEmpty` merely signals that the queue is empty, but it could mean that some promises haven't completed yet.
+      
+          @returns A promise that settles when the queue becomes empty, and all promises have completed; `queue.size === 0 && queue.pending === 0`.
+          */
+      async onIdle() {
+        if (this._pendingCount === 0 && this._queue.size === 0) {
+          return;
+        }
+        return new Promise((resolve13) => {
+          const existingResolve = this._resolveIdle;
+          this._resolveIdle = () => {
+            existingResolve();
+            resolve13();
+          };
+        });
+      }
+      /**
+      Size of the queue.
+      */
+      get size() {
+        return this._queue.size;
+      }
+      /**
+          Size of the queue, filtered by the given options.
+      
+          For example, this can be used to find the number of items remaining in the queue with a specific priority level.
+          */
+      sizeBy(options) {
+        return this._queue.filter(options).length;
+      }
+      /**
+      Number of pending promises.
+      */
+      get pending() {
+        return this._pendingCount;
+      }
+      /**
+      Whether the queue is currently paused.
+      */
+      get isPaused() {
+        return this._isPaused;
+      }
+      get timeout() {
+        return this._timeout;
+      }
+      /**
+      Set the timeout for future operations.
+      */
+      set timeout(milliseconds) {
+        this._timeout = milliseconds;
+      }
+    };
+    exports2.default = PQueue2;
   }
-  return false;
-}
-function isBooleanFlag(flag) {
-  const recommended = flag.recommendedValue;
-  return typeof recommended === "boolean" || recommended === "true" || recommended === "false";
-}
-var path37, import_cloudformation_diff4, import_toolkit_lib18, chalk34, import_enquirer, fs40, FlagsMenuOptions;
-var init_flag_operations = __esm({
-  "lib/commands/flag-operations.ts"() {
+});
+
+// lib/commands/flags/operations.ts
+var os12, path37, import_cloudformation_diff4, import_toolkit_lib18, chalk34, fs40, import_p_queue, FlagOperations;
+var init_operations = __esm({
+  "lib/commands/flags/operations.ts"() {
     "use strict";
+    os12 = __toESM(require("os"));
     path37 = __toESM(require("path"));
     import_cloudformation_diff4 = __toESM(require_lib11());
     import_toolkit_lib18 = __toESM(require_lib12());
     chalk34 = __toESM(require_source());
-    import_enquirer = __toESM(require_enquirer());
     fs40 = __toESM(require_lib13());
+    import_p_queue = __toESM(require_dist3());
     init_api();
+    FlagOperations = class {
+      constructor(flags, toolkit, ioHelper) {
+        this.flags = flags;
+        this.toolkit = toolkit;
+        this.ioHelper = ioHelper;
+        this.app = "";
+        this.baseContextValues = {};
+        this.allStacks = [];
+        this.queue = new import_p_queue.default({ concurrency: 4 });
+      }
+      static {
+        __name(this, "FlagOperations");
+      }
+      /** Main entry point that routes to either flag setting or display operations */
+      async execute(params) {
+        if (params.set) {
+          if (params.FLAGNAME && params.value) {
+            await this.setFlag(params);
+          } else {
+            await this.setMultipleFlags(params);
+          }
+        } else {
+          await this.displayFlags(params);
+        }
+      }
+      /** Sets a single specific flag with validation and user confirmation */
+      async setFlag(params) {
+        const flagName = params.FLAGNAME[0];
+        const flag = this.flags.find((f3) => f3.name === flagName);
+        if (!flag) {
+          await this.ioHelper.defaults.error("Flag not found.");
+          return;
+        }
+        if (!this.isBooleanFlag(flag)) {
+          await this.ioHelper.defaults.error(`Flag '${flagName}' is not a boolean flag. Only boolean flags are currently supported.`);
+          return;
+        }
+        const prototypeSuccess = await this.prototypeChanges([flagName], params);
+        if (prototypeSuccess) {
+          await this.handleUserResponse([flagName], params);
+        }
+      }
+      /** Sets multiple flags (all or unconfigured) with validation and user confirmation */
+      async setMultipleFlags(params) {
+        if (params.default && !this.flags.some((f3) => f3.unconfiguredBehavesLike)) {
+          await this.ioHelper.defaults.error("The --default options are not compatible with the AWS CDK library used by your application. Please upgrade to 2.212.0 or above.");
+          return;
+        }
+        const flagsToSet = this.getFlagsToSet(params);
+        const prototypeSuccess = await this.prototypeChanges(flagsToSet, params);
+        if (prototypeSuccess) {
+          await this.handleUserResponse(flagsToSet, params);
+        }
+      }
+      /** Determines which flags should be set based on the provided parameters */
+      getFlagsToSet(params) {
+        if (params.all && params.default) {
+          return this.flags.filter((flag) => this.isBooleanFlag(flag)).map((flag) => flag.name);
+        } else if (params.all) {
+          return this.flags.filter((flag) => flag.userValue === void 0 || !this.isUserValueEqualToRecommended(flag)).filter((flag) => this.isBooleanFlag(flag)).map((flag) => flag.name);
+        } else {
+          return this.flags.filter((flag) => flag.userValue === void 0).filter((flag) => this.isBooleanFlag(flag)).map((flag) => flag.name);
+        }
+      }
+      /** Sets flags that don't cause template changes */
+      async setSafeFlags(params) {
+        const cdkJson = await JSON.parse(await fs40.readFile(path37.join(process.cwd(), "cdk.json"), "utf-8"));
+        this.app = params.app || cdkJson.app;
+        const isUsingTsNode = this.app.includes("ts-node");
+        if (isUsingTsNode && !this.app.includes("-T") && !this.app.includes("--transpileOnly")) {
+          await this.ioHelper.defaults.info(`Repeated synths with ts-node will type-check the application on every synth. Add --transpileOnly to cdk.json's "app" command to make this operation faster.`);
+        }
+        const unconfiguredFlags = this.flags.filter((flag) => flag.userValue === void 0 && this.isBooleanFlag(flag));
+        if (unconfiguredFlags.length === 0) {
+          await this.ioHelper.defaults.info("All feature flags are configured.");
+          return;
+        }
+        await this.initializeSafetyCheck();
+        const safeFlags = await this.batchTestFlags(unconfiguredFlags);
+        await this.cleanupSafetyCheck();
+        if (safeFlags.length > 0) {
+          await this.ioHelper.defaults.info("Flags that can be set without template changes:");
+          for (const flag of safeFlags) {
+            await this.ioHelper.defaults.info(`- ${flag.name} -> ${flag.recommendedValue}`);
+          }
+          await this.handleUserResponse(safeFlags.map((flag) => flag.name), { ...params, recommended: true });
+        } else {
+          await this.ioHelper.defaults.info("No more flags can be set without causing template changes.");
+        }
+      }
+      /** Initializes the safety check by reading context and synthesizing baseline templates */
+      async initializeSafetyCheck() {
+        const baseContext = new import_toolkit_lib18.CdkAppMultiContext(process.cwd());
+        this.baseContextValues = await baseContext.read();
+        this.baselineTempDir = fs40.mkdtempSync(path37.join(os12.tmpdir(), "cdk-baseline-"));
+        const baseSource = await this.toolkit.fromCdkApp(this.app, {
+          contextStore: baseContext,
+          outdir: this.baselineTempDir
+        });
+        const baseCx = await this.toolkit.synth(baseSource);
+        const baseAssembly = baseCx.cloudAssembly;
+        this.allStacks = baseAssembly.stacksRecursively;
+        this.queue = new import_p_queue.default({ concurrency: 4 });
+      }
+      /** Cleans up temporary directories created during safety checks */
+      async cleanupSafetyCheck() {
+        if (this.baselineTempDir) {
+          await fs40.remove(this.baselineTempDir);
+          this.baselineTempDir = void 0;
+        }
+      }
+      /** Tests multiple flags together and isolates unsafe ones using binary search */
+      async batchTestFlags(flags) {
+        if (flags.length === 0) return [];
+        const allFlagsContext = { ...this.baseContextValues };
+        flags.forEach((flag) => {
+          allFlagsContext[flag.name] = flag.recommendedValue;
+        });
+        const allSafe = await this.testBatch(allFlagsContext);
+        if (allSafe) return flags;
+        return this.isolateUnsafeFlags(flags);
+      }
+      /** Tests if a set of context values causes template changes by synthesizing and diffing */
+      async testBatch(contextValues) {
+        const testContext = new import_toolkit_lib18.MemoryContext(contextValues);
+        const tempDir = fs40.mkdtempSync(path37.join(os12.tmpdir(), "cdk-test-"));
+        const testSource = await this.toolkit.fromCdkApp(this.app, {
+          contextStore: testContext,
+          outdir: tempDir
+        });
+        const testCx = await this.toolkit.synth(testSource);
+        try {
+          for (const stack of this.allStacks) {
+            const templatePath = stack.templateFullPath;
+            const diff = await this.toolkit.diff(testCx, {
+              method: import_toolkit_lib18.DiffMethod.LocalFile(templatePath),
+              stacks: {
+                strategy: "pattern-must-match-single" /* PATTERN_MUST_MATCH_SINGLE */,
+                patterns: [stack.hierarchicalId]
+              }
+            });
+            for (const stackDiff of Object.values(diff)) {
+              if (stackDiff.differenceCount > 0) {
+                return false;
+              }
+            }
+          }
+          return true;
+        } finally {
+          await fs40.remove(tempDir);
+        }
+      }
+      /** Uses binary search to isolate which flags are safe to set without template changes */
+      async isolateUnsafeFlags(flags) {
+        const safeFlags = [];
+        const processBatch = /* @__PURE__ */ __name(async (batch, contextValues) => {
+          if (batch.length === 1) {
+            const isSafe = await this.testBatch(
+              { ...contextValues, [batch[0].name]: batch[0].recommendedValue }
+            );
+            if (isSafe) safeFlags.push(batch[0]);
+            return;
+          }
+          const batchContext = { ...contextValues };
+          batch.forEach((flag) => {
+            batchContext[flag.name] = flag.recommendedValue;
+          });
+          const isSafeBatch = await this.testBatch(batchContext);
+          if (isSafeBatch) {
+            safeFlags.push(...batch);
+            return;
+          }
+          const mid = Math.floor(batch.length / 2);
+          const left = batch.slice(0, mid);
+          const right = batch.slice(mid);
+          void this.queue.add(() => processBatch(left, contextValues));
+          void this.queue.add(() => processBatch(right, contextValues));
+        }, "processBatch");
+        void this.queue.add(() => processBatch(flags, this.baseContextValues));
+        await this.queue.onIdle();
+        return safeFlags;
+      }
+      /** Prototypes flag changes by synthesizing templates and showing diffs to the user */
+      async prototypeChanges(flagNames, params) {
+        const baseContext = new import_toolkit_lib18.CdkAppMultiContext(process.cwd());
+        const baseContextValues = await baseContext.read();
+        const memoryContext = new import_toolkit_lib18.MemoryContext(baseContextValues);
+        const cdkJson = await JSON.parse(await fs40.readFile(path37.join(process.cwd(), "cdk.json"), "utf-8"));
+        const app = cdkJson.app;
+        const source = await this.toolkit.fromCdkApp(app, {
+          contextStore: baseContext,
+          outdir: fs40.mkdtempSync(path37.join(os12.tmpdir(), "cdk-original-"))
+        });
+        const updateObj = await this.buildUpdateObject(flagNames, params, baseContextValues);
+        if (!updateObj) return false;
+        await memoryContext.update(updateObj);
+        const cx = await this.toolkit.synth(source);
+        const assembly = cx.cloudAssembly;
+        const modifiedSource = await this.toolkit.fromCdkApp(app, {
+          contextStore: memoryContext,
+          outdir: fs40.mkdtempSync(path37.join(os12.tmpdir(), "cdk-temp-"))
+        });
+        const modifiedCx = await this.toolkit.synth(modifiedSource);
+        const allStacks = assembly.stacksRecursively;
+        for (const stack of allStacks) {
+          const templatePath = stack.templateFullPath;
+          await this.toolkit.diff(modifiedCx, {
+            method: import_toolkit_lib18.DiffMethod.LocalFile(templatePath),
+            stacks: {
+              strategy: "pattern-must-match-single" /* PATTERN_MUST_MATCH_SINGLE */,
+              patterns: [stack.hierarchicalId]
+            }
+          });
+        }
+        await this.displayFlagChanges(updateObj, baseContextValues);
+        return true;
+      }
+      /** Displays a summary of flag changes showing old and new values */
+      async displayFlagChanges(updateObj, baseContextValues) {
+        await this.ioHelper.defaults.info("\nFlag changes:");
+        for (const [flagName, newValue] of Object.entries(updateObj)) {
+          const currentValue = baseContextValues[flagName];
+          const currentDisplay = currentValue === void 0 ? "<unset>" : String(currentValue);
+          await this.ioHelper.defaults.info(`  ${flagName}: ${currentDisplay} \u2192 ${newValue}`);
+        }
+      }
+      /** Builds the update object with new flag values based on parameters and current context */
+      async buildUpdateObject(flagNames, params, baseContextValues) {
+        const updateObj = {};
+        if (flagNames.length === 1 && params.value !== void 0) {
+          const flagName = flagNames[0];
+          const boolValue = params.value === "true";
+          if (baseContextValues[flagName] === boolValue) {
+            await this.ioHelper.defaults.info("Flag is already set to the specified value. No changes needed.");
+            return null;
+          }
+          updateObj[flagName] = boolValue;
+        } else {
+          for (const flagName of flagNames) {
+            const flag = this.flags.find((f3) => f3.name === flagName);
+            if (!flag) {
+              await this.ioHelper.defaults.error(`Flag ${flagName} not found.`);
+              return null;
+            }
+            const newValue = params.recommended ? flag.recommendedValue : String(flag.unconfiguredBehavesLike?.v2) === "true";
+            updateObj[flagName] = newValue;
+          }
+        }
+        return updateObj;
+      }
+      /** Prompts user for confirmation and applies changes if accepted */
+      async handleUserResponse(flagNames, params) {
+        const userAccepted = await this.ioHelper.requestResponse({
+          time: /* @__PURE__ */ new Date(),
+          level: "info",
+          code: "CDK_TOOLKIT_I9300",
+          message: "Do you want to accept these changes?",
+          data: {
+            flagNames,
+            responseDescription: 'Enter "y" to apply changes or "n" to cancel'
+          },
+          defaultResponse: false
+        });
+        if (userAccepted) {
+          await this.modifyValues(flagNames, params);
+          await this.ioHelper.defaults.info("Flag value(s) updated successfully.");
+        } else {
+          await this.ioHelper.defaults.info("Operation cancelled");
+        }
+        await this.cleanupTempDirectories();
+      }
+      /** Removes temporary directories created during flag operations */
+      async cleanupTempDirectories() {
+        const originalDir = path37.join(process.cwd(), "original");
+        const tempDir = path37.join(process.cwd(), "temp");
+        await fs40.remove(originalDir);
+        await fs40.remove(tempDir);
+      }
+      /** Actually modifies the cdk.json file with the new flag values */
+      async modifyValues(flagNames, params) {
+        const cdkJsonPath = path37.join(process.cwd(), "cdk.json");
+        const cdkJsonContent = await fs40.readFile(cdkJsonPath, "utf-8");
+        const cdkJson = JSON.parse(cdkJsonContent);
+        if (flagNames.length === 1 && !params.safe) {
+          const boolValue = params.value === "true";
+          cdkJson.context[String(flagNames[0])] = boolValue;
+          await this.ioHelper.defaults.info(`Setting flag '${flagNames}' to: ${boolValue}`);
+        } else {
+          for (const flagName of flagNames) {
+            const flag = this.flags.find((f3) => f3.name === flagName);
+            const newValue = params.recommended || params.safe ? flag.recommendedValue : String(flag.unconfiguredBehavesLike?.v2) === "true";
+            cdkJson.context[flagName] = newValue;
+          }
+        }
+        await fs40.writeFile(cdkJsonPath, JSON.stringify(cdkJson, null, 2), "utf-8");
+      }
+      /** Displays flags in a table format, either specific flags or filtered by criteria */
+      async displayFlags(params) {
+        const { FLAGNAME, all } = params;
+        if (FLAGNAME && FLAGNAME.length > 0) {
+          await this.displaySpecificFlags(FLAGNAME);
+          return;
+        }
+        const flagsToDisplay = all ? this.flags : this.flags.filter((flag) => flag.userValue === void 0 || !this.isUserValueEqualToRecommended(flag));
+        await this.displayFlagTable(flagsToDisplay);
+        if (!all && flagsToDisplay.length === 0) {
+          await this.ioHelper.defaults.info("");
+          await this.ioHelper.defaults.info("\u2705 All feature flags are already set to their recommended values.");
+          await this.ioHelper.defaults.info("Use 'cdk flags --all --unstable=flags' to see all flags and their current values.");
+        }
+      }
+      /** Displays detailed information for specific flags matching the given names */
+      async displaySpecificFlags(flagNames) {
+        const matchingFlags = this.flags.filter((f3) => flagNames.some((searchTerm) => f3.name.toLowerCase().includes(searchTerm.toLowerCase())));
+        if (matchingFlags.length === 0) {
+          await this.ioHelper.defaults.error(`Flag matching "${flagNames.join(", ")}" not found.`);
+          return;
+        }
+        if (matchingFlags.length === 1) {
+          const flag = matchingFlags[0];
+          await this.ioHelper.defaults.info(`Flag name: ${flag.name}`);
+          await this.ioHelper.defaults.info(`Description: ${flag.explanation}`);
+          await this.ioHelper.defaults.info(`Recommended value: ${flag.recommendedValue}`);
+          await this.ioHelper.defaults.info(`User value: ${flag.userValue}`);
+          return;
+        }
+        await this.ioHelper.defaults.info(`Found ${matchingFlags.length} flags matching "${flagNames.join(", ")}":`);
+        await this.displayFlagTable(matchingFlags);
+      }
+      /** Returns sort order for flags */
+      getFlagSortOrder(flag) {
+        if (flag.userValue === void 0) return 3;
+        if (this.isUserValueEqualToRecommended(flag)) return 1;
+        return 2;
+      }
+      /** Displays flags in a formatted table grouped by module and sorted */
+      async displayFlagTable(flags) {
+        const sortedFlags = [...flags].sort((a3, b3) => {
+          const orderA = this.getFlagSortOrder(a3);
+          const orderB = this.getFlagSortOrder(b3);
+          if (orderA !== orderB) return orderA - orderB;
+          if (a3.module !== b3.module) return a3.module.localeCompare(b3.module);
+          return a3.name.localeCompare(b3.name);
+        });
+        const rows = [["Feature Flag Name", "Recommended Value", "User Value"]];
+        let currentModule = "";
+        sortedFlags.forEach((flag) => {
+          if (flag.module !== currentModule) {
+            rows.push([chalk34.bold(`Module: ${flag.module}`), "", ""]);
+            currentModule = flag.module;
+          }
+          rows.push([
+            `  ${flag.name}`,
+            String(flag.recommendedValue),
+            flag.userValue === void 0 ? "<unset>" : String(flag.userValue)
+          ]);
+        });
+        const formattedTable = (0, import_cloudformation_diff4.formatTable)(rows, void 0, true);
+        await this.ioHelper.defaults.info(formattedTable);
+      }
+      /** Checks if a flag has a boolean recommended value */
+      isBooleanFlag(flag) {
+        const recommended = flag.recommendedValue;
+        return typeof recommended === "boolean" || recommended === "true" || recommended === "false";
+      }
+      /** Checks if the user's current value matches the recommended value */
+      isUserValueEqualToRecommended(flag) {
+        return String(flag.userValue) === String(flag.recommendedValue);
+      }
+      /** Shows helpful usage examples and available command options */
+      async displayHelpMessage() {
+        await this.ioHelper.defaults.info("\n" + chalk34.bold("Available options:"));
+        await this.ioHelper.defaults.info("  cdk flags --interactive     # Interactive menu to manage flags");
+        await this.ioHelper.defaults.info("  cdk flags --all             # Show all flags (including configured ones)");
+        await this.ioHelper.defaults.info("  cdk flags --set --all --recommended    # Set all flags to recommended values");
+        await this.ioHelper.defaults.info("  cdk flags --set --all --default       # Set all flags to default values");
+        await this.ioHelper.defaults.info("  cdk flags --set --unconfigured --recommended  # Set unconfigured flags to recommended");
+        await this.ioHelper.defaults.info("  cdk flags --set <flag-name> --value <true|false>  # Set specific flag");
+        await this.ioHelper.defaults.info("  cdk flags --safe            # Safely set flags that don't change templates");
+      }
+    };
+  }
+});
+
+// lib/commands/flags/router.ts
+var FlagOperationRouter;
+var init_router = __esm({
+  "lib/commands/flags/router.ts"() {
+    "use strict";
+    FlagOperationRouter = class {
+      constructor(validator, interactiveHandler, flagOperations) {
+        this.validator = validator;
+        this.interactiveHandler = interactiveHandler;
+        this.flagOperations = flagOperations;
+      }
+      static {
+        __name(this, "FlagOperationRouter");
+      }
+      /** Routes flag operations to appropriate handlers based on parameters */
+      async route(params) {
+        if (params.interactive) {
+          await this.handleInteractiveMode();
+          return;
+        }
+        if (params.safe) {
+          await this.flagOperations.setSafeFlags(params);
+          return;
+        }
+        const isValid = await this.validator.validateParams(params);
+        if (!isValid) return;
+        if (params.set) {
+          await this.handleSetOperations(params);
+        } else {
+          await this.flagOperations.displayFlags(params);
+          await this.showHelpMessage(params);
+        }
+      }
+      /** Handles flag setting operations, routing to single or multiple flag methods */
+      async handleSetOperations(params) {
+        if (params.FLAGNAME && params.value) {
+          await this.flagOperations.setFlag(params);
+        } else if (params.all || params.unconfigured) {
+          await this.flagOperations.setMultipleFlags(params);
+        }
+      }
+      /** Manages interactive mode */
+      async handleInteractiveMode() {
+        while (true) {
+          const interactiveParams = await this.interactiveHandler.handleInteractiveMode();
+          if (!interactiveParams) return;
+          await this.flagOperations.execute(interactiveParams);
+          if (!interactiveParams.FLAGNAME) {
+            return;
+          }
+        }
+      }
+      /** Shows help message when no specific options are provided */
+      async showHelpMessage(params) {
+        if (!params.all && !params.FLAGNAME) {
+          await this.flagOperations.displayHelpMessage();
+        }
+      }
+    };
+  }
+});
+
+// lib/commands/flags/validator.ts
+var FlagValidator;
+var init_validator2 = __esm({
+  "lib/commands/flags/validator.ts"() {
+    "use strict";
+    FlagValidator = class {
+      constructor(ioHelper) {
+        this.ioHelper = ioHelper;
+      }
+      static {
+        __name(this, "FlagValidator");
+      }
+      /** Shows error message when CDK version is incompatible with flags command */
+      async showIncompatibleVersionError() {
+        await this.ioHelper.defaults.error("The 'cdk flags' command is not compatible with the AWS CDK library used by your application. Please upgrade to 2.212.0 or above.");
+      }
+      /** Validates all parameters and returns true if valid, false if any validation fails */
+      async validateParams(params) {
+        const validations = [
+          () => this.validateFlagNameAndAll(params),
+          () => this.validateSetRequirement(params),
+          () => this.validateValueRequirement(params),
+          () => this.validateMutuallyExclusive(params),
+          () => this.validateUnconfiguredUsage(params),
+          () => this.validateSetWithFlags(params)
+        ];
+        for (const validation of validations) {
+          const isValid = await validation();
+          if (!isValid) return false;
+        }
+        return true;
+      }
+      /** Validates that --all and specific flag names are not used together */
+      async validateFlagNameAndAll(params) {
+        if (params.FLAGNAME && params.all) {
+          await this.ioHelper.defaults.error("Error: Cannot use both --all and a specific flag name. Please use either --all to show all flags or specify a single flag name.");
+          return false;
+        }
+        return true;
+      }
+      /** Validates that modification options require --set flag */
+      async validateSetRequirement(params) {
+        if ((params.value || params.recommended || params.default || params.unconfigured) && !params.set) {
+          await this.ioHelper.defaults.error("Error: This option can only be used with --set.");
+          return false;
+        }
+        return true;
+      }
+      /** Validates that --value requires a specific flag name */
+      async validateValueRequirement(params) {
+        if (params.value && !params.FLAGNAME) {
+          await this.ioHelper.defaults.error("Error: --value requires a specific flag name. Please specify a flag name when providing a value.");
+          return false;
+        }
+        return true;
+      }
+      /** Validates that mutually exclusive options are not used together */
+      async validateMutuallyExclusive(params) {
+        if (params.recommended && params.default) {
+          await this.ioHelper.defaults.error("Error: Cannot use both --recommended and --default. Please choose one option.");
+          return false;
+        }
+        if (params.unconfigured && params.all) {
+          await this.ioHelper.defaults.error("Error: Cannot use both --unconfigured and --all. Please choose one option.");
+          return false;
+        }
+        return true;
+      }
+      /** Validates that --unconfigured is not used with specific flag names */
+      async validateUnconfiguredUsage(params) {
+        if (params.unconfigured && params.FLAGNAME) {
+          await this.ioHelper.defaults.error("Error: Cannot use --unconfigured with a specific flag name. --unconfigured works with multiple flags.");
+          return false;
+        }
+        return true;
+      }
+      /** Validates that --set operations have required accompanying options */
+      async validateSetWithFlags(params) {
+        if (params.set && params.FLAGNAME && !params.value) {
+          await this.ioHelper.defaults.error("Error: When setting a specific flag, you must provide a --value.");
+          return false;
+        }
+        if (params.set && params.all && !params.recommended && !params.default) {
+          await this.ioHelper.defaults.error("Error: When using --set with --all, you must specify either --recommended or --default.");
+          return false;
+        }
+        if (params.set && params.unconfigured && !params.recommended && !params.default) {
+          await this.ioHelper.defaults.error("Error: When using --set with --unconfigured, you must specify either --recommended or --default.");
+          return false;
+        }
+        if (params.set && !params.all && !params.unconfigured && !params.FLAGNAME) {
+          await this.ioHelper.defaults.error("Error: When using --set, you must specify either --all, --unconfigured, or provide a specific flag name.");
+          return false;
+        }
+        return true;
+      }
+    };
+  }
+});
+
+// lib/commands/flags/flags.ts
+var FlagCommandHandler;
+var init_flags = __esm({
+  "lib/commands/flags/flags.ts"() {
+    "use strict";
+    init_interactive_handler();
+    init_operations();
+    init_router();
+    init_validator2();
     init_obsolete_flags();
-    FlagsMenuOptions = /* @__PURE__ */ ((FlagsMenuOptions2) => {
-      FlagsMenuOptions2["ALL_TO_RECOMMENDED"] = "Set all flags to recommended values";
-      FlagsMenuOptions2["UNCONFIGURED_TO_RECOMMENDED"] = "Set unconfigured flags to recommended values";
-      FlagsMenuOptions2["UNCONFIGURED_TO_DEFAULT"] = "Set unconfigured flags to their implied configuration (record current behavior)";
-      FlagsMenuOptions2["MODIFY_SPECIFIC_FLAG"] = "Modify a specific flag";
-      FlagsMenuOptions2["EXIT"] = "Exit";
-      return FlagsMenuOptions2;
-    })(FlagsMenuOptions || {});
-    __name(handleFlags, "handleFlags");
-    __name(setMultipleFlagsIfSupported, "setMultipleFlagsIfSupported");
-    __name(setFlag, "setFlag");
-    __name(prototypeChanges, "prototypeChanges");
-    __name(setMultipleFlags, "setMultipleFlags");
-    __name(handleUserResponse, "handleUserResponse");
-    __name(modifyValues, "modifyValues");
-    __name(getFlagSortOrder, "getFlagSortOrder");
-    __name(displayFlagTable, "displayFlagTable");
-    __name(displayFlags, "displayFlags");
-    __name(isUserValueEqualToRecommended, "isUserValueEqualToRecommended");
-    __name(toBooleanValue, "toBooleanValue");
-    __name(isBooleanFlag, "isBooleanFlag");
+    FlagCommandHandler = class {
+      static {
+        __name(this, "FlagCommandHandler");
+      }
+      /** Main component that sets up all flag operation components */
+      constructor(flagData, ioHelper, options, toolkit) {
+        this.flags = flagData.filter((flag) => !OBSOLETE_FLAGS.includes(flag.name));
+        this.options = { ...options, concurrency: options.concurrency ?? 4 };
+        this.ioHelper = ioHelper;
+        const validator = new FlagValidator(ioHelper);
+        const flagOperations = new FlagOperations(this.flags, toolkit, ioHelper);
+        const interactiveHandler = new InteractiveHandler(this.flags, flagOperations);
+        this.router = new FlagOperationRouter(validator, interactiveHandler, flagOperations);
+      }
+      /** Main entry point that processes the flags command */
+      async processFlagsCommand() {
+        if (this.flags.length === 0) {
+          await this.ioHelper.defaults.error("The 'cdk flags' command is not compatible with the AWS CDK library used by your application. Please upgrade to 2.212.0 or above.");
+          return;
+        }
+        await this.router.route(this.options);
+      }
+    };
   }
 });
 
@@ -357351,7 +358253,7 @@ var require_helpers2 = __commonJS({
 });
 
 // ../../node_modules/agent-base/dist/index.js
-var require_dist3 = __commonJS({
+var require_dist4 = __commonJS({
   "../../node_modules/agent-base/dist/index.js"(exports2) {
     "use strict";
     var __createBinding3 = exports2 && exports2.__createBinding || (Object.create ? (function(o3, m3, k3, k22) {
@@ -358258,7 +359160,7 @@ var require_proxy_from_env = __commonJS({
 });
 
 // ../../node_modules/http-proxy-agent/dist/index.js
-var require_dist4 = __commonJS({
+var require_dist5 = __commonJS({
   "../../node_modules/http-proxy-agent/dist/index.js"(exports2) {
     "use strict";
     var __createBinding3 = exports2 && exports2.__createBinding || (Object.create ? (function(o3, m3, k3, k22) {
@@ -358297,7 +359199,7 @@ var require_dist4 = __commonJS({
     var tls = __importStar2(require("tls"));
     var debug_1 = __importDefault2(require_src2());
     var events_1 = require("events");
-    var agent_base_1 = require_dist3();
+    var agent_base_1 = require_dist4();
     var url_1 = require("url");
     var debug3 = (0, debug_1.default)("http-proxy-agent");
     var HttpProxyAgent = class extends agent_base_1.Agent {
@@ -358494,7 +359396,7 @@ var require_parse_proxy_response = __commonJS({
 });
 
 // ../../node_modules/https-proxy-agent/dist/index.js
-var require_dist5 = __commonJS({
+var require_dist6 = __commonJS({
   "../../node_modules/https-proxy-agent/dist/index.js"(exports2) {
     "use strict";
     var __createBinding3 = exports2 && exports2.__createBinding || (Object.create ? (function(o3, m3, k3, k22) {
@@ -358533,7 +359435,7 @@ var require_dist5 = __commonJS({
     var tls = __importStar2(require("tls"));
     var assert_1 = __importDefault2(require("assert"));
     var debug_1 = __importDefault2(require_src2());
-    var agent_base_1 = require_dist3();
+    var agent_base_1 = require_dist4();
     var url_1 = require("url");
     var parse_proxy_response_1 = require_parse_proxy_response();
     var debug3 = (0, debug_1.default)("https-proxy-agent");
@@ -362468,7 +363370,7 @@ var require_build = __commonJS({
 });
 
 // ../../node_modules/socks-proxy-agent/dist/index.js
-var require_dist6 = __commonJS({
+var require_dist7 = __commonJS({
   "../../node_modules/socks-proxy-agent/dist/index.js"(exports2) {
     "use strict";
     var __createBinding3 = exports2 && exports2.__createBinding || (Object.create ? (function(o3, m3, k3, k22) {
@@ -362504,7 +363406,7 @@ var require_dist6 = __commonJS({
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.SocksProxyAgent = void 0;
     var socks_1 = require_build();
-    var agent_base_1 = require_dist3();
+    var agent_base_1 = require_dist4();
     var debug_1 = __importDefault2(require_src2());
     var dns = __importStar2(require("dns"));
     var net = __importStar2(require("net"));
@@ -364850,7 +365752,7 @@ var require_StringEncoding = __commonJS({
 });
 
 // ../../node_modules/basic-ftp/dist/index.js
-var require_dist7 = __commonJS({
+var require_dist8 = __commonJS({
   "../../node_modules/basic-ftp/dist/index.js"(exports2) {
     "use strict";
     var __createBinding3 = exports2 && exports2.__createBinding || (Object.create ? (function(o3, m3, k3, k22) {
@@ -364895,7 +365797,7 @@ var require_ftp = __commonJS({
     };
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.ftp = void 0;
-    var basic_ftp_1 = require_dist7();
+    var basic_ftp_1 = require_dist8();
     var stream_1 = require("stream");
     var path_1 = require("path");
     var debug_1 = __importDefault2(require_src2());
@@ -365162,7 +366064,7 @@ var require_https = __commonJS({
 });
 
 // ../../node_modules/get-uri/dist/index.js
-var require_dist8 = __commonJS({
+var require_dist9 = __commonJS({
   "../../node_modules/get-uri/dist/index.js"(exports2) {
     "use strict";
     var __importDefault2 = exports2 && exports2.__importDefault || function(mod) {
@@ -379906,7 +380808,7 @@ ${err.cause.stack}`;
 });
 
 // ../../node_modules/degenerator/dist/index.js
-var require_dist9 = __commonJS({
+var require_dist10 = __commonJS({
   "../../node_modules/degenerator/dist/index.js"(exports2) {
     "use strict";
     var __createBinding3 = exports2 && exports2.__createBinding || (Object.create ? (function(o3, m3, k3, k22) {
@@ -380514,7 +381416,7 @@ var require_weekdayRange = __commonJS({
 });
 
 // ../../node_modules/pac-resolver/dist/index.js
-var require_dist10 = __commonJS({
+var require_dist11 = __commonJS({
   "../../node_modules/pac-resolver/dist/index.js"(exports2) {
     "use strict";
     var __importDefault2 = exports2 && exports2.__importDefault || function(mod) {
@@ -380522,7 +381424,7 @@ var require_dist10 = __commonJS({
     };
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.sandbox = exports2.createPacResolver = void 0;
-    var degenerator_1 = require_dist9();
+    var degenerator_1 = require_dist10();
     var dateRange_1 = __importDefault2(require_dateRange());
     var dnsDomainIs_1 = __importDefault2(require_dnsDomainIs());
     var dnsDomainLevels_1 = __importDefault2(require_dnsDomainLevels());
@@ -382389,7 +383291,7 @@ var require_runtime_asyncify = __commonJS({
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.QuickJSAsyncRuntime = void 0;
-    var _1 = require_dist11();
+    var _1 = require_dist12();
     var context_asyncify_1 = require_context_asyncify();
     var runtime_1 = require_runtime();
     var types_1 = require_types4();
@@ -383564,7 +384466,7 @@ var require_module_test = __commonJS({
 });
 
 // ../../node_modules/@tootallnate/quickjs-emscripten/dist/index.js
-var require_dist11 = __commonJS({
+var require_dist12 = __commonJS({
   "../../node_modules/@tootallnate/quickjs-emscripten/dist/index.js"(exports2) {
     "use strict";
     var __createBinding3 = exports2 && exports2.__createBinding || (Object.create ? (function(o3, m3, k3, k22) {
@@ -383666,7 +384568,7 @@ var require_dist11 = __commonJS({
 });
 
 // ../../node_modules/pac-proxy-agent/dist/index.js
-var require_dist12 = __commonJS({
+var require_dist13 = __commonJS({
   "../../node_modules/pac-proxy-agent/dist/index.js"(exports2) {
     "use strict";
     var __createBinding3 = exports2 && exports2.__createBinding || (Object.create ? (function(o3, m3, k3, k22) {
@@ -383707,10 +384609,10 @@ var require_dist12 = __commonJS({
     var events_1 = require("events");
     var debug_1 = __importDefault2(require_src2());
     var url_1 = require("url");
-    var agent_base_1 = require_dist3();
-    var get_uri_1 = require_dist8();
-    var pac_resolver_1 = require_dist10();
-    var quickjs_emscripten_1 = require_dist11();
+    var agent_base_1 = require_dist4();
+    var get_uri_1 = require_dist9();
+    var pac_resolver_1 = require_dist11();
+    var quickjs_emscripten_1 = require_dist12();
     var debug3 = (0, debug_1.default)("pac-proxy-agent");
     var setServernameFromNonIpHost = /* @__PURE__ */ __name((options) => {
       if (options.servername === void 0 && options.host && !net.isIP(options.host)) {
@@ -383822,18 +384724,18 @@ var require_dist12 = __commonJS({
               socket = net.connect(opts);
             }
           } else if (type === "SOCKS" || type === "SOCKS5") {
-            const { SocksProxyAgent } = await Promise.resolve().then(() => __importStar2(require_dist6()));
+            const { SocksProxyAgent } = await Promise.resolve().then(() => __importStar2(require_dist7()));
             agent = new SocksProxyAgent(`socks://${target}`, this.opts);
           } else if (type === "SOCKS4") {
-            const { SocksProxyAgent } = await Promise.resolve().then(() => __importStar2(require_dist6()));
+            const { SocksProxyAgent } = await Promise.resolve().then(() => __importStar2(require_dist7()));
             agent = new SocksProxyAgent(`socks4a://${target}`, this.opts);
           } else if (type === "PROXY" || type === "HTTP" || type === "HTTPS") {
             const proxyURL = `${type === "HTTPS" ? "https" : "http"}://${target}`;
             if (secureEndpoint || isWebSocket) {
-              const { HttpsProxyAgent } = await Promise.resolve().then(() => __importStar2(require_dist5()));
+              const { HttpsProxyAgent } = await Promise.resolve().then(() => __importStar2(require_dist6()));
               agent = new HttpsProxyAgent(proxyURL, this.opts);
             } else {
-              const { HttpProxyAgent } = await Promise.resolve().then(() => __importStar2(require_dist4()));
+              const { HttpProxyAgent } = await Promise.resolve().then(() => __importStar2(require_dist5()));
               agent = new HttpProxyAgent(proxyURL, this.opts);
             }
           }
@@ -383872,7 +384774,7 @@ var require_dist12 = __commonJS({
 });
 
 // ../../node_modules/proxy-agent/dist/index.js
-var require_dist13 = __commonJS({
+var require_dist14 = __commonJS({
   "../../node_modules/proxy-agent/dist/index.js"(exports2) {
     "use strict";
     var __createBinding3 = exports2 && exports2.__createBinding || (Object.create ? (function(o3, m3, k3, k22) {
@@ -383911,15 +384813,15 @@ var require_dist13 = __commonJS({
     var https2 = __importStar2(require("https"));
     var url_1 = require("url");
     var lru_cache_1 = __importDefault2(require_lru_cache());
-    var agent_base_1 = require_dist3();
+    var agent_base_1 = require_dist4();
     var debug_1 = __importDefault2(require_src2());
     var proxy_from_env_1 = require_proxy_from_env();
     var debug3 = (0, debug_1.default)("proxy-agent");
     var wellKnownAgents = {
-      http: /* @__PURE__ */ __name(async () => (await Promise.resolve().then(() => __importStar2(require_dist4()))).HttpProxyAgent, "http"),
-      https: /* @__PURE__ */ __name(async () => (await Promise.resolve().then(() => __importStar2(require_dist5()))).HttpsProxyAgent, "https"),
-      socks: /* @__PURE__ */ __name(async () => (await Promise.resolve().then(() => __importStar2(require_dist6()))).SocksProxyAgent, "socks"),
-      pac: /* @__PURE__ */ __name(async () => (await Promise.resolve().then(() => __importStar2(require_dist12()))).PacProxyAgent, "pac")
+      http: /* @__PURE__ */ __name(async () => (await Promise.resolve().then(() => __importStar2(require_dist5()))).HttpProxyAgent, "http"),
+      https: /* @__PURE__ */ __name(async () => (await Promise.resolve().then(() => __importStar2(require_dist6()))).HttpsProxyAgent, "https"),
+      socks: /* @__PURE__ */ __name(async () => (await Promise.resolve().then(() => __importStar2(require_dist7()))).SocksProxyAgent, "socks"),
+      pac: /* @__PURE__ */ __name(async () => (await Promise.resolve().then(() => __importStar2(require_dist13()))).PacProxyAgent, "pac")
     };
     exports2.proxies = {
       http: [wellKnownAgents.http, wellKnownAgents.https],
@@ -384001,7 +384903,7 @@ var init_proxy_agent = __esm({
   "lib/cli/proxy-agent.ts"() {
     "use strict";
     fs41 = __toESM(require_lib13());
-    import_proxy_agent = __toESM(require_dist13());
+    import_proxy_agent = __toESM(require_dist14());
     ProxyAgentProvider = class {
       static {
         __name(this, "ProxyAgentProvider");
@@ -384078,11 +384980,7 @@ async function exec4(args, synthesizer) {
     stackProgress: argv.progress
   }, true);
   const ioHelper = asIoHelper(ioHost, ioHost.currentAction);
-  if (argv.debug || argv.verbose > 2) {
-    setSdkTracing(true);
-  } else {
-    setSdkTracing(false);
-  }
+  setSdkTracing(argv.debug || argv.verbose > 2);
   try {
     await checkForPlatformWarnings(ioHelper);
   } catch (e3) {
@@ -384417,6 +385315,9 @@ async function exec4(args, synthesizer) {
         if (args2.bootstrapStackName) {
           await ioHost.defaults.warn("--bootstrap-stack-name is deprecated and will be removed when gc is GA. Use --toolkit-stack-name.");
         }
+        if (args2.roleArn) {
+          await ioHost.defaults.warn("The --role-arn option is not supported for the gc command and will be ignored.");
+        }
         return cli2.garbageCollect(args2.ENVIRONMENTS, {
           action: args2.action,
           type: args2.type,
@@ -384436,7 +385337,8 @@ async function exec4(args, synthesizer) {
           unstableFeatures: configuration.settings.get(["unstable"])
         });
         const flagsData = await toolkit.flags(cloudExecutable);
-        return handleFlags(flagsData, ioHelper, args2, toolkit);
+        const handler = new FlagCommandHandler(flagsData, ioHelper, args2, toolkit);
+        return handler.processFlagsCommand();
       case "synthesize":
       case "synth":
         ioHost.currentAction = "synth";
@@ -384653,7 +385555,7 @@ var init_cli = __esm({
     init_context5();
     init_docs();
     init_doctor();
-    init_flag_operations();
+    init_flags();
     init_init2();
     init_migrate();
     init_cxapp();
@@ -384864,7 +385766,7 @@ function warnAboutContextKey2(settings, prefix2, fileName) {
 }
 function expandHomeDir3(x3) {
   if (x3.startsWith("~")) {
-    return fs_path3.join(os12.homedir(), x3.slice(1));
+    return fs_path3.join(os13.homedir(), x3.slice(1));
   }
   return x3;
 }
@@ -384979,11 +385881,11 @@ function parseStringTagsListToObject2(argTags) {
   }
   return tags.length > 0 ? tags : void 0;
 }
-var os12, fs_path3, import_toolkit_lib20, fs42, PROJECT_CONTEXT2, PROJECT_CONFIG2, USER_DEFAULTS2, CONTEXT_KEY2, Command, BUNDLING_COMMANDS2, Configuration2;
+var os13, fs_path3, import_toolkit_lib20, fs42, PROJECT_CONTEXT2, PROJECT_CONFIG2, USER_DEFAULTS2, CONTEXT_KEY2, Command, BUNDLING_COMMANDS2, Configuration2;
 var init_configuration = __esm({
   "lib/legacy/configuration.ts"() {
     "use strict";
-    os12 = __toESM(require("os"));
+    os13 = __toESM(require("os"));
     fs_path3 = __toESM(require("path"));
     import_toolkit_lib20 = __toESM(require_lib12());
     fs42 = __toESM(require_lib13());