aws-cdk 2.1132.0 → 2.1133.0

package/lib/index.js

@@ -3695,7 +3695,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.1132.0" };
+    module2.exports = { version: "2.1133.0" };
   }
 });
 
@@ -8429,54 +8429,54 @@ var require_polyfills = __commonJS({
     }
     var chdir;
     module2.exports = patch;
-    function patch(fs57) {
+    function patch(fs58) {
       if (constants3.hasOwnProperty("O_SYMLINK") && process.version.match(/^v0\.6\.[0-2]|^v0\.5\./)) {
-        patchLchmod(fs57);
-      }
-      if (!fs57.lutimes) {
-        patchLutimes(fs57);
-      }
-      fs57.chown = chownFix(fs57.chown);
-      fs57.fchown = chownFix(fs57.fchown);
-      fs57.lchown = chownFix(fs57.lchown);
-      fs57.chmod = chmodFix(fs57.chmod);
-      fs57.fchmod = chmodFix(fs57.fchmod);
-      fs57.lchmod = chmodFix(fs57.lchmod);
-      fs57.chownSync = chownFixSync(fs57.chownSync);
-      fs57.fchownSync = chownFixSync(fs57.fchownSync);
-      fs57.lchownSync = chownFixSync(fs57.lchownSync);
-      fs57.chmodSync = chmodFixSync(fs57.chmodSync);
-      fs57.fchmodSync = chmodFixSync(fs57.fchmodSync);
-      fs57.lchmodSync = chmodFixSync(fs57.lchmodSync);
-      fs57.stat = statFix(fs57.stat);
-      fs57.fstat = statFix(fs57.fstat);
-      fs57.lstat = statFix(fs57.lstat);
-      fs57.statSync = statFixSync(fs57.statSync);
-      fs57.fstatSync = statFixSync(fs57.fstatSync);
-      fs57.lstatSync = statFixSync(fs57.lstatSync);
-      if (fs57.chmod && !fs57.lchmod) {
-        fs57.lchmod = function(path54, mode, cb) {
+        patchLchmod(fs58);
+      }
+      if (!fs58.lutimes) {
+        patchLutimes(fs58);
+      }
+      fs58.chown = chownFix(fs58.chown);
+      fs58.fchown = chownFix(fs58.fchown);
+      fs58.lchown = chownFix(fs58.lchown);
+      fs58.chmod = chmodFix(fs58.chmod);
+      fs58.fchmod = chmodFix(fs58.fchmod);
+      fs58.lchmod = chmodFix(fs58.lchmod);
+      fs58.chownSync = chownFixSync(fs58.chownSync);
+      fs58.fchownSync = chownFixSync(fs58.fchownSync);
+      fs58.lchownSync = chownFixSync(fs58.lchownSync);
+      fs58.chmodSync = chmodFixSync(fs58.chmodSync);
+      fs58.fchmodSync = chmodFixSync(fs58.fchmodSync);
+      fs58.lchmodSync = chmodFixSync(fs58.lchmodSync);
+      fs58.stat = statFix(fs58.stat);
+      fs58.fstat = statFix(fs58.fstat);
+      fs58.lstat = statFix(fs58.lstat);
+      fs58.statSync = statFixSync(fs58.statSync);
+      fs58.fstatSync = statFixSync(fs58.fstatSync);
+      fs58.lstatSync = statFixSync(fs58.lstatSync);
+      if (fs58.chmod && !fs58.lchmod) {
+        fs58.lchmod = function(path54, mode, cb) {
           if (cb) process.nextTick(cb);
         };
-        fs57.lchmodSync = function() {
+        fs58.lchmodSync = function() {
         };
       }
-      if (fs57.chown && !fs57.lchown) {
-        fs57.lchown = function(path54, uid, gid, cb) {
+      if (fs58.chown && !fs58.lchown) {
+        fs58.lchown = function(path54, uid, gid, cb) {
           if (cb) process.nextTick(cb);
         };
-        fs57.lchownSync = function() {
+        fs58.lchownSync = function() {
         };
       }
       if (platform5 === "win32") {
-        fs57.rename = typeof fs57.rename !== "function" ? fs57.rename : (function(fs$rename) {
+        fs58.rename = typeof fs58.rename !== "function" ? fs58.rename : (function(fs$rename) {
           function rename(from, to, cb) {
             var start = Date.now();
             var backoff = 0;
             fs$rename(from, to, /* @__PURE__ */ __name(function CB(er) {
               if (er && (er.code === "EACCES" || er.code === "EPERM" || er.code === "EBUSY") && Date.now() - start < 6e4) {
                 setTimeout(function() {
-                  fs57.stat(to, function(stater, st) {
+                  fs58.stat(to, function(stater, st) {
                     if (stater && stater.code === "ENOENT")
                       fs$rename(from, to, CB);
                     else
@@ -8493,9 +8493,9 @@ var require_polyfills = __commonJS({
           __name(rename, "rename");
           if (Object.setPrototypeOf) Object.setPrototypeOf(rename, fs$rename);
           return rename;
-        })(fs57.rename);
+        })(fs58.rename);
       }
-      fs57.read = typeof fs57.read !== "function" ? fs57.read : (function(fs$read) {
+      fs58.read = typeof fs58.read !== "function" ? fs58.read : (function(fs$read) {
         function read(fd, buffer, offset, length, position, callback_) {
           var callback;
           if (callback_ && typeof callback_ === "function") {
@@ -8503,23 +8503,23 @@ var require_polyfills = __commonJS({
             callback = /* @__PURE__ */ __name(function(er, _, __) {
               if (er && er.code === "EAGAIN" && eagCounter < 10) {
                 eagCounter++;
-                return fs$read.call(fs57, fd, buffer, offset, length, position, callback);
+                return fs$read.call(fs58, fd, buffer, offset, length, position, callback);
               }
               callback_.apply(this, arguments);
             }, "callback");
           }
-          return fs$read.call(fs57, fd, buffer, offset, length, position, callback);
+          return fs$read.call(fs58, fd, buffer, offset, length, position, callback);
         }
         __name(read, "read");
         if (Object.setPrototypeOf) Object.setPrototypeOf(read, fs$read);
         return read;
-      })(fs57.read);
-      fs57.readSync = typeof fs57.readSync !== "function" ? fs57.readSync : /* @__PURE__ */ (function(fs$readSync) {
+      })(fs58.read);
+      fs58.readSync = typeof fs58.readSync !== "function" ? fs58.readSync : /* @__PURE__ */ (function(fs$readSync) {
         return function(fd, buffer, offset, length, position) {
           var eagCounter = 0;
           while (true) {
             try {
-              return fs$readSync.call(fs57, fd, buffer, offset, length, position);
+              return fs$readSync.call(fs58, fd, buffer, offset, length, position);
             } catch (er) {
               if (er.code === "EAGAIN" && eagCounter < 10) {
                 eagCounter++;
@@ -8529,10 +8529,10 @@ var require_polyfills = __commonJS({
             }
           }
         };
-      })(fs57.readSync);
-      function patchLchmod(fs58) {
-        fs58.lchmod = function(path54, mode, callback) {
-          fs58.open(
+      })(fs58.readSync);
+      function patchLchmod(fs59) {
+        fs59.lchmod = function(path54, mode, callback) {
+          fs59.open(
             path54,
             constants3.O_WRONLY | constants3.O_SYMLINK,
             mode,
@@ -8541,74 +8541,74 @@ var require_polyfills = __commonJS({
                 if (callback) callback(err);
                 return;
               }
-              fs58.fchmod(fd, mode, function(err2) {
-                fs58.close(fd, function(err22) {
+              fs59.fchmod(fd, mode, function(err2) {
+                fs59.close(fd, function(err22) {
                   if (callback) callback(err2 || err22);
                 });
               });
             }
           );
         };
-        fs58.lchmodSync = function(path54, mode) {
-          var fd = fs58.openSync(path54, constants3.O_WRONLY | constants3.O_SYMLINK, mode);
+        fs59.lchmodSync = function(path54, mode) {
+          var fd = fs59.openSync(path54, constants3.O_WRONLY | constants3.O_SYMLINK, mode);
           var threw = true;
           var ret;
           try {
-            ret = fs58.fchmodSync(fd, mode);
+            ret = fs59.fchmodSync(fd, mode);
             threw = false;
           } finally {
             if (threw) {
               try {
-                fs58.closeSync(fd);
+                fs59.closeSync(fd);
               } catch (er) {
               }
             } else {
-              fs58.closeSync(fd);
+              fs59.closeSync(fd);
             }
           }
           return ret;
         };
       }
       __name(patchLchmod, "patchLchmod");
-      function patchLutimes(fs58) {
-        if (constants3.hasOwnProperty("O_SYMLINK") && fs58.futimes) {
-          fs58.lutimes = function(path54, at, mt, cb) {
-            fs58.open(path54, constants3.O_SYMLINK, function(er, fd) {
+      function patchLutimes(fs59) {
+        if (constants3.hasOwnProperty("O_SYMLINK") && fs59.futimes) {
+          fs59.lutimes = function(path54, at, mt, cb) {
+            fs59.open(path54, constants3.O_SYMLINK, function(er, fd) {
               if (er) {
                 if (cb) cb(er);
                 return;
               }
-              fs58.futimes(fd, at, mt, function(er2) {
-                fs58.close(fd, function(er22) {
+              fs59.futimes(fd, at, mt, function(er2) {
+                fs59.close(fd, function(er22) {
                   if (cb) cb(er2 || er22);
                 });
               });
             });
           };
-          fs58.lutimesSync = function(path54, at, mt) {
-            var fd = fs58.openSync(path54, constants3.O_SYMLINK);
+          fs59.lutimesSync = function(path54, at, mt) {
+            var fd = fs59.openSync(path54, constants3.O_SYMLINK);
             var ret;
             var threw = true;
             try {
-              ret = fs58.futimesSync(fd, at, mt);
+              ret = fs59.futimesSync(fd, at, mt);
               threw = false;
             } finally {
               if (threw) {
                 try {
-                  fs58.closeSync(fd);
+                  fs59.closeSync(fd);
                 } catch (er) {
                 }
               } else {
-                fs58.closeSync(fd);
+                fs59.closeSync(fd);
               }
             }
             return ret;
           };
-        } else if (fs58.futimes) {
-          fs58.lutimes = function(_a2, _b, _c6, cb) {
+        } else if (fs59.futimes) {
+          fs59.lutimes = function(_a2, _b, _c6, cb) {
             if (cb) process.nextTick(cb);
           };
-          fs58.lutimesSync = function() {
+          fs59.lutimesSync = function() {
           };
         }
       }
@@ -8616,7 +8616,7 @@ var require_polyfills = __commonJS({
       function chmodFix(orig) {
         if (!orig) return orig;
         return function(target, mode, cb) {
-          return orig.call(fs57, target, mode, function(er) {
+          return orig.call(fs58, target, mode, function(er) {
             if (chownErOk(er)) er = null;
             if (cb) cb.apply(this, arguments);
           });
@@ -8627,7 +8627,7 @@ var require_polyfills = __commonJS({
         if (!orig) return orig;
         return function(target, mode) {
           try {
-            return orig.call(fs57, target, mode);
+            return orig.call(fs58, target, mode);
           } catch (er) {
             if (!chownErOk(er)) throw er;
           }
@@ -8637,7 +8637,7 @@ var require_polyfills = __commonJS({
       function chownFix(orig) {
         if (!orig) return orig;
         return function(target, uid, gid, cb) {
-          return orig.call(fs57, target, uid, gid, function(er) {
+          return orig.call(fs58, target, uid, gid, function(er) {
             if (chownErOk(er)) er = null;
             if (cb) cb.apply(this, arguments);
           });
@@ -8648,7 +8648,7 @@ var require_polyfills = __commonJS({
         if (!orig) return orig;
         return function(target, uid, gid) {
           try {
-            return orig.call(fs57, target, uid, gid);
+            return orig.call(fs58, target, uid, gid);
           } catch (er) {
             if (!chownErOk(er)) throw er;
           }
@@ -8670,14 +8670,14 @@ var require_polyfills = __commonJS({
             if (cb) cb.apply(this, arguments);
           }
           __name(callback, "callback");
-          return options ? orig.call(fs57, target, options, callback) : orig.call(fs57, target, callback);
+          return options ? orig.call(fs58, target, options, callback) : orig.call(fs58, target, callback);
         };
       }
       __name(statFix, "statFix");
       function statFixSync(orig) {
         if (!orig) return orig;
         return function(target, options) {
-          var stats = options ? orig.call(fs57, target, options) : orig.call(fs57, target);
+          var stats = options ? orig.call(fs58, target, options) : orig.call(fs58, target);
           if (stats) {
             if (stats.uid < 0) stats.uid += 4294967296;
             if (stats.gid < 0) stats.gid += 4294967296;
@@ -8709,7 +8709,7 @@ var require_legacy_streams = __commonJS({
   "../../node_modules/graceful-fs/legacy-streams.js"(exports2, module2) {
     var Stream = require("stream").Stream;
     module2.exports = legacy;
-    function legacy(fs57) {
+    function legacy(fs58) {
       return {
         ReadStream: ReadStream2,
         WriteStream
@@ -8752,7 +8752,7 @@ var require_legacy_streams = __commonJS({
           });
           return;
         }
-        fs57.open(this.path, this.flags, this.mode, function(err, fd) {
+        fs58.open(this.path, this.flags, this.mode, function(err, fd) {
           if (err) {
             self2.emit("error", err);
             self2.readable = false;
@@ -8792,7 +8792,7 @@ var require_legacy_streams = __commonJS({
         this.busy = false;
         this._queue = [];
         if (this.fd === null) {
-          this._open = fs57.open;
+          this._open = fs58.open;
           this._queue.push([this._open, this.path, this.flags, this.mode, void 0]);
           this.flush();
         }
@@ -8830,7 +8830,7 @@ var require_clone = __commonJS({
 // ../../node_modules/graceful-fs/graceful-fs.js
 var require_graceful_fs = __commonJS({
   "../../node_modules/graceful-fs/graceful-fs.js"(exports2, module2) {
-    var fs57 = require("fs");
+    var fs58 = require("fs");
     var polyfills = require_polyfills();
     var legacy = require_legacy_streams();
     var clone = require_clone();
@@ -8864,12 +8864,12 @@ var require_graceful_fs = __commonJS({
         m4 = "GFS4: " + m4.split(/\n/).join("\nGFS4: ");
         console.error(m4);
       }, "debug");
-    if (!fs57[gracefulQueue]) {
+    if (!fs58[gracefulQueue]) {
       queue = global[gracefulQueue] || [];
-      publishQueue(fs57, queue);
-      fs57.close = (function(fs$close) {
+      publishQueue(fs58, queue);
+      fs58.close = (function(fs$close) {
         function close(fd, cb) {
-          return fs$close.call(fs57, fd, function(err) {
+          return fs$close.call(fs58, fd, function(err) {
             if (!err) {
               resetQueue();
             }
@@ -8882,10 +8882,10 @@ var require_graceful_fs = __commonJS({
           value: fs$close
         });
         return close;
-      })(fs57.close);
-      fs57.closeSync = (function(fs$closeSync) {
+      })(fs58.close);
+      fs58.closeSync = (function(fs$closeSync) {
         function closeSync(fd) {
-          fs$closeSync.apply(fs57, arguments);
+          fs$closeSync.apply(fs58, arguments);
           resetQueue();
         }
         __name(closeSync, "closeSync");
@@ -8893,31 +8893,31 @@ var require_graceful_fs = __commonJS({
           value: fs$closeSync
         });
         return closeSync;
-      })(fs57.closeSync);
+      })(fs58.closeSync);
       if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || "")) {
         process.on("exit", function() {
-          debug2(fs57[gracefulQueue]);
-          require("assert").equal(fs57[gracefulQueue].length, 0);
+          debug2(fs58[gracefulQueue]);
+          require("assert").equal(fs58[gracefulQueue].length, 0);
         });
       }
     }
     var queue;
     if (!global[gracefulQueue]) {
-      publishQueue(global, fs57[gracefulQueue]);
-    }
-    module2.exports = patch(clone(fs57));
-    if (process.env.TEST_GRACEFUL_FS_GLOBAL_PATCH && !fs57.__patched) {
-      module2.exports = patch(fs57);
-      fs57.__patched = true;
-    }
-    function patch(fs58) {
-      polyfills(fs58);
-      fs58.gracefulify = patch;
-      fs58.createReadStream = createReadStream3;
-      fs58.createWriteStream = createWriteStream;
-      var fs$readFile = fs58.readFile;
-      fs58.readFile = readFile11;
-      function readFile11(path54, options, cb) {
+      publishQueue(global, fs58[gracefulQueue]);
+    }
+    module2.exports = patch(clone(fs58));
+    if (process.env.TEST_GRACEFUL_FS_GLOBAL_PATCH && !fs58.__patched) {
+      module2.exports = patch(fs58);
+      fs58.__patched = true;
+    }
+    function patch(fs59) {
+      polyfills(fs59);
+      fs59.gracefulify = patch;
+      fs59.createReadStream = createReadStream3;
+      fs59.createWriteStream = createWriteStream;
+      var fs$readFile = fs59.readFile;
+      fs59.readFile = readFile12;
+      function readFile12(path54, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
         return go$readFile(path54, options, cb);
@@ -8933,9 +8933,9 @@ var require_graceful_fs = __commonJS({
         }
         __name(go$readFile, "go$readFile");
       }
-      __name(readFile11, "readFile");
-      var fs$writeFile = fs58.writeFile;
-      fs58.writeFile = writeFile6;
+      __name(readFile12, "readFile");
+      var fs$writeFile = fs59.writeFile;
+      fs59.writeFile = writeFile6;
       function writeFile6(path54, data2, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
@@ -8953,9 +8953,9 @@ var require_graceful_fs = __commonJS({
         __name(go$writeFile, "go$writeFile");
       }
       __name(writeFile6, "writeFile");
-      var fs$appendFile = fs58.appendFile;
+      var fs$appendFile = fs59.appendFile;
       if (fs$appendFile)
-        fs58.appendFile = appendFile;
+        fs59.appendFile = appendFile;
       function appendFile(path54, data2, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
@@ -8973,9 +8973,9 @@ var require_graceful_fs = __commonJS({
         __name(go$appendFile, "go$appendFile");
       }
       __name(appendFile, "appendFile");
-      var fs$copyFile = fs58.copyFile;
+      var fs$copyFile = fs59.copyFile;
       if (fs$copyFile)
-        fs58.copyFile = copyFile;
+        fs59.copyFile = copyFile;
       function copyFile(src, dest, flags, cb) {
         if (typeof flags === "function") {
           cb = flags;
@@ -8995,8 +8995,8 @@ var require_graceful_fs = __commonJS({
         __name(go$copyFile, "go$copyFile");
       }
       __name(copyFile, "copyFile");
-      var fs$readdir = fs58.readdir;
-      fs58.readdir = readdir5;
+      var fs$readdir = fs59.readdir;
+      fs59.readdir = readdir5;
       var noReaddirOptionVersions = /^v[0-5]\./;
       function readdir5(path54, options, cb) {
         if (typeof options === "function")
@@ -9039,21 +9039,21 @@ var require_graceful_fs = __commonJS({
       }
       __name(readdir5, "readdir");
       if (process.version.substr(0, 4) === "v0.8") {
-        var legStreams = legacy(fs58);
+        var legStreams = legacy(fs59);
         ReadStream2 = legStreams.ReadStream;
         WriteStream = legStreams.WriteStream;
       }
-      var fs$ReadStream = fs58.ReadStream;
+      var fs$ReadStream = fs59.ReadStream;
       if (fs$ReadStream) {
         ReadStream2.prototype = Object.create(fs$ReadStream.prototype);
         ReadStream2.prototype.open = ReadStream$open;
       }
-      var fs$WriteStream = fs58.WriteStream;
+      var fs$WriteStream = fs59.WriteStream;
       if (fs$WriteStream) {
         WriteStream.prototype = Object.create(fs$WriteStream.prototype);
         WriteStream.prototype.open = WriteStream$open;
       }
-      Object.defineProperty(fs58, "ReadStream", {
+      Object.defineProperty(fs59, "ReadStream", {
         get: /* @__PURE__ */ __name(function() {
           return ReadStream2;
         }, "get"),
@@ -9063,7 +9063,7 @@ var require_graceful_fs = __commonJS({
         enumerable: true,
         configurable: true
       });
-      Object.defineProperty(fs58, "WriteStream", {
+      Object.defineProperty(fs59, "WriteStream", {
         get: /* @__PURE__ */ __name(function() {
           return WriteStream;
         }, "get"),
@@ -9074,7 +9074,7 @@ var require_graceful_fs = __commonJS({
         configurable: true
       });
       var FileReadStream = ReadStream2;
-      Object.defineProperty(fs58, "FileReadStream", {
+      Object.defineProperty(fs59, "FileReadStream", {
         get: /* @__PURE__ */ __name(function() {
           return FileReadStream;
         }, "get"),
@@ -9085,7 +9085,7 @@ var require_graceful_fs = __commonJS({
         configurable: true
       });
       var FileWriteStream = WriteStream;
-      Object.defineProperty(fs58, "FileWriteStream", {
+      Object.defineProperty(fs59, "FileWriteStream", {
         get: /* @__PURE__ */ __name(function() {
           return FileWriteStream;
         }, "get"),
@@ -9138,15 +9138,15 @@ var require_graceful_fs = __commonJS({
       }
       __name(WriteStream$open, "WriteStream$open");
       function createReadStream3(path54, options) {
-        return new fs58.ReadStream(path54, options);
+        return new fs59.ReadStream(path54, options);
       }
       __name(createReadStream3, "createReadStream");
       function createWriteStream(path54, options) {
-        return new fs58.WriteStream(path54, options);
+        return new fs59.WriteStream(path54, options);
       }
       __name(createWriteStream, "createWriteStream");
-      var fs$open = fs58.open;
-      fs58.open = open2;
+      var fs$open = fs59.open;
+      fs59.open = open2;
       function open2(path54, flags, mode, cb) {
         if (typeof mode === "function")
           cb = mode, mode = null;
@@ -9164,22 +9164,22 @@ var require_graceful_fs = __commonJS({
         __name(go$open, "go$open");
       }
       __name(open2, "open");
-      return fs58;
+      return fs59;
     }
     __name(patch, "patch");
     function enqueue(elem) {
       debug2("ENQUEUE", elem[0].name, elem[1]);
-      fs57[gracefulQueue].push(elem);
+      fs58[gracefulQueue].push(elem);
       retry();
     }
     __name(enqueue, "enqueue");
     var retryTimer;
     function resetQueue() {
       var now = Date.now();
-      for (var i6 = 0; i6 < fs57[gracefulQueue].length; ++i6) {
-        if (fs57[gracefulQueue][i6].length > 2) {
-          fs57[gracefulQueue][i6][3] = now;
-          fs57[gracefulQueue][i6][4] = now;
+      for (var i6 = 0; i6 < fs58[gracefulQueue].length; ++i6) {
+        if (fs58[gracefulQueue][i6].length > 2) {
+          fs58[gracefulQueue][i6][3] = now;
+          fs58[gracefulQueue][i6][4] = now;
         }
       }
       retry();
@@ -9188,9 +9188,9 @@ var require_graceful_fs = __commonJS({
     function retry() {
       clearTimeout(retryTimer);
       retryTimer = void 0;
-      if (fs57[gracefulQueue].length === 0)
+      if (fs58[gracefulQueue].length === 0)
         return;
-      var elem = fs57[gracefulQueue].shift();
+      var elem = fs58[gracefulQueue].shift();
       var fn = elem[0];
       var args = elem[1];
       var err = elem[2];
@@ -9212,7 +9212,7 @@ var require_graceful_fs = __commonJS({
           debug2("RETRY", fn.name, args);
           fn.apply(null, args.concat([startTime]));
         } else {
-          fs57[gracefulQueue].push(elem);
+          fs58[gracefulQueue].push(elem);
         }
       }
       if (retryTimer === void 0) {
@@ -9228,7 +9228,7 @@ var require_fs = __commonJS({
   "../../node_modules/fs-extra/lib/fs/index.js"(exports2) {
     "use strict";
     var u = require_universalify().fromCallback;
-    var fs57 = require_graceful_fs();
+    var fs58 = require_graceful_fs();
     var api = [
       "access",
       "appendFile",
@@ -9269,26 +9269,26 @@ var require_fs = __commonJS({
       "utimes",
       "writeFile"
     ].filter((key) => {
-      return typeof fs57[key] === "function";
+      return typeof fs58[key] === "function";
     });
-    Object.assign(exports2, fs57);
+    Object.assign(exports2, fs58);
     api.forEach((method) => {
-      exports2[method] = u(fs57[method]);
+      exports2[method] = u(fs58[method]);
     });
     exports2.exists = function(filename, callback) {
       if (typeof callback === "function") {
-        return fs57.exists(filename, callback);
+        return fs58.exists(filename, callback);
       }
       return new Promise((resolve16) => {
-        return fs57.exists(filename, resolve16);
+        return fs58.exists(filename, resolve16);
       });
     };
     exports2.read = function(fd, buffer, offset, length, position, callback) {
       if (typeof callback === "function") {
-        return fs57.read(fd, buffer, offset, length, position, callback);
+        return fs58.read(fd, buffer, offset, length, position, callback);
       }
       return new Promise((resolve16, reject) => {
-        fs57.read(fd, buffer, offset, length, position, (err, bytesRead, buffer2) => {
+        fs58.read(fd, buffer, offset, length, position, (err, bytesRead, buffer2) => {
           if (err) return reject(err);
           resolve16({ bytesRead, buffer: buffer2 });
         });
@@ -9296,10 +9296,10 @@ var require_fs = __commonJS({
     };
     exports2.write = function(fd, buffer, ...args) {
       if (typeof args[args.length - 1] === "function") {
-        return fs57.write(fd, buffer, ...args);
+        return fs58.write(fd, buffer, ...args);
       }
       return new Promise((resolve16, reject) => {
-        fs57.write(fd, buffer, ...args, (err, bytesWritten, buffer2) => {
+        fs58.write(fd, buffer, ...args, (err, bytesWritten, buffer2) => {
           if (err) return reject(err);
           resolve16({ bytesWritten, buffer: buffer2 });
         });
@@ -9307,10 +9307,10 @@ var require_fs = __commonJS({
     };
     exports2.readv = function(fd, buffers, ...args) {
       if (typeof args[args.length - 1] === "function") {
-        return fs57.readv(fd, buffers, ...args);
+        return fs58.readv(fd, buffers, ...args);
       }
       return new Promise((resolve16, reject) => {
-        fs57.readv(fd, buffers, ...args, (err, bytesRead, buffers2) => {
+        fs58.readv(fd, buffers, ...args, (err, bytesRead, buffers2) => {
           if (err) return reject(err);
           resolve16({ bytesRead, buffers: buffers2 });
         });
@@ -9318,17 +9318,17 @@ var require_fs = __commonJS({
     };
     exports2.writev = function(fd, buffers, ...args) {
       if (typeof args[args.length - 1] === "function") {
-        return fs57.writev(fd, buffers, ...args);
+        return fs58.writev(fd, buffers, ...args);
       }
       return new Promise((resolve16, reject) => {
-        fs57.writev(fd, buffers, ...args, (err, bytesWritten, buffers2) => {
+        fs58.writev(fd, buffers, ...args, (err, bytesWritten, buffers2) => {
           if (err) return reject(err);
           resolve16({ bytesWritten, buffers: buffers2 });
         });
       });
     };
-    if (typeof fs57.realpath.native === "function") {
-      exports2.realpath.native = u(fs57.realpath.native);
+    if (typeof fs58.realpath.native === "function") {
+      exports2.realpath.native = u(fs58.realpath.native);
     } else {
       process.emitWarning(
         "fs.realpath.native is not a function. Is fs being monkey-patched?",
@@ -9361,7 +9361,7 @@ var require_utils = __commonJS({
 var require_make_dir = __commonJS({
   "../../node_modules/fs-extra/lib/mkdirs/make-dir.js"(exports2, module2) {
     "use strict";
-    var fs57 = require_fs();
+    var fs58 = require_fs();
     var { checkPath } = require_utils();
     var getMode = /* @__PURE__ */ __name((options) => {
       const defaults = { mode: 511 };
@@ -9370,14 +9370,14 @@ var require_make_dir = __commonJS({
     }, "getMode");
     module2.exports.makeDir = async (dir, options) => {
       checkPath(dir);
-      return fs57.mkdir(dir, {
+      return fs58.mkdir(dir, {
         mode: getMode(options),
         recursive: true
       });
     };
     module2.exports.makeDirSync = (dir, options) => {
       checkPath(dir);
-      return fs57.mkdirSync(dir, {
+      return fs58.mkdirSync(dir, {
         mode: getMode(options),
         recursive: true
       });
@@ -9409,14 +9409,14 @@ var require_path_exists = __commonJS({
   "../../node_modules/fs-extra/lib/path-exists/index.js"(exports2, module2) {
     "use strict";
     var u = require_universalify().fromPromise;
-    var fs57 = require_fs();
+    var fs58 = require_fs();
     function pathExists9(path54) {
-      return fs57.access(path54).then(() => true).catch(() => false);
+      return fs58.access(path54).then(() => true).catch(() => false);
     }
     __name(pathExists9, "pathExists");
     module2.exports = {
       pathExists: u(pathExists9),
-      pathExistsSync: fs57.existsSync
+      pathExistsSync: fs58.existsSync
     };
   }
 });
@@ -9425,18 +9425,18 @@ var require_path_exists = __commonJS({
 var require_utimes = __commonJS({
   "../../node_modules/fs-extra/lib/util/utimes.js"(exports2, module2) {
     "use strict";
-    var fs57 = require_fs();
+    var fs58 = require_fs();
     var u = require_universalify().fromPromise;
     async function utimesMillis(path54, atime, mtime) {
-      const fd = await fs57.open(path54, "r+");
+      const fd = await fs58.open(path54, "r+");
       let error3 = null;
       try {
-        await fs57.futimes(fd, atime, mtime);
+        await fs58.futimes(fd, atime, mtime);
       } catch (futimesErr) {
         error3 = futimesErr;
       } finally {
         try {
-          await fs57.close(fd);
+          await fs58.close(fd);
         } catch (closeErr) {
           if (!error3) error3 = closeErr;
         }
@@ -9447,15 +9447,15 @@ var require_utimes = __commonJS({
     }
     __name(utimesMillis, "utimesMillis");
     function utimesMillisSync(path54, atime, mtime) {
-      const fd = fs57.openSync(path54, "r+");
+      const fd = fs58.openSync(path54, "r+");
       let error3 = null;
       try {
-        fs57.futimesSync(fd, atime, mtime);
+        fs58.futimesSync(fd, atime, mtime);
       } catch (futimesErr) {
         error3 = futimesErr;
       } finally {
         try {
-          fs57.closeSync(fd);
+          fs58.closeSync(fd);
         } catch (closeErr) {
           if (!error3) error3 = closeErr;
         }
@@ -9476,11 +9476,11 @@ var require_utimes = __commonJS({
 var require_stat = __commonJS({
   "../../node_modules/fs-extra/lib/util/stat.js"(exports2, module2) {
     "use strict";
-    var fs57 = require_fs();
+    var fs58 = require_fs();
     var path54 = require("path");
     var u = require_universalify().fromPromise;
     function getStats(src, dest, opts) {
-      const statFunc = opts.dereference ? (file) => fs57.stat(file, { bigint: true }) : (file) => fs57.lstat(file, { bigint: true });
+      const statFunc = opts.dereference ? (file) => fs58.stat(file, { bigint: true }) : (file) => fs58.lstat(file, { bigint: true });
       return Promise.all([
         statFunc(src),
         statFunc(dest).catch((err) => {
@@ -9492,7 +9492,7 @@ var require_stat = __commonJS({
     __name(getStats, "getStats");
     function getStatsSync(src, dest, opts) {
       let destStat;
-      const statFunc = opts.dereference ? (file) => fs57.statSync(file, { bigint: true }) : (file) => fs57.lstatSync(file, { bigint: true });
+      const statFunc = opts.dereference ? (file) => fs58.statSync(file, { bigint: true }) : (file) => fs58.lstatSync(file, { bigint: true });
       const srcStat = statFunc(src);
       try {
         destStat = statFunc(dest);
@@ -9557,7 +9557,7 @@ var require_stat = __commonJS({
       if (destParent === srcParent || destParent === path54.parse(destParent).root) return;
       let destStat;
       try {
-        destStat = await fs57.stat(destParent, { bigint: true });
+        destStat = await fs58.stat(destParent, { bigint: true });
       } catch (err) {
         if (err.code === "ENOENT") return;
         throw err;
@@ -9574,7 +9574,7 @@ var require_stat = __commonJS({
       if (destParent === srcParent || destParent === path54.parse(destParent).root) return;
       let destStat;
       try {
-        destStat = fs57.statSync(destParent, { bigint: true });
+        destStat = fs58.statSync(destParent, { bigint: true });
       } catch (err) {
         if (err.code === "ENOENT") return;
         throw err;
@@ -9646,12 +9646,12 @@ var require_async = __commonJS({
 var require_copy = __commonJS({
   "../../node_modules/fs-extra/lib/copy/copy.js"(exports2, module2) {
     "use strict";
-    var fs57 = require_fs();
+    var fs58 = require_fs();
     var path54 = require("path");
     var { mkdirs } = require_mkdirs();
     var { pathExists: pathExists9 } = require_path_exists();
     var { utimesMillis } = require_utimes();
-    var stat8 = require_stat();
+    var stat9 = require_stat();
     var { asyncIteratorConcurrentProcess } = require_async();
     async function copy2(src, dest, opts = {}) {
       if (typeof opts === "function") {
@@ -9666,8 +9666,8 @@ var require_copy = __commonJS({
           "fs-extra-WARN0001"
         );
       }
-      const { srcStat, destStat } = await stat8.checkPaths(src, dest, "copy", opts);
-      await stat8.checkParentPaths(src, srcStat, dest, "copy");
+      const { srcStat, destStat } = await stat9.checkPaths(src, dest, "copy", opts);
+      await stat9.checkParentPaths(src, srcStat, dest, "copy");
       const include = await runFilter(src, dest, opts);
       if (!include) return;
       const destParent = path54.dirname(dest);
@@ -9684,7 +9684,7 @@ var require_copy = __commonJS({
     }
     __name(runFilter, "runFilter");
     async function getStatsAndPerformCopy(destStat, src, dest, opts) {
-      const statFn = opts.dereference ? fs57.stat : fs57.lstat;
+      const statFn = opts.dereference ? fs58.stat : fs58.lstat;
       const srcStat = await statFn(src);
       if (srcStat.isDirectory()) return onDir(srcStat, destStat, src, dest, opts);
       if (srcStat.isFile() || srcStat.isCharacterDevice() || srcStat.isBlockDevice()) return onFile(srcStat, destStat, src, dest, opts);
@@ -9697,7 +9697,7 @@ var require_copy = __commonJS({
     async function onFile(srcStat, destStat, src, dest, opts) {
       if (!destStat) return copyFile(srcStat, src, dest, opts);
       if (opts.overwrite) {
-        await fs57.unlink(dest);
+        await fs58.unlink(dest);
         return copyFile(srcStat, src, dest, opts);
       }
       if (opts.errorOnExist) {
@@ -9706,15 +9706,15 @@ var require_copy = __commonJS({
     }
     __name(onFile, "onFile");
     async function copyFile(srcStat, src, dest, opts) {
-      await fs57.copyFile(src, dest);
+      await fs58.copyFile(src, dest);
       if (opts.preserveTimestamps) {
         if (fileIsNotWritable(srcStat.mode)) {
           await makeFileWritable(dest, srcStat.mode);
         }
-        const updatedSrcStat = await fs57.stat(src);
+        const updatedSrcStat = await fs58.stat(src);
         await utimesMillis(dest, updatedSrcStat.atime, updatedSrcStat.mtime);
       }
-      return fs57.chmod(dest, srcStat.mode);
+      return fs58.chmod(dest, srcStat.mode);
     }
     __name(copyFile, "copyFile");
     function fileIsNotWritable(srcMode) {
@@ -9722,55 +9722,55 @@ var require_copy = __commonJS({
     }
     __name(fileIsNotWritable, "fileIsNotWritable");
     function makeFileWritable(dest, srcMode) {
-      return fs57.chmod(dest, srcMode | 128);
+      return fs58.chmod(dest, srcMode | 128);
     }
     __name(makeFileWritable, "makeFileWritable");
     async function onDir(srcStat, destStat, src, dest, opts) {
       if (!destStat) {
-        await fs57.mkdir(dest);
+        await fs58.mkdir(dest);
       }
-      await asyncIteratorConcurrentProcess(await fs57.opendir(src), async (item) => {
+      await asyncIteratorConcurrentProcess(await fs58.opendir(src), async (item) => {
         const srcItem = path54.join(src, item.name);
         const destItem = path54.join(dest, item.name);
         const include = await runFilter(srcItem, destItem, opts);
         if (include) {
-          const { destStat: destStat2 } = await stat8.checkPaths(srcItem, destItem, "copy", opts);
+          const { destStat: destStat2 } = await stat9.checkPaths(srcItem, destItem, "copy", opts);
           await getStatsAndPerformCopy(destStat2, srcItem, destItem, opts);
         }
       });
       if (!destStat) {
-        await fs57.chmod(dest, srcStat.mode);
+        await fs58.chmod(dest, srcStat.mode);
       }
     }
     __name(onDir, "onDir");
     async function onLink(destStat, src, dest, opts) {
-      let resolvedSrc = await fs57.readlink(src);
+      let resolvedSrc = await fs58.readlink(src);
       if (opts.dereference) {
         resolvedSrc = path54.resolve(process.cwd(), resolvedSrc);
       }
       if (!destStat) {
-        return fs57.symlink(resolvedSrc, dest);
+        return fs58.symlink(resolvedSrc, dest);
       }
       let resolvedDest = null;
       try {
-        resolvedDest = await fs57.readlink(dest);
+        resolvedDest = await fs58.readlink(dest);
       } catch (e6) {
-        if (e6.code === "EINVAL" || e6.code === "UNKNOWN") return fs57.symlink(resolvedSrc, dest);
+        if (e6.code === "EINVAL" || e6.code === "UNKNOWN") return fs58.symlink(resolvedSrc, dest);
         throw e6;
       }
       if (opts.dereference) {
         resolvedDest = path54.resolve(process.cwd(), resolvedDest);
       }
       if (resolvedSrc !== resolvedDest) {
-        if (stat8.isSrcSubdir(resolvedSrc, resolvedDest)) {
+        if (stat9.isSrcSubdir(resolvedSrc, resolvedDest)) {
           throw new Error(`Cannot copy '${resolvedSrc}' to a subdirectory of itself, '${resolvedDest}'.`);
         }
-        if (stat8.isSrcSubdir(resolvedDest, resolvedSrc)) {
+        if (stat9.isSrcSubdir(resolvedDest, resolvedSrc)) {
           throw new Error(`Cannot overwrite '${resolvedDest}' with '${resolvedSrc}'.`);
         }
       }
-      await fs57.unlink(dest);
-      return fs57.symlink(resolvedSrc, dest);
+      await fs58.unlink(dest);
+      return fs58.symlink(resolvedSrc, dest);
     }
     __name(onLink, "onLink");
     module2.exports = copy2;
@@ -9781,11 +9781,11 @@ var require_copy = __commonJS({
 var require_copy_sync = __commonJS({
   "../../node_modules/fs-extra/lib/copy/copy-sync.js"(exports2, module2) {
     "use strict";
-    var fs57 = require_graceful_fs();
+    var fs58 = require_graceful_fs();
     var path54 = require("path");
     var mkdirsSync2 = require_mkdirs().mkdirsSync;
     var utimesMillisSync = require_utimes().utimesMillisSync;
-    var stat8 = require_stat();
+    var stat9 = require_stat();
     function copySync(src, dest, opts) {
       if (typeof opts === "function") {
         opts = { filter: opts };
@@ -9800,16 +9800,16 @@ var require_copy_sync = __commonJS({
           "fs-extra-WARN0002"
         );
       }
-      const { srcStat, destStat } = stat8.checkPathsSync(src, dest, "copy", opts);
-      stat8.checkParentPathsSync(src, srcStat, dest, "copy");
+      const { srcStat, destStat } = stat9.checkPathsSync(src, dest, "copy", opts);
+      stat9.checkParentPathsSync(src, srcStat, dest, "copy");
       if (opts.filter && !opts.filter(src, dest)) return;
       const destParent = path54.dirname(dest);
-      if (!fs57.existsSync(destParent)) mkdirsSync2(destParent);
+      if (!fs58.existsSync(destParent)) mkdirsSync2(destParent);
       return getStats(destStat, src, dest, opts);
     }
     __name(copySync, "copySync");
     function getStats(destStat, src, dest, opts) {
-      const statSync3 = opts.dereference ? fs57.statSync : fs57.lstatSync;
+      const statSync3 = opts.dereference ? fs58.statSync : fs58.lstatSync;
       const srcStat = statSync3(src);
       if (srcStat.isDirectory()) return onDir(srcStat, destStat, src, dest, opts);
       else if (srcStat.isFile() || srcStat.isCharacterDevice() || srcStat.isBlockDevice()) return onFile(srcStat, destStat, src, dest, opts);
@@ -9826,7 +9826,7 @@ var require_copy_sync = __commonJS({
     __name(onFile, "onFile");
     function mayCopyFile(srcStat, src, dest, opts) {
       if (opts.overwrite) {
-        fs57.unlinkSync(dest);
+        fs58.unlinkSync(dest);
         return copyFile(srcStat, src, dest, opts);
       } else if (opts.errorOnExist) {
         throw new Error(`'${dest}' already exists`);
@@ -9834,7 +9834,7 @@ var require_copy_sync = __commonJS({
     }
     __name(mayCopyFile, "mayCopyFile");
     function copyFile(srcStat, src, dest, opts) {
-      fs57.copyFileSync(src, dest);
+      fs58.copyFileSync(src, dest);
       if (opts.preserveTimestamps) handleTimestamps(srcStat.mode, src, dest);
       return setDestMode(dest, srcStat.mode);
     }
@@ -9853,11 +9853,11 @@ var require_copy_sync = __commonJS({
     }
     __name(makeFileWritable, "makeFileWritable");
     function setDestMode(dest, srcMode) {
-      return fs57.chmodSync(dest, srcMode);
+      return fs58.chmodSync(dest, srcMode);
     }
     __name(setDestMode, "setDestMode");
     function setDestTimestamps(src, dest) {
-      const updatedSrcStat = fs57.statSync(src);
+      const updatedSrcStat = fs58.statSync(src);
       return utimesMillisSync(dest, updatedSrcStat.atime, updatedSrcStat.mtime);
     }
     __name(setDestTimestamps, "setDestTimestamps");
@@ -9867,13 +9867,13 @@ var require_copy_sync = __commonJS({
     }
     __name(onDir, "onDir");
     function mkDirAndCopy(srcMode, src, dest, opts) {
-      fs57.mkdirSync(dest);
+      fs58.mkdirSync(dest);
       copyDir(src, dest, opts);
       return setDestMode(dest, srcMode);
     }
     __name(mkDirAndCopy, "mkDirAndCopy");
     function copyDir(src, dest, opts) {
-      const dir = fs57.opendirSync(src);
+      const dir = fs58.opendirSync(src);
       try {
         let dirent;
         while ((dirent = dir.readSync()) !== null) {
@@ -9888,33 +9888,33 @@ var require_copy_sync = __commonJS({
       const srcItem = path54.join(src, item);
       const destItem = path54.join(dest, item);
       if (opts.filter && !opts.filter(srcItem, destItem)) return;
-      const { destStat } = stat8.checkPathsSync(srcItem, destItem, "copy", opts);
+      const { destStat } = stat9.checkPathsSync(srcItem, destItem, "copy", opts);
       return getStats(destStat, srcItem, destItem, opts);
     }
     __name(copyDirItem, "copyDirItem");
     function onLink(destStat, src, dest, opts) {
-      let resolvedSrc = fs57.readlinkSync(src);
+      let resolvedSrc = fs58.readlinkSync(src);
       if (opts.dereference) {
         resolvedSrc = path54.resolve(process.cwd(), resolvedSrc);
       }
       if (!destStat) {
-        return fs57.symlinkSync(resolvedSrc, dest);
+        return fs58.symlinkSync(resolvedSrc, dest);
       } else {
         let resolvedDest;
         try {
-          resolvedDest = fs57.readlinkSync(dest);
+          resolvedDest = fs58.readlinkSync(dest);
         } catch (err) {
-          if (err.code === "EINVAL" || err.code === "UNKNOWN") return fs57.symlinkSync(resolvedSrc, dest);
+          if (err.code === "EINVAL" || err.code === "UNKNOWN") return fs58.symlinkSync(resolvedSrc, dest);
           throw err;
         }
         if (opts.dereference) {
           resolvedDest = path54.resolve(process.cwd(), resolvedDest);
         }
         if (resolvedSrc !== resolvedDest) {
-          if (stat8.isSrcSubdir(resolvedSrc, resolvedDest)) {
+          if (stat9.isSrcSubdir(resolvedSrc, resolvedDest)) {
             throw new Error(`Cannot copy '${resolvedSrc}' to a subdirectory of itself, '${resolvedDest}'.`);
           }
-          if (stat8.isSrcSubdir(resolvedDest, resolvedSrc)) {
+          if (stat9.isSrcSubdir(resolvedDest, resolvedSrc)) {
             throw new Error(`Cannot overwrite '${resolvedDest}' with '${resolvedSrc}'.`);
           }
         }
@@ -9923,8 +9923,8 @@ var require_copy_sync = __commonJS({
     }
     __name(onLink, "onLink");
     function copyLink(resolvedSrc, dest) {
-      fs57.unlinkSync(dest);
-      return fs57.symlinkSync(resolvedSrc, dest);
+      fs58.unlinkSync(dest);
+      return fs58.symlinkSync(resolvedSrc, dest);
     }
     __name(copyLink, "copyLink");
     module2.exports = copySync;
@@ -9947,14 +9947,14 @@ var require_copy2 = __commonJS({
 var require_remove = __commonJS({
   "../../node_modules/fs-extra/lib/remove/index.js"(exports2, module2) {
     "use strict";
-    var fs57 = require_graceful_fs();
+    var fs58 = require_graceful_fs();
     var u = require_universalify().fromCallback;
     function remove2(path54, callback) {
-      fs57.rm(path54, { recursive: true, force: true }, callback);
+      fs58.rm(path54, { recursive: true, force: true }, callback);
     }
     __name(remove2, "remove");
     function removeSync(path54) {
-      fs57.rmSync(path54, { recursive: true, force: true });
+      fs58.rmSync(path54, { recursive: true, force: true });
     }
     __name(removeSync, "removeSync");
     module2.exports = {
@@ -9969,14 +9969,14 @@ var require_empty = __commonJS({
   "../../node_modules/fs-extra/lib/empty/index.js"(exports2, module2) {
     "use strict";
     var u = require_universalify().fromPromise;
-    var fs57 = require_fs();
+    var fs58 = require_fs();
     var path54 = require("path");
     var mkdir2 = require_mkdirs();
     var remove2 = require_remove();
     var emptyDir = u(/* @__PURE__ */ __name(async function emptyDir2(dir) {
       let items;
       try {
-        items = await fs57.readdir(dir);
+        items = await fs58.readdir(dir);
       } catch {
         return mkdir2.mkdirs(dir);
       }
@@ -9985,7 +9985,7 @@ var require_empty = __commonJS({
     function emptyDirSync(dir) {
       let items;
       try {
-        items = fs57.readdirSync(dir);
+        items = fs58.readdirSync(dir);
       } catch {
         return mkdir2.mkdirsSync(dir);
       }
@@ -10010,52 +10010,52 @@ var require_file = __commonJS({
     "use strict";
     var u = require_universalify().fromPromise;
     var path54 = require("path");
-    var fs57 = require_fs();
+    var fs58 = require_fs();
     var mkdir2 = require_mkdirs();
     async function createFile(file) {
       let stats;
       try {
-        stats = await fs57.stat(file);
+        stats = await fs58.stat(file);
       } catch {
       }
       if (stats && stats.isFile()) return;
       const dir = path54.dirname(file);
       let dirStats = null;
       try {
-        dirStats = await fs57.stat(dir);
+        dirStats = await fs58.stat(dir);
       } catch (err) {
         if (err.code === "ENOENT") {
           await mkdir2.mkdirs(dir);
-          await fs57.writeFile(file, "");
+          await fs58.writeFile(file, "");
           return;
         } else {
           throw err;
         }
       }
       if (dirStats.isDirectory()) {
-        await fs57.writeFile(file, "");
+        await fs58.writeFile(file, "");
       } else {
-        await fs57.readdir(dir);
+        await fs58.readdir(dir);
       }
     }
     __name(createFile, "createFile");
     function createFileSync(file) {
       let stats;
       try {
-        stats = fs57.statSync(file);
+        stats = fs58.statSync(file);
       } catch {
       }
       if (stats && stats.isFile()) return;
       const dir = path54.dirname(file);
       try {
-        if (!fs57.statSync(dir).isDirectory()) {
-          fs57.readdirSync(dir);
+        if (!fs58.statSync(dir).isDirectory()) {
+          fs58.readdirSync(dir);
         }
       } catch (err) {
         if (err && err.code === "ENOENT") mkdir2.mkdirsSync(dir);
         else throw err;
       }
-      fs57.writeFileSync(file, "");
+      fs58.writeFileSync(file, "");
     }
     __name(createFileSync, "createFileSync");
     module2.exports = {
@@ -10071,19 +10071,19 @@ var require_link = __commonJS({
     "use strict";
     var u = require_universalify().fromPromise;
     var path54 = require("path");
-    var fs57 = require_fs();
+    var fs58 = require_fs();
     var mkdir2 = require_mkdirs();
     var { pathExists: pathExists9 } = require_path_exists();
     var { areIdentical } = require_stat();
     async function createLink(srcpath, dstpath) {
       let dstStat;
       try {
-        dstStat = await fs57.lstat(dstpath, { bigint: true });
+        dstStat = await fs58.lstat(dstpath, { bigint: true });
       } catch {
       }
       let srcStat;
       try {
-        srcStat = await fs57.lstat(srcpath, { bigint: true });
+        srcStat = await fs58.lstat(srcpath, { bigint: true });
       } catch (err) {
         err.message = err.message.replace("lstat", "ensureLink");
         throw err;
@@ -10094,27 +10094,27 @@ var require_link = __commonJS({
       if (!dirExists) {
         await mkdir2.mkdirs(dir);
       }
-      await fs57.link(srcpath, dstpath);
+      await fs58.link(srcpath, dstpath);
     }
     __name(createLink, "createLink");
     function createLinkSync(srcpath, dstpath) {
       let dstStat;
       try {
-        dstStat = fs57.lstatSync(dstpath, { bigint: true });
+        dstStat = fs58.lstatSync(dstpath, { bigint: true });
       } catch {
       }
       try {
-        const srcStat = fs57.lstatSync(srcpath, { bigint: true });
+        const srcStat = fs58.lstatSync(srcpath, { bigint: true });
         if (dstStat && areIdentical(srcStat, dstStat)) return;
       } catch (err) {
         err.message = err.message.replace("lstat", "ensureLink");
         throw err;
       }
       const dir = path54.dirname(dstpath);
-      const dirExists = fs57.existsSync(dir);
-      if (dirExists) return fs57.linkSync(srcpath, dstpath);
+      const dirExists = fs58.existsSync(dir);
+      if (dirExists) return fs58.linkSync(srcpath, dstpath);
       mkdir2.mkdirsSync(dir);
-      return fs57.linkSync(srcpath, dstpath);
+      return fs58.linkSync(srcpath, dstpath);
     }
     __name(createLinkSync, "createLinkSync");
     module2.exports = {
@@ -10129,13 +10129,13 @@ var require_symlink_paths = __commonJS({
   "../../node_modules/fs-extra/lib/ensure/symlink-paths.js"(exports2, module2) {
     "use strict";
     var path54 = require("path");
-    var fs57 = require_fs();
+    var fs58 = require_fs();
     var { pathExists: pathExists9 } = require_path_exists();
     var u = require_universalify().fromPromise;
     async function symlinkPaths(srcpath, dstpath) {
       if (path54.isAbsolute(srcpath)) {
         try {
-          await fs57.lstat(srcpath);
+          await fs58.lstat(srcpath);
         } catch (err) {
           err.message = err.message.replace("lstat", "ensureSymlink");
           throw err;
@@ -10155,7 +10155,7 @@ var require_symlink_paths = __commonJS({
         };
       }
       try {
-        await fs57.lstat(srcpath);
+        await fs58.lstat(srcpath);
       } catch (err) {
         err.message = err.message.replace("lstat", "ensureSymlink");
         throw err;
@@ -10168,7 +10168,7 @@ var require_symlink_paths = __commonJS({
     __name(symlinkPaths, "symlinkPaths");
     function symlinkPathsSync(srcpath, dstpath) {
       if (path54.isAbsolute(srcpath)) {
-        const exists2 = fs57.existsSync(srcpath);
+        const exists2 = fs58.existsSync(srcpath);
         if (!exists2) throw new Error("absolute srcpath does not exist");
         return {
           toCwd: srcpath,
@@ -10177,14 +10177,14 @@ var require_symlink_paths = __commonJS({
       }
       const dstdir = path54.dirname(dstpath);
       const relativeToDst = path54.join(dstdir, srcpath);
-      const exists = fs57.existsSync(relativeToDst);
+      const exists = fs58.existsSync(relativeToDst);
       if (exists) {
         return {
           toCwd: relativeToDst,
           toDst: srcpath
         };
       }
-      const srcExists = fs57.existsSync(srcpath);
+      const srcExists = fs58.existsSync(srcpath);
       if (!srcExists) throw new Error("relative srcpath does not exist");
       return {
         toCwd: srcpath,
@@ -10203,13 +10203,13 @@ var require_symlink_paths = __commonJS({
 var require_symlink_type = __commonJS({
   "../../node_modules/fs-extra/lib/ensure/symlink-type.js"(exports2, module2) {
     "use strict";
-    var fs57 = require_fs();
+    var fs58 = require_fs();
     var u = require_universalify().fromPromise;
     async function symlinkType(srcpath, type) {
       if (type) return type;
       let stats;
       try {
-        stats = await fs57.lstat(srcpath);
+        stats = await fs58.lstat(srcpath);
       } catch {
         return "file";
       }
@@ -10220,7 +10220,7 @@ var require_symlink_type = __commonJS({
       if (type) return type;
       let stats;
       try {
-        stats = fs57.lstatSync(srcpath);
+        stats = fs58.lstatSync(srcpath);
       } catch {
         return "file";
       }
@@ -10240,7 +10240,7 @@ var require_symlink = __commonJS({
     "use strict";
     var u = require_universalify().fromPromise;
     var path54 = require("path");
-    var fs57 = require_fs();
+    var fs58 = require_fs();
     var { mkdirs, mkdirsSync: mkdirsSync2 } = require_mkdirs();
     var { symlinkPaths, symlinkPathsSync } = require_symlink_paths();
     var { symlinkType, symlinkTypeSync } = require_symlink_type();
@@ -10249,23 +10249,23 @@ var require_symlink = __commonJS({
     async function createSymlink(srcpath, dstpath, type) {
       let stats;
       try {
-        stats = await fs57.lstat(dstpath);
+        stats = await fs58.lstat(dstpath);
       } catch {
       }
       if (stats && stats.isSymbolicLink()) {
         let srcStat;
         if (path54.isAbsolute(srcpath)) {
-          srcStat = await fs57.stat(srcpath, { bigint: true });
+          srcStat = await fs58.stat(srcpath, { bigint: true });
         } else {
           const dstdir = path54.dirname(dstpath);
           const relativeToDst = path54.join(dstdir, srcpath);
           try {
-            srcStat = await fs57.stat(relativeToDst, { bigint: true });
+            srcStat = await fs58.stat(relativeToDst, { bigint: true });
           } catch {
-            srcStat = await fs57.stat(srcpath, { bigint: true });
+            srcStat = await fs58.stat(srcpath, { bigint: true });
           }
         }
-        const dstStat = await fs57.stat(dstpath, { bigint: true });
+        const dstStat = await fs58.stat(dstpath, { bigint: true });
         if (areIdentical(srcStat, dstStat)) return;
       }
       const relative6 = await symlinkPaths(srcpath, dstpath);
@@ -10275,39 +10275,39 @@ var require_symlink = __commonJS({
       if (!await pathExists9(dir)) {
         await mkdirs(dir);
       }
-      return fs57.symlink(srcpath, dstpath, toType);
+      return fs58.symlink(srcpath, dstpath, toType);
     }
     __name(createSymlink, "createSymlink");
     function createSymlinkSync(srcpath, dstpath, type) {
       let stats;
       try {
-        stats = fs57.lstatSync(dstpath);
+        stats = fs58.lstatSync(dstpath);
       } catch {
       }
       if (stats && stats.isSymbolicLink()) {
         let srcStat;
         if (path54.isAbsolute(srcpath)) {
-          srcStat = fs57.statSync(srcpath, { bigint: true });
+          srcStat = fs58.statSync(srcpath, { bigint: true });
         } else {
           const dstdir = path54.dirname(dstpath);
           const relativeToDst = path54.join(dstdir, srcpath);
           try {
-            srcStat = fs57.statSync(relativeToDst, { bigint: true });
+            srcStat = fs58.statSync(relativeToDst, { bigint: true });
           } catch {
-            srcStat = fs57.statSync(srcpath, { bigint: true });
+            srcStat = fs58.statSync(srcpath, { bigint: true });
           }
         }
-        const dstStat = fs57.statSync(dstpath, { bigint: true });
+        const dstStat = fs58.statSync(dstpath, { bigint: true });
         if (areIdentical(srcStat, dstStat)) return;
       }
       const relative6 = symlinkPathsSync(srcpath, dstpath);
       srcpath = relative6.toDst;
       type = symlinkTypeSync(relative6.toCwd, type);
       const dir = path54.dirname(dstpath);
-      const exists = fs57.existsSync(dir);
-      if (exists) return fs57.symlinkSync(srcpath, dstpath, type);
+      const exists = fs58.existsSync(dir);
+      if (exists) return fs58.symlinkSync(srcpath, dstpath, type);
       mkdirsSync2(dir);
-      return fs57.symlinkSync(srcpath, dstpath, type);
+      return fs58.symlinkSync(srcpath, dstpath, type);
     }
     __name(createSymlinkSync, "createSymlinkSync");
     module2.exports = {
@@ -10377,9 +10377,9 @@ var require_jsonfile = __commonJS({
       if (typeof options === "string") {
         options = { encoding: options };
       }
-      const fs57 = options.fs || _fs;
+      const fs58 = options.fs || _fs;
       const shouldThrow = "throws" in options ? options.throws : true;
-      let data2 = await universalify.fromCallback(fs57.readFile)(file, options);
+      let data2 = await universalify.fromCallback(fs58.readFile)(file, options);
       data2 = stripBom(data2);
       let obj;
       try {
@@ -10395,15 +10395,15 @@ var require_jsonfile = __commonJS({
       return obj;
     }
     __name(_readFile, "_readFile");
-    var readFile11 = universalify.fromPromise(_readFile);
-    function readFileSync20(file, options = {}) {
+    var readFile12 = universalify.fromPromise(_readFile);
+    function readFileSync21(file, options = {}) {
       if (typeof options === "string") {
         options = { encoding: options };
       }
-      const fs57 = options.fs || _fs;
+      const fs58 = options.fs || _fs;
       const shouldThrow = "throws" in options ? options.throws : true;
       try {
-        let content = fs57.readFileSync(file, options);
+        let content = fs58.readFileSync(file, options);
         content = stripBom(content);
         return JSON.parse(content, options.reviver);
       } catch (err) {
@@ -10415,23 +10415,23 @@ var require_jsonfile = __commonJS({
         }
       }
     }
-    __name(readFileSync20, "readFileSync");
+    __name(readFileSync21, "readFileSync");
     async function _writeFile(file, obj, options = {}) {
-      const fs57 = options.fs || _fs;
+      const fs58 = options.fs || _fs;
       const str = stringify2(obj, options);
-      await universalify.fromCallback(fs57.writeFile)(file, str, options);
+      await universalify.fromCallback(fs58.writeFile)(file, str, options);
     }
     __name(_writeFile, "_writeFile");
     var writeFile6 = universalify.fromPromise(_writeFile);
     function writeFileSync6(file, obj, options = {}) {
-      const fs57 = options.fs || _fs;
+      const fs58 = options.fs || _fs;
       const str = stringify2(obj, options);
-      return fs57.writeFileSync(file, str, options);
+      return fs58.writeFileSync(file, str, options);
     }
     __name(writeFileSync6, "writeFileSync");
     module2.exports = {
-      readFile: readFile11,
-      readFileSync: readFileSync20,
+      readFile: readFile12,
+      readFileSync: readFileSync21,
       writeFile: writeFile6,
       writeFileSync: writeFileSync6
     };
@@ -10458,7 +10458,7 @@ var require_output_file = __commonJS({
   "../../node_modules/fs-extra/lib/output-file/index.js"(exports2, module2) {
     "use strict";
     var u = require_universalify().fromPromise;
-    var fs57 = require_fs();
+    var fs58 = require_fs();
     var path54 = require("path");
     var mkdir2 = require_mkdirs();
     var pathExists9 = require_path_exists().pathExists;
@@ -10467,15 +10467,15 @@ var require_output_file = __commonJS({
       if (!await pathExists9(dir)) {
         await mkdir2.mkdirs(dir);
       }
-      return fs57.writeFile(file, data2, encoding);
+      return fs58.writeFile(file, data2, encoding);
     }
     __name(outputFile, "outputFile");
     function outputFileSync(file, ...args) {
       const dir = path54.dirname(file);
-      if (!fs57.existsSync(dir)) {
+      if (!fs58.existsSync(dir)) {
         mkdir2.mkdirsSync(dir);
       }
-      fs57.writeFileSync(file, ...args);
+      fs58.writeFileSync(file, ...args);
     }
     __name(outputFileSync, "outputFileSync");
     module2.exports = {
@@ -10537,17 +10537,17 @@ var require_json = __commonJS({
 var require_move = __commonJS({
   "../../node_modules/fs-extra/lib/move/move.js"(exports2, module2) {
     "use strict";
-    var fs57 = require_fs();
+    var fs58 = require_fs();
     var path54 = require("path");
     var { copy: copy2 } = require_copy2();
     var { remove: remove2 } = require_remove();
     var { mkdirp: mkdirp2 } = require_mkdirs();
     var { pathExists: pathExists9 } = require_path_exists();
-    var stat8 = require_stat();
+    var stat9 = require_stat();
     async function move(src, dest, opts = {}) {
       const overwrite = opts.overwrite || opts.clobber || false;
-      const { srcStat, isChangingCase = false } = await stat8.checkPaths(src, dest, "move", opts);
-      await stat8.checkParentPaths(src, srcStat, dest, "move");
+      const { srcStat, isChangingCase = false } = await stat9.checkPaths(src, dest, "move", opts);
+      await stat9.checkParentPaths(src, srcStat, dest, "move");
       const destParent = path54.dirname(dest);
       const parsedParentPath = path54.parse(destParent);
       if (parsedParentPath.root !== destParent) {
@@ -10565,7 +10565,7 @@ var require_move = __commonJS({
         }
       }
       try {
-        await fs57.rename(src, dest);
+        await fs58.rename(src, dest);
       } catch (err) {
         if (err.code !== "EXDEV") {
           throw err;
@@ -10592,17 +10592,17 @@ var require_move = __commonJS({
 var require_move_sync = __commonJS({
   "../../node_modules/fs-extra/lib/move/move-sync.js"(exports2, module2) {
     "use strict";
-    var fs57 = require_graceful_fs();
+    var fs58 = require_graceful_fs();
     var path54 = require("path");
     var copySync = require_copy2().copySync;
     var removeSync = require_remove().removeSync;
     var mkdirpSync2 = require_mkdirs().mkdirpSync;
-    var stat8 = require_stat();
+    var stat9 = require_stat();
     function moveSync(src, dest, opts) {
       opts = opts || {};
       const overwrite = opts.overwrite || opts.clobber || false;
-      const { srcStat, isChangingCase = false } = stat8.checkPathsSync(src, dest, "move", opts);
-      stat8.checkParentPathsSync(src, srcStat, dest, "move");
+      const { srcStat, isChangingCase = false } = stat9.checkPathsSync(src, dest, "move", opts);
+      stat9.checkParentPathsSync(src, srcStat, dest, "move");
       if (!isParentRoot(dest)) mkdirpSync2(path54.dirname(dest));
       return doRename(src, dest, overwrite, isChangingCase);
     }
@@ -10619,13 +10619,13 @@ var require_move_sync = __commonJS({
         removeSync(dest);
         return rename(src, dest, overwrite);
       }
-      if (fs57.existsSync(dest)) throw new Error("dest already exists.");
+      if (fs58.existsSync(dest)) throw new Error("dest already exists.");
       return rename(src, dest, overwrite);
     }
     __name(doRename, "doRename");
     function rename(src, dest, overwrite) {
       try {
-        fs57.renameSync(src, dest);
+        fs58.renameSync(src, dest);
       } catch (err) {
         if (err.code !== "EXDEV") throw err;
         return moveAcrossDevice(src, dest, overwrite);
@@ -10808,11 +10808,11 @@ async function shell(command6, options) {
       child.stdin.write(options.input);
       child.stdin.end();
     }
-    const stdout = new Array();
+    const stdout2 = new Array();
     const stderr = new Array();
     child.stdout.on("data", (chunk) => {
       handleShellOutput(chunk, options, "data_stdout");
-      stdout.push(chunk);
+      stdout2.push(chunk);
     });
     child.stderr.on("data", (chunk) => {
       handleShellOutput(chunk, options, "data_stderr");
@@ -10822,7 +10822,7 @@ async function shell(command6, options) {
     child.once("close", (code, signal) => {
       handleShellOutput(renderCommandLine(command6), options, "close");
       if (code === 0) {
-        resolve16(Buffer.concat(stdout).toString("utf-8"));
+        resolve16(Buffer.concat(stdout2).toString("utf-8"));
       } else {
         const out = Buffer.concat(stderr).toString("utf-8").trim();
         reject(
@@ -11640,9 +11640,9 @@ var require_path = __commonJS({
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.convertPosixPathToPattern = exports2.convertWindowsPathToPattern = exports2.convertPathToPattern = exports2.escapePosixPath = exports2.escapeWindowsPath = exports2.escape = exports2.removeLeadingDotSegment = exports2.makeAbsolute = exports2.unixify = void 0;
-    var os14 = require("os");
+    var os15 = require("os");
     var path54 = require("path");
-    var IS_WINDOWS_PLATFORM = os14.platform() === "win32";
+    var IS_WINDOWS_PLATFORM = os15.platform() === "win32";
     var LEADING_DOT_SEGMENT_CHARACTERS_COUNT = 2;
     var POSIX_UNESCAPED_GLOB_SYMBOLS_RE = /(\\?)([()*?[\]{|}]|^!|[!+@](?=\()|\\(?![!()*+?@[\]{|}]))/g;
     var WINDOWS_UNESCAPED_GLOB_SYMBOLS_RE = /(\\?)([()[\]{}]|^!|[!+@](?=\())/g;
@@ -15243,8 +15243,8 @@ var require_utils5 = __commonJS({
     exports2.array = array;
     var errno = require_errno();
     exports2.errno = errno;
-    var fs57 = require_fs2();
-    exports2.fs = fs57;
+    var fs58 = require_fs2();
+    exports2.fs = fs58;
     var path54 = require_path();
     exports2.path = path54;
     var pattern = require_pattern();
@@ -15376,7 +15376,7 @@ var require_async2 = __commonJS({
           callSuccessCallback(callback, lstat3);
           return;
         }
-        settings.fs.stat(path54, (statError, stat8) => {
+        settings.fs.stat(path54, (statError, stat9) => {
           if (statError !== null) {
             if (settings.throwErrorOnBrokenSymbolicLink) {
               callFailureCallback(callback, statError);
@@ -15386,9 +15386,9 @@ var require_async2 = __commonJS({
             return;
           }
           if (settings.markSymbolicLink) {
-            stat8.isSymbolicLink = () => true;
+            stat9.isSymbolicLink = () => true;
           }
-          callSuccessCallback(callback, stat8);
+          callSuccessCallback(callback, stat9);
         });
       });
     }
@@ -15417,11 +15417,11 @@ var require_sync = __commonJS({
         return lstat3;
       }
       try {
-        const stat8 = settings.fs.statSync(path54);
+        const stat9 = settings.fs.statSync(path54);
         if (settings.markSymbolicLink) {
-          stat8.isSymbolicLink = () => true;
+          stat9.isSymbolicLink = () => true;
         }
-        return stat8;
+        return stat9;
       } catch (error3) {
         if (!settings.throwErrorOnBrokenSymbolicLink) {
           return lstat3;
@@ -15440,12 +15440,12 @@ var require_fs3 = __commonJS({
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.createFileSystemAdapter = exports2.FILE_SYSTEM_ADAPTER = void 0;
-    var fs57 = require("fs");
+    var fs58 = require("fs");
     exports2.FILE_SYSTEM_ADAPTER = {
-      lstat: fs57.lstat,
-      stat: fs57.stat,
-      lstatSync: fs57.lstatSync,
-      statSync: fs57.statSync
+      lstat: fs58.lstat,
+      stat: fs58.stat,
+      lstatSync: fs58.lstatSync,
+      statSync: fs58.statSync
     };
     function createFileSystemAdapter(fsMethods) {
       if (fsMethods === void 0) {
@@ -15463,7 +15463,7 @@ var require_settings = __commonJS({
   "../../node_modules/@nodelib/fs.stat/out/settings.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
-    var fs57 = require_fs3();
+    var fs58 = require_fs3();
     var Settings2 = class {
       static {
         __name(this, "Settings");
@@ -15471,7 +15471,7 @@ var require_settings = __commonJS({
       constructor(_options = {}) {
         this._options = _options;
         this.followSymbolicLink = this._getValue(this._options.followSymbolicLink, true);
-        this.fs = fs57.createFileSystemAdapter(this._options.fs);
+        this.fs = fs58.createFileSystemAdapter(this._options.fs);
         this.markSymbolicLink = this._getValue(this._options.markSymbolicLink, false);
         this.throwErrorOnBrokenSymbolicLink = this._getValue(this._options.throwErrorOnBrokenSymbolicLink, true);
       }
@@ -15493,15 +15493,15 @@ var require_out = __commonJS({
     var sync = require_sync();
     var settings_1 = require_settings();
     exports2.Settings = settings_1.default;
-    function stat8(path54, optionsOrSettingsOrCallback, callback) {
+    function stat9(path54, optionsOrSettingsOrCallback, callback) {
       if (typeof optionsOrSettingsOrCallback === "function") {
         async.read(path54, getSettings(), optionsOrSettingsOrCallback);
         return;
       }
       async.read(path54, getSettings(optionsOrSettingsOrCallback), callback);
     }
-    __name(stat8, "stat");
-    exports2.stat = stat8;
+    __name(stat9, "stat");
+    exports2.stat = stat9;
     function statSync3(path54, optionsOrSettings) {
       const settings = getSettings(optionsOrSettings);
       return sync.read(path54, settings);
@@ -15637,8 +15637,8 @@ var require_utils6 = __commonJS({
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.fs = void 0;
-    var fs57 = require_fs4();
-    exports2.fs = fs57;
+    var fs58 = require_fs4();
+    exports2.fs = fs58;
   }
 });
 
@@ -15843,14 +15843,14 @@ var require_fs5 = __commonJS({
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.createFileSystemAdapter = exports2.FILE_SYSTEM_ADAPTER = void 0;
-    var fs57 = require("fs");
+    var fs58 = require("fs");
     exports2.FILE_SYSTEM_ADAPTER = {
-      lstat: fs57.lstat,
-      stat: fs57.stat,
-      lstatSync: fs57.lstatSync,
-      statSync: fs57.statSync,
-      readdir: fs57.readdir,
-      readdirSync: fs57.readdirSync
+      lstat: fs58.lstat,
+      stat: fs58.stat,
+      lstatSync: fs58.lstatSync,
+      statSync: fs58.statSync,
+      readdir: fs58.readdir,
+      readdirSync: fs58.readdirSync
     };
     function createFileSystemAdapter(fsMethods) {
       if (fsMethods === void 0) {
@@ -15870,7 +15870,7 @@ var require_settings2 = __commonJS({
     Object.defineProperty(exports2, "__esModule", { value: true });
     var path54 = require("path");
     var fsStat = require_out();
-    var fs57 = require_fs5();
+    var fs58 = require_fs5();
     var Settings2 = class {
       static {
         __name(this, "Settings");
@@ -15878,7 +15878,7 @@ var require_settings2 = __commonJS({
       constructor(_options = {}) {
         this._options = _options;
         this.followSymbolicLinks = this._getValue(this._options.followSymbolicLinks, false);
-        this.fs = fs57.createFileSystemAdapter(this._options.fs);
+        this.fs = fs58.createFileSystemAdapter(this._options.fs);
         this.pathSegmentSeparator = this._getValue(this._options.pathSegmentSeparator, path54.sep);
         this.stats = this._getValue(this._options.stats, false);
         this.throwErrorOnBrokenSymbolicLink = this._getValue(this._options.throwErrorOnBrokenSymbolicLink, true);
@@ -17359,16 +17359,16 @@ var require_settings4 = __commonJS({
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.DEFAULT_FILE_SYSTEM_ADAPTER = void 0;
-    var fs57 = require("fs");
-    var os14 = require("os");
-    var CPU_COUNT = Math.max(os14.cpus().length, 1);
+    var fs58 = require("fs");
+    var os15 = require("os");
+    var CPU_COUNT = Math.max(os15.cpus().length, 1);
     exports2.DEFAULT_FILE_SYSTEM_ADAPTER = {
-      lstat: fs57.lstat,
-      lstatSync: fs57.lstatSync,
-      stat: fs57.stat,
-      statSync: fs57.statSync,
-      readdir: fs57.readdir,
-      readdirSync: fs57.readdirSync
+      lstat: fs58.lstat,
+      lstatSync: fs58.lstatSync,
+      stat: fs58.stat,
+      statSync: fs58.statSync,
+      readdir: fs58.readdir,
+      readdirSync: fs58.readdirSync
     };
     var Settings2 = class {
       static {
@@ -17846,7 +17846,7 @@ var require_dist = __commonJS({
 // ../../node_modules/yazl/index.js
 var require_yazl = __commonJS({
   "../../node_modules/yazl/index.js"(exports2) {
-    var fs57 = require("fs");
+    var fs58 = require("fs");
     var Transform = require("stream").Transform;
     var PassThrough2 = require("stream").PassThrough;
     var zlib2 = require("zlib");
@@ -17877,14 +17877,14 @@ var require_yazl = __commonJS({
       if (shouldIgnoreAdding(self2)) return;
       var entry = new Entry(metadataPath, false, options);
       self2.entries.push(entry);
-      fs57.stat(realPath, function(err, stats) {
+      fs58.stat(realPath, function(err, stats) {
         if (err) return self2.emit("error", err);
         if (!stats.isFile()) return self2.emit("error", new Error("not a file: " + realPath));
         entry.uncompressedSize = stats.size;
         if (options.mtime == null) entry.setLastModDate(stats.mtime);
         if (options.mode == null) entry.setFileAttributesMode(stats.mode);
         entry.setFileDataPumpFunction(function() {
-          var readStream = fs57.createReadStream(realPath);
+          var readStream = fs58.createReadStream(realPath);
           entry.state = Entry.FILE_DATA_IN_PROGRESS;
           readStream.on("error", function(err2) {
             self2.emit("error", err2);
@@ -18603,11 +18603,11 @@ var require_zip = __commonJS({
         zip2.outputStream.pipe(output);
         for (const file of files) {
           const fullPath = path54.resolve(directory, file);
-          const [data2, stat8] = await Promise.all([fs_1.promises.readFile(fullPath), fs_1.promises.stat(fullPath)]);
+          const [data2, stat9] = await Promise.all([fs_1.promises.readFile(fullPath), fs_1.promises.stat(fullPath)]);
           zip2.addBuffer(data2, file, {
             mtime: epoch(),
             // reset dates to get the same hash for the same content
-            mode: stat8.mode,
+            mode: stat9.mode,
             // Only emit the DOS timestamp (no UTC "universal time" extended field),
             // so the archive bytes do not depend on the machine's timezone.
             forceDosTimestamp: true
@@ -35533,7 +35533,7 @@ var require_dist_cjs6 = __commonJS({
     var { setCredentialFeature: setCredentialFeature2 } = (init_client3(), __toCommonJS(client_exports2));
     var { CredentialsProviderError: CredentialsProviderError2 } = (init_config2(), __toCommonJS(config_exports));
     var { NodeHttpHandler } = require_dist_cjs5();
-    var fs57 = require("node:fs/promises");
+    var fs58 = require("node:fs/promises");
     var { HttpRequest: HttpRequest2 } = (init_protocols(), __toCommonJS(protocols_exports));
     var { sdkStreamMixin: sdkStreamMixin3, parseRfc3339DateTime: parseRfc3339DateTime2 } = (init_serde(), __toCommonJS(serde_exports));
     var ECS_CONTAINER_HOST = "169.254.170.2";
@@ -35661,7 +35661,7 @@ Set AWS_CONTAINER_CREDENTIALS_FULL_URI or AWS_CONTAINER_CREDENTIALS_RELATIVE_URI
         if (token) {
           request4.headers.Authorization = token;
         } else if (tokenFile) {
-          request4.headers.Authorization = (await fs57.readFile(tokenFile)).toString();
+          request4.headers.Authorization = (await fs58.readFile(tokenFile)).toString();
         }
         try {
           const result2 = await requestHandler.handle(request4, { requestTimeout });
@@ -42421,12 +42421,12 @@ var init_signin = __esm({
 var require_dist_cjs10 = __commonJS({
   "../../node_modules/@aws-sdk/credential-provider-login/dist-cjs/index.js"(exports2) {
     var { setCredentialFeature: setCredentialFeature2 } = (init_client3(), __toCommonJS(client_exports2));
-    var { CredentialsProviderError: CredentialsProviderError2, readFile: readFile11, parseKnownFiles: parseKnownFiles2, getProfileName: getProfileName2 } = (init_config2(), __toCommonJS(config_exports));
+    var { CredentialsProviderError: CredentialsProviderError2, readFile: readFile12, parseKnownFiles: parseKnownFiles2, getProfileName: getProfileName2 } = (init_config2(), __toCommonJS(config_exports));
     var { HttpRequest: HttpRequest2 } = (init_protocols(), __toCommonJS(protocols_exports));
     var { createHash: createHash8, createPrivateKey, createPublicKey, sign: sign3 } = require("node:crypto");
     var { promises: promises8 } = require("node:fs");
-    var { homedir: homedir7 } = require("node:os");
-    var { dirname: dirname17, join: join54 } = require("node:path");
+    var { homedir: homedir8 } = require("node:os");
+    var { dirname: dirname17, join: join55 } = require("node:path");
     var LoginCredentialsFetcher = class _LoginCredentialsFetcher {
       static {
         __name(this, "LoginCredentialsFetcher");
@@ -42552,7 +42552,7 @@ var require_dist_cjs10 = __commonJS({
         try {
           let tokenData;
           try {
-            tokenData = await readFile11(tokenFilePath, { ignoreCache: this.init?.ignoreCache });
+            tokenData = await readFile12(tokenFilePath, { ignoreCache: this.init?.ignoreCache });
           } catch {
             tokenData = await promises8.readFile(tokenFilePath, "utf8");
           }
@@ -42585,10 +42585,10 @@ var require_dist_cjs10 = __commonJS({
         await promises8.writeFile(tokenFilePath, JSON.stringify(token, null, 2), "utf8");
       }
       getTokenFilePath() {
-        const directory = process.env.AWS_LOGIN_CACHE_DIRECTORY ?? join54(homedir7(), ".aws", "login", "cache");
+        const directory = process.env.AWS_LOGIN_CACHE_DIRECTORY ?? join55(homedir8(), ".aws", "login", "cache");
         const loginSessionBytes = Buffer.from(this.loginSession, "utf8");
         const loginSessionSha256 = createHash8("sha256").update(loginSessionBytes).digest("hex");
-        return join54(directory, `${loginSessionSha256}.json`);
+        return join55(directory, `${loginSessionSha256}.json`);
       }
       derToRawSignature(derSignature) {
         let offset = 2;
@@ -44135,10 +44135,10 @@ var require_dist_cjs12 = __commonJS({
         if (credentialProcess !== void 0) {
           const execPromise = promisify4(externalDataInterceptor2?.getTokenRecord?.().exec ?? exec5);
           try {
-            const { stdout } = await execPromise(credentialProcess);
+            const { stdout: stdout2 } = await execPromise(credentialProcess);
             let data2;
             try {
-              data2 = JSON.parse(stdout.trim());
+              data2 = JSON.parse(stdout2.trim());
             } catch {
               throw Error(`Profile ${profileName} credential_process returned invalid JSON.`);
             }
@@ -44171,7 +44171,7 @@ var require_dist_cjs13 = __commonJS({
   "../../node_modules/@aws-sdk/credential-provider-web-identity/dist-cjs/index.js"(exports2) {
     var { setCredentialFeature: setCredentialFeature2 } = (init_client3(), __toCommonJS(client_exports2));
     var { CredentialsProviderError: CredentialsProviderError2, externalDataInterceptor: externalDataInterceptor2 } = (init_config2(), __toCommonJS(config_exports));
-    var { readFileSync: readFileSync20 } = require("node:fs");
+    var { readFileSync: readFileSync21 } = require("node:fs");
     var fromWebToken = /* @__PURE__ */ __name((init) => async (awsIdentityProperties) => {
       init.logger?.debug("@aws-sdk/credential-provider-web-identity - fromWebToken");
       const { roleArn, roleSessionName, webIdentityToken, providerId, policyArns, policy, durationSeconds } = init;
@@ -44212,7 +44212,7 @@ var require_dist_cjs13 = __commonJS({
       }
       const credentials = await fromWebToken({
         ...init,
-        webIdentityToken: externalDataInterceptor2?.getTokenRecord?.()[webIdentityTokenFile] ?? readFileSync20(webIdentityTokenFile, { encoding: "ascii" }),
+        webIdentityToken: externalDataInterceptor2?.getTokenRecord?.()[webIdentityTokenFile] ?? readFileSync21(webIdentityTokenFile, { encoding: "ascii" }),
         roleArn,
         roleSessionName
       })(awsIdentityProperties);
@@ -69049,7 +69049,7 @@ var require_has_flag = __commonJS({
 var require_supports_color = __commonJS({
   "../../node_modules/supports-color/index.js"(exports2, module2) {
     "use strict";
-    var os14 = require("os");
+    var os15 = require("os");
     var tty = require("tty");
     var hasFlag = require_has_flag();
     var { env: env3 } = process;
@@ -69098,7 +69098,7 @@ var require_supports_color = __commonJS({
         return min;
       }
       if (process.platform === "win32") {
-        const osRelease = os14.release().split(".");
+        const osRelease = os15.release().split(".");
         if (Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) {
           return Number(osRelease[2]) >= 14931 ? 3 : 2;
         }
@@ -70236,13 +70236,42 @@ function formatErrorMessage(error3) {
     return `${error3.message}
 ${formatErrorMessage(error3.cause)}`;
   }
-  return error3?.message || error3?.toString() || "Unknown error";
+  if (error3?.message) {
+    return error3.message;
+  }
+  const fromSdk = formatSdkError(error3);
+  if (fromSdk) {
+    return fromSdk;
+  }
+  return error3?.toString() || "Unknown error";
+}
+function formatSdkError(error3) {
+  const name = error3?.name ?? error3?.code;
+  const metadata = error3?.$metadata ?? {};
+  const details = [];
+  if (typeof metadata.httpStatusCode === "number") {
+    details.push(`HTTP ${metadata.httpStatusCode}`);
+  }
+  if (metadata.requestId) {
+    details.push(`request id: ${metadata.requestId}`);
+  }
+  if (name && details.length > 0) {
+    return `${name} (${details.join(", ")})`;
+  }
+  if (name) {
+    return name;
+  }
+  if (details.length > 0) {
+    return details.join(", ");
+  }
+  return void 0;
 }
 var init_format_error = __esm({
   "../@aws-cdk/toolkit-lib/lib/util/format-error.ts"() {
     "use strict";
     init_toolkit_error();
     __name(formatErrorMessage, "formatErrorMessage");
+    __name(formatSdkError, "formatSdkError");
   }
 });
 
@@ -106564,14 +106593,16 @@ var init_deploy_stack = __esm({
         const replacement = hasReplacement(changeSetDescription);
         const isPausedFailState = this.cloudFormationStack.stackStatus.isRollbackable;
         const rollback = this.options.rollback ?? true;
-        const expressNoRollback = this.options.express && this.options.rollback !== true;
+        if (this.options.express) {
+          return this.executeChangeSet(changeSetDescription);
+        }
         if (isPausedFailState && replacement) {
           return { type: "failpaused-need-rollback-first", reason: "replacement", status: this.cloudFormationStack.stackStatus.name };
         }
         if (isPausedFailState && rollback) {
           return { type: "failpaused-need-rollback-first", reason: "not-norollback", status: this.cloudFormationStack.stackStatus.name };
         }
-        if ((!rollback || expressNoRollback) && replacement) {
+        if (!rollback && replacement) {
           return { type: "replacement-requires-rollback" };
         }
         return this.executeChangeSet(changeSetDescription);
@@ -275685,12 +275716,12 @@ function isEc2Instance() {
   return cachedIsEc2;
 }
 function detectEc2() {
-  const os14 = (0, import_node_os3.platform)();
+  const os15 = (0, import_node_os3.platform)();
   try {
-    if (os14 === "linux") {
+    if (os15 === "linux") {
       return detectEc2Linux();
     }
-    if (os14 === "win32") {
+    if (os15 === "win32") {
       return detectEc2Windows();
     }
     return false;
@@ -278176,7 +278207,7 @@ var require_cloud_artifact = __commonJS({
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.CloudArtifact = void 0;
-    var fs57 = require("fs");
+    var fs58 = require("fs");
     var path54 = require("path");
     var cxschema12 = require_lib2();
     var metadata_1 = require_metadata();
@@ -278199,7 +278230,7 @@ var require_cloud_artifact = __commonJS({
       static readMetadata(assemblyDirectory, x) {
         const ret = {};
         if (x.additionalMetadataFile) {
-          Object.assign(ret, JSON.parse(fs57.readFileSync(path54.join(assemblyDirectory, x.additionalMetadataFile), "utf-8")));
+          Object.assign(ret, JSON.parse(fs58.readFileSync(path54.join(assemblyDirectory, x.additionalMetadataFile), "utf-8")));
         }
         for (const [p3, entries] of Object.entries(x.metadata ?? {})) {
           if (ret[p3]) {
@@ -278308,7 +278339,7 @@ var require_asset_manifest_artifact = __commonJS({
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.AssetManifestArtifact = void 0;
-    var fs57 = require("fs");
+    var fs58 = require("fs");
     var path54 = require("path");
     var cloud_artifact_1 = require_cloud_artifact();
     var error_1 = require_error2();
@@ -278354,7 +278385,7 @@ var require_asset_manifest_artifact = __commonJS({
         if (this._contents !== void 0) {
           return this._contents;
         }
-        const contents = this._contents = JSON.parse(fs57.readFileSync(this.file, "utf-8"));
+        const contents = this._contents = JSON.parse(fs58.readFileSync(this.file, "utf-8"));
         return contents;
       }
     };
@@ -278415,7 +278446,7 @@ var require_cloudformation_artifact = __commonJS({
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.CloudFormationStackArtifact = void 0;
-    var fs57 = require("fs");
+    var fs58 = require("fs");
     var path54 = require("path");
     var cxschema12 = require_lib2();
     var cloud_artifact_1 = require_cloud_artifact();
@@ -278487,7 +278518,7 @@ var require_cloudformation_artifact = __commonJS({
        */
       get template() {
         if (this._template === void 0) {
-          this._template = JSON.parse(fs57.readFileSync(this.templateFullPath, "utf-8"));
+          this._template = JSON.parse(fs58.readFileSync(this.templateFullPath, "utf-8"));
         }
         return this._template;
       }
@@ -278672,8 +278703,8 @@ var require_cloud_assembly = __commonJS({
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.CloudAssemblyBuilder = exports2.CloudAssembly = void 0;
-    var fs57 = require("fs");
-    var os14 = require("os");
+    var fs58 = require("fs");
+    var os15 = require("os");
     var path54 = require("path");
     var cxschema12 = require_lib2();
     var cloudformation_artifact_1 = require_cloudformation_artifact();
@@ -278738,7 +278769,7 @@ var require_cloud_assembly = __commonJS({
        */
       static cleanupTemporaryDirectories() {
         for (const dir of TEMPORARY_ASSEMBLY_DIRS2) {
-          fs57.rmSync(dir, { recursive: true, force: true });
+          fs58.rmSync(dir, { recursive: true, force: true });
         }
         TEMPORARY_ASSEMBLY_DIRS2.splice(0, TEMPORARY_ASSEMBLY_DIRS2.length);
       }
@@ -278953,7 +278984,7 @@ var require_cloud_assembly = __commonJS({
         manifest = filterUndefined2(manifest);
         const manifestFilePath = path54.join(this.outdir, MANIFEST_FILE4);
         cxschema12.Manifest.saveAssemblyManifest(manifest, manifestFilePath);
-        fs57.writeFileSync(path54.join(this.outdir, "cdk.out"), JSON.stringify({ version: manifest.version }));
+        fs58.writeFileSync(path54.join(this.outdir, "cdk.out"), JSON.stringify({ version: manifest.version }));
         return new CloudAssembly8(this.outdir);
       }
       /**
@@ -278979,7 +279010,7 @@ var require_cloud_assembly = __commonJS({
        * Delete the cloud assembly directory
        */
       delete() {
-        fs57.rmSync(this.outdir, { recursive: true, force: true });
+        fs58.rmSync(this.outdir, { recursive: true, force: true });
       }
     };
     exports2.CloudAssemblyBuilder = CloudAssemblyBuilder3;
@@ -279008,18 +279039,18 @@ var require_cloud_assembly = __commonJS({
       if (outdir) {
         return outdir;
       }
-      const tmpDir = fs57.mkdtempSync(path54.join(fs57.realpathSync(os14.tmpdir()), "cdk.out"));
+      const tmpDir = fs58.mkdtempSync(path54.join(fs58.realpathSync(os15.tmpdir()), "cdk.out"));
       TEMPORARY_ASSEMBLY_DIRS2.push(tmpDir);
       return outdir ?? tmpDir;
     }
     __name(determineOutputDirectory2, "determineOutputDirectory");
     function ensureDirSync2(dir) {
-      if (fs57.existsSync(dir)) {
-        if (!fs57.statSync(dir).isDirectory()) {
+      if (fs58.existsSync(dir)) {
+        if (!fs58.statSync(dir).isDirectory()) {
           throw new error_1.CloudAssemblyError(`${dir} must be a directory`);
         }
       } else {
-        fs57.mkdirSync(dir, { recursive: true });
+        fs58.mkdirSync(dir, { recursive: true });
       }
     }
     __name(ensureDirSync2, "ensureDirSync");
@@ -281273,7 +281304,13 @@ function synthParametersFromSettings(settings) {
   return {
     context: contextFromSettings(settings),
     env: {
-      ...settings.get(["debugApp"]) ? debugEnvVars : {}
+      ...settings.get(["debugApp"]) ? debugEnvVars : {},
+      // When validation is disabled (e.g. via the CLI's `--no-validation`), forward
+      // it to the app process as an environment variable so framework-side validation
+      // layers can honor it. This is read in framework code that has no access to a
+      // construct tree, which is why it is an environment variable rather than context.
+      // Only an explicit `false` disables it, so a missing setting fails safe (validation on).
+      ...settings.get(["validation"]) === false ? { CDK_VALIDATION: "false" } : {}
     }
   };
 }
@@ -281426,6 +281463,7 @@ function settingsFromSynthOptions(synthOpts = {}) {
     versionReporting: true,
     assetMetadata: true,
     assetStaging: true,
+    validation: true,
     ...synthOpts
   }, true);
 }
@@ -283569,7 +283607,7 @@ function ensureNonEmptyResources(template) {
     };
   }
 }
-function parseAndValidateConstructPaths(paths) {
+function resolveStackAndConstructPaths(paths, availableStackIds) {
   if (paths.length === 0) {
     throw new ToolkitError("MissingConstructPath", "At least one construct path is required (e.g. cdk orphan MyStack/MyTable)");
   }
@@ -283577,25 +283615,31 @@ function parseAndValidateConstructPaths(paths) {
   let stackId;
   for (const raw of paths) {
     const p3 = raw.replace(/^\//, "");
-    const slashIdx = p3.indexOf("/");
-    if (slashIdx < 0) {
-      throw new ToolkitError("InvalidConstructPath", `Construct path '${raw}' must include both a stack name and a construct path separated by '/' (e.g. MyStack/MyTable)`);
+    const matchedStack = availableStackIds.filter((id) => p3 === id || p3.startsWith(`${id}/`)).sort((a6, b6) => b6.length - a6.length)[0];
+    if (!matchedStack) {
+      throw new ToolkitError(
+        "StackNotFound",
+        `No stack found for construct path '${raw}'. Available stacks: ${availableStackIds.join(", ")}`
+      );
     }
-    const thisStack = p3.substring(0, slashIdx);
-    const constructPath = p3.substring(slashIdx + 1);
-    if (stackId && thisStack !== stackId) {
-      throw new ToolkitError("MultipleStacks", `All construct paths must reference the same stack, but got '${stackId}' and '${thisStack}'`);
+    const constructPath = p3.substring(matchedStack.length + 1);
+    if (constructPath === "") {
+      throw new ToolkitError(
+        "InvalidConstructPath",
+        `Construct path '${raw}' must include a construct path within the stack (e.g. ${matchedStack}/MyTable)`
+      );
+    }
+    if (stackId && matchedStack !== stackId) {
+      throw new ToolkitError("MultipleStacks", `All construct paths must reference the same stack, but got '${stackId}' and '${matchedStack}'`);
     }
-    stackId = thisStack;
+    stackId = matchedStack;
     constructPaths.push(constructPath);
   }
   return { stackId, constructPaths };
 }
-var import_cloud_assembly_api13;
 var init_helpers2 = __esm({
   "../@aws-cdk/toolkit-lib/lib/api/orphan/private/helpers.ts"() {
     "use strict";
-    import_cloud_assembly_api13 = __toESM(require_lib3());
     init_toolkit_error();
     __name(walkObject, "walkObject");
     __name(replaceInObject, "replaceInObject");
@@ -283603,7 +283647,7 @@ var init_helpers2 = __esm({
     __name(removeDependsOn, "removeDependsOn");
     __name(assertDeploySucceeded, "assertDeploySucceeded");
     __name(ensureNonEmptyResources, "ensureNonEmptyResources");
-    __name(parseAndValidateConstructPaths, "parseAndValidateConstructPaths");
+    __name(resolveStackAndConstructPaths, "resolveStackAndConstructPaths");
   }
 });
 
@@ -287033,8 +287077,8 @@ var init_esm2 = __esm({
         }
         return this._userIgnored(path54, stats);
       }
-      _isntIgnored(path54, stat8) {
-        return !this._isIgnored(path54, stat8);
+      _isntIgnored(path54, stat9) {
+        return !this._isIgnored(path54, stat9);
       }
       /**
        * Provides a set of common helpers and properties relating to symlink handling.
@@ -288803,7 +288847,7 @@ async function replaceAwsPlaceholders2(object, aws) {
     account = /* @__PURE__ */ __name(() => Promise.resolve(a6), "account");
     return a6;
   }, "account");
-  return import_cloud_assembly_api14.EnvironmentPlaceholders.replaceAsync(object, {
+  return import_cloud_assembly_api13.EnvironmentPlaceholders.replaceAsync(object, {
     async region() {
       return object.region ?? aws.discoverDefaultRegion();
     },
@@ -288815,12 +288859,12 @@ async function replaceAwsPlaceholders2(object, aws) {
     }
   });
 }
-var import_cdk_assets_lib5, import_cloud_assembly_api14, RefactoringContext;
+var import_cdk_assets_lib5, import_cloud_assembly_api13, RefactoringContext;
 var init_context3 = __esm({
   "../@aws-cdk/toolkit-lib/lib/api/refactoring/context.ts"() {
     "use strict";
     import_cdk_assets_lib5 = __toESM(require_lib5());
-    import_cloud_assembly_api14 = __toESM(require_lib3());
+    import_cloud_assembly_api13 = __toESM(require_lib3());
     init_cloudformation4();
     init_digest();
     init_toolkit_error();
@@ -289218,8 +289262,8 @@ function countAssemblyResults(span, assembly) {
   const stacksRecursively = assembly.stacksRecursively;
   span.incCounter("stacks", stacksRecursively.length);
   span.incCounter("assemblies", asmCount(assembly));
-  span.incCounter("errorAnns", sum3(stacksRecursively.map((s) => s.messages.filter((m4) => m4.level === import_cloud_assembly_api15.SynthesisMessageLevel.ERROR).length)));
-  span.incCounter("warnings", sum3(stacksRecursively.map((s) => s.messages.filter((m4) => m4.level === import_cloud_assembly_api15.SynthesisMessageLevel.WARNING).length)));
+  span.incCounter("errorAnns", sum3(stacksRecursively.map((s) => s.messages.filter((m4) => m4.level === import_cloud_assembly_api14.SynthesisMessageLevel.ERROR).length)));
+  span.incCounter("warnings", sum3(stacksRecursively.map((s) => s.messages.filter((m4) => m4.level === import_cloud_assembly_api14.SynthesisMessageLevel.WARNING).length)));
   const annotationErrorCodes = stacksRecursively.flatMap((s) => Object.values(s.metadata).flatMap((ms) => ms.filter((m4) => m4.type === ANNOTATION_ERROR_CODE_TYPE)));
   for (const annotationErrorCode of annotationErrorCodes) {
     span.incCounter(`errorAnn:${annotationErrorCode.data}`);
@@ -289232,11 +289276,11 @@ function countAssemblyResults(span, assembly) {
 function sum3(xs) {
   return xs.reduce((a6, b6) => a6 + b6, 0);
 }
-var import_cloud_assembly_api15, ANNOTATION_ERROR_CODE_TYPE;
+var import_cloud_assembly_api14, ANNOTATION_ERROR_CODE_TYPE;
 var init_count_assembly_results = __esm({
   "../@aws-cdk/toolkit-lib/lib/toolkit/private/count-assembly-results.ts"() {
     "use strict";
-    import_cloud_assembly_api15 = __toESM(require_lib3());
+    import_cloud_assembly_api14 = __toESM(require_lib3());
     __name(countAssemblyResults, "countAssemblyResults");
     __name(sum3, "sum");
     ANNOTATION_ERROR_CODE_TYPE = "aws:cdk:error-code";
@@ -289778,6 +289822,7 @@ function formatValidationReports(fileRoot, reports) {
   });
   return [
     ...pluginFailures.map(formatPluginFailure),
+    ...successfullyExecutedPlugins.flatMap((r6) => r6.preamble ? [`${import_chalk26.default.underline(sanitize(r6.pluginName))}: ${sanitize(r6.preamble)}`] : []),
     ...violations.map((v) => formatViolationBlock(fileRoot, v))
   ];
 }
@@ -289854,7 +289899,7 @@ function formatConstructInfo(fileRoot, construct) {
   const logicalId = sanitize(construct.cloudFormationResource?.logicalId);
   if (construct.constructPath) {
     const cPath = sanitize(construct.constructPath);
-    parts.push(logicalId ? `${import_chalk26.default.bold(cPath)} (${logicalId})` : import_chalk26.default.bold(cPath));
+    parts.push(logicalId ? `${cPath} (${logicalId})` : cPath);
   } else {
     if (construct.cloudFormationResource?.templatePath) {
       parts.push(humanFriendlyFilename(fileRoot, sanitize(construct.cloudFormationResource.templatePath)));
@@ -291217,16 +291262,13 @@ ${deployResult.stackArn}`));
         try {
           this.requireUnstableFeature("orphan");
           const ioHelper = asIoHelper(this.ioHost, "orphan");
-          const parsed = parseAndValidateConstructPaths(options.constructPaths);
           const assembly = __using(_stack, await synthAndMeasure(ioHelper, cx, ALL_STACKS), true);
           const allStacks = await assembly.selectStacksV2(ALL_STACKS);
+          const parsed = resolveStackAndConstructPaths(
+            options.constructPaths,
+            allStacks.stackArtifacts.map((s) => s.hierarchicalId)
+          );
           const stack = allStacks.stackArtifacts.find((s) => s.hierarchicalId === parsed.stackId);
-          if (!stack) {
-            throw new ToolkitError(
-              "StackNotFound",
-              `No stack found with construct ID '${parsed.stackId}'. Available stacks: ${allStacks.stackArtifacts.map((s) => s.hierarchicalId).join(", ")}`
-            );
-          }
           const deployments = await this.deploymentsForAction("orphan");
           const orphaner = new ResourceOrphaner({
             deployments,
@@ -292583,12 +292625,12 @@ var init_installation_id = __esm({
 async function getLibraryVersion(ioHelper) {
   try {
     const command6 = `node -e 'process.stdout.write(require.resolve("aws-cdk-lib"))'`;
-    const { stdout } = await (0, import_util69.promisify)(import_child_process.exec)(command6);
-    if (!fs38.existsSync(stdout)) {
+    const { stdout: stdout2 } = await (0, import_util69.promisify)(import_child_process.exec)(command6);
+    if (!fs38.existsSync(stdout2)) {
       await ioHelper.defaults.trace('Could not get CDK Library Version: require.resolve("aws-cdk-lib") did not return a file path');
       return;
     }
-    const pathToPackageJson = path37.join(path37.dirname(stdout), "package.json");
+    const pathToPackageJson = path37.join(path37.dirname(stdout2), "package.json");
     const packageJson = fs38.readJSONSync(pathToPackageJson);
     if (!packageJson.version) {
       await ioHelper.defaults.trace("Could not get CDK Library Version: package.json does not have version field");
@@ -293881,7 +293923,14 @@ var require_cli_type_registry = __commonJS({
           description: "Check your set-up for potential problems"
         },
         lsp: {
-          description: "Start the CDK Language Server (LSP) over stdio for editor and AI-agent integration"
+          description: "Start the CDK Language Server (LSP) over stdio for editor and AI-agent integration",
+          options: {
+            features: {
+              type: "boolean",
+              default: false,
+              desc: "Print the LSP feature manifest as JSON and exit instead of starting the server. Lets a client probe LSP presence and capabilities without opening a session."
+            }
+          }
         },
         orphan: {
           arg: {
@@ -294221,11 +294270,38 @@ function isValidWrapperUserAgent(value2) {
   if (!VALID_USER_AGENTS.includes(name)) return false;
   return mode === "sandbox" || mode === "production";
 }
-var import_node_crypto16, import_toolkit_lib3, ABORTED_ERROR_MESSAGE, VALID_USER_AGENTS, TelemetrySession;
+async function tryDetectAmznPackage() {
+  try {
+    await fs41.stat(pathlib.join(os11.homedir(), ".midway"));
+  } catch {
+    return;
+  }
+  try {
+    const configFile = await fs41.readFile("Config", "utf-8");
+    const m4 = configFile.match(/^package\.(\S+)\s*=/m);
+    if (m4) {
+      return m4[1];
+    }
+  } catch {
+  }
+  try {
+    const ionFile = await fs41.readFile("brazil.ion", "utf-8");
+    const m4 = ionFile.match(/(^|\s)name:\s*"([^"]+)"/m);
+    if (m4) {
+      return m4[2];
+    }
+  } catch {
+  }
+  return void 0;
+}
+var import_node_crypto16, fs41, os11, pathlib, import_toolkit_lib3, ABORTED_ERROR_MESSAGE, VALID_USER_AGENTS, TelemetrySession;
 var init_session = __esm({
   "lib/cli/telemetry/session.ts"() {
     "use strict";
     import_node_crypto16 = require("node:crypto");
+    fs41 = __toESM(require("node:fs/promises"));
+    os11 = __toESM(require("os"));
+    pathlib = __toESM(require("path"));
     import_toolkit_lib3 = __toESM(require_lib12());
     init_installation_id();
     init_library_version();
@@ -294274,7 +294350,8 @@ var init_session = __esm({
             sessionId: (0, import_node_crypto16.randomUUID)(),
             telemetryVersion: "2.0",
             cdkCliVersion: versionNumber2(),
-            cdkLibraryVersion: await getLibraryVersion(this.ioHost.asIoHelper())
+            cdkLibraryVersion: await getLibraryVersion(this.ioHost.asIoHelper()),
+            amznPackage: await tryDetectAmznPackage()
           },
           event: {
             command: {
@@ -294448,6 +294525,7 @@ var init_session = __esm({
     __name(isAbortedError, "isAbortedError");
     __name(mutable, "mutable");
     __name(isValidWrapperUserAgent, "isValidWrapperUserAgent");
+    __name(tryDetectAmznPackage, "tryDetectAmznPackage");
   }
 });
 
@@ -294560,12 +294638,12 @@ var init_endpoint_sink = __esm({
 });
 
 // lib/cli/telemetry/sink/file-sink.ts
-var import_toolkit_lib5, fs41, FileTelemetrySink;
+var import_toolkit_lib5, fs42, FileTelemetrySink;
 var init_file_sink = __esm({
   "lib/cli/telemetry/sink/file-sink.ts"() {
     "use strict";
     import_toolkit_lib5 = __toESM(require_lib12());
-    fs41 = __toESM(require_lib4());
+    fs42 = __toESM(require_lib4());
     init_api_private();
     FileTelemetrySink = class {
       static {
@@ -294579,20 +294657,20 @@ var init_file_sink = __esm({
       constructor(props) {
         this.ioHelper = IoHelper.fromActionAwareIoHost(props.ioHost);
         this.logFilePath = props.logFilePath;
-        if (fs41.existsSync(this.logFilePath)) {
+        if (fs42.existsSync(this.logFilePath)) {
           throw new import_toolkit_lib5.ToolkitError("TelemetryFileExists", `Telemetry file already exists at ${this.logFilePath}`);
         }
-        fs41.ensureFileSync(this.logFilePath);
-        fs41.writeJsonSync(this.logFilePath, []);
+        fs42.ensureFileSync(this.logFilePath);
+        fs42.writeJsonSync(this.logFilePath, []);
       }
       /**
        * Emit an event.
        */
       async emit(event) {
         try {
-          const json = fs41.readJsonSync(this.logFilePath);
+          const json = fs42.readJsonSync(this.logFilePath);
           json.push(event);
-          fs41.writeJSONSync(this.logFilePath, json, { spaces: 2 });
+          fs42.writeJSONSync(this.logFilePath, json, { spaces: 2 });
         } catch (e6) {
           await this.ioHelper.defaults.trace(`Failed to add telemetry event: ${e6.message}`);
         }
@@ -295282,7 +295360,12 @@ var init_cli_io_host = __esm({
        * Formats a message for console output with optional color support
        */
       formatMessage(msg) {
-        let message_text = this.isTTY ? styleMap2[msg.level](msg.message) : msg.message;
+        let message_text;
+        if (msg.code === "CDK_TOOLKIT_E9600") {
+          message_text = msg.message;
+        } else {
+          message_text = this.isTTY ? styleMap2[msg.level](msg.message) : msg.message;
+        }
         return (msg.level === "debug" || msg.level === "trace" ? `[${this.formatTime(msg.time)}] ${message_text}` : message_text) + "\n";
       }
       /**
@@ -295362,8 +295445,8 @@ async function loadAndLog(ioHelper, fileName) {
 async function settingsFromFile2(ioHelper, fileName) {
   let settings;
   const expanded = expandHomeDir2(fileName);
-  if (await fs42.pathExists(expanded)) {
-    const data2 = await fs42.readJson(expanded);
+  if (await fs43.pathExists(expanded)) {
+    const data2 = await fs43.readJson(expanded);
     settings = new Settings(data2);
   } else {
     settings = new Settings();
@@ -295405,7 +295488,7 @@ async function warnAboutContextKey(ioHelper, settings, prefix, fileName) {
 }
 function expandHomeDir2(x) {
   if (x.startsWith("~")) {
-    return fs_path2.join(os11.homedir(), x.slice(1));
+    return fs_path2.join(os12.homedir(), x.slice(1));
   }
   return x;
 }
@@ -295433,6 +295516,7 @@ async function commandLineArgumentsToSettings(ioHelper, argv) {
     language: argv.language,
     pathMetadata: argv.pathMetadata,
     assetMetadata: argv.assetMetadata,
+    validation: argv.validation,
     profile: argv.profile,
     region: argv.region,
     plugin: argv.plugin,
@@ -295527,14 +295611,14 @@ async function parseStringTagsListToObject(ioHelper, argTags) {
   }
   return tags.length > 0 ? tags : void 0;
 }
-var os11, fs_path2, import_toolkit_lib8, fs42, PROJECT_CONFIG, USER_DEFAULTS, CONTEXT_KEY, BUNDLING_COMMANDS, Configuration;
+var os12, fs_path2, import_toolkit_lib8, fs43, PROJECT_CONFIG, USER_DEFAULTS, CONTEXT_KEY, BUNDLING_COMMANDS, Configuration;
 var init_user_configuration = __esm({
   "lib/cli/user-configuration.ts"() {
     "use strict";
-    os11 = __toESM(require("os"));
+    os12 = __toESM(require("os"));
     fs_path2 = __toESM(require("path"));
     import_toolkit_lib8 = __toESM(require_lib12());
-    fs42 = __toESM(require_lib4());
+    fs43 = __toESM(require_lib4());
     init_context4();
     init_settings2();
     init_context4();
@@ -295916,15 +296000,15 @@ async function shell2(ioHelper, command6) {
     stdio: ["ignore", "pipe", "inherit"]
   });
   return new Promise((resolve16, reject) => {
-    const stdout = new Array();
+    const stdout2 = new Array();
     child.stdout.on("data", (chunk) => {
       process.stdout.write(chunk);
-      stdout.push(chunk);
+      stdout2.push(chunk);
     });
     child.once("error", reject);
     child.once("exit", (code) => {
       if (code === 0) {
-        resolve16(Buffer.from(stdout).toString("utf-8"));
+        resolve16(Buffer.from(stdout2).toString("utf-8"));
       } else {
         reject(new import_toolkit_lib9.ToolkitError("CommandFailed", `${commandLine} exited with error code ${code}`));
       }
@@ -296247,7 +296331,7 @@ async function loadLocalTemplate(fromPath, templatePath) {
     let actualTemplatePath = fromPath;
     if (templatePath) {
       actualTemplatePath = path42.join(fromPath, templatePath);
-      if (!await fs43.pathExists(actualTemplatePath)) {
+      if (!await fs44.pathExists(actualTemplatePath)) {
         throw new import_toolkit_lib11.ToolkitError("TemplatePathNotFound", `Template path does not exist: ${actualTemplatePath}`);
       }
     }
@@ -296300,7 +296384,7 @@ async function resolveLanguage(ioHelper, template, requestedLanguage, type) {
   })();
 }
 async function findPotentialTemplates(repositoryPath) {
-  const entries = await fs43.readdir(repositoryPath, { withFileTypes: true });
+  const entries = await fs44.readdir(repositoryPath, { withFileTypes: true });
   const templateValidationPromises = entries.filter((entry) => entry.isDirectory() && !entry.name.startsWith(".")).map(async (entry) => {
     try {
       const templatePath = path42.join(repositoryPath, entry.name);
@@ -296315,7 +296399,7 @@ async function findPotentialTemplates(repositoryPath) {
 }
 async function getLanguageDirectories(templatePath) {
   try {
-    const entries = await fs43.readdir(templatePath, { withFileTypes: true });
+    const entries = await fs44.readdir(templatePath, { withFileTypes: true });
     const languageValidationPromises = entries.filter((directoryEntry) => directoryEntry.isDirectory() && SUPPORTED_LANGUAGE_NAMES.includes(directoryEntry.name)).map(async (directoryEntry) => {
       const languageDirectoryPath = path42.join(templatePath, directoryEntry.name);
       try {
@@ -296339,7 +296423,7 @@ async function hasLanguageFiles(directoryPath, extensions) {
   while (dirsToCheck.length > 0) {
     const currentDir = dirsToCheck.pop();
     try {
-      const entries = await fs43.readdir(currentDir, { withFileTypes: true });
+      const entries = await fs44.readdir(currentDir, { withFileTypes: true });
       for (const entry of entries) {
         if (entry.isFile() && extensions.some((ext) => entry.name.endsWith(ext))) {
           return true;
@@ -296407,7 +296491,7 @@ async function availableInitTemplates() {
   }
 }
 async function listDirectory(dirPath) {
-  return (await fs43.readdir(dirPath)).filter((p3) => !p3.startsWith(".")).filter((p3) => !(p3 === "LICENSE")).filter((p3) => !(p3 === INFO_DOT_JSON)).sort();
+  return (await fs44.readdir(dirPath)).filter((p3) => !p3.startsWith(".")).filter((p3) => !(p3 === "LICENSE")).filter((p3) => !(p3 === INFO_DOT_JSON)).sort();
 }
 async function printAvailableTemplates(ioHelper, language) {
   await ioHelper.defaults.info("Available templates:");
@@ -296427,8 +296511,8 @@ async function initializeProject(ioHelper, template, language, canUseNetwork, ge
   if (migrate) {
     await template.addMigrateContext(workDir);
   }
-  if (await fs43.pathExists(`${workDir}/README.md`)) {
-    const readme = await fs43.readFile(`${workDir}/README.md`, { encoding: "utf-8" });
+  if (await fs44.pathExists(`${workDir}/README.md`)) {
+    const readme = await fs44.readFile(`${workDir}/README.md`, { encoding: "utf-8" });
     await ioHelper.defaults.info(import_chalk30.default.green(readme));
   }
   if (!generateOnly) {
@@ -296439,11 +296523,11 @@ async function initializeProject(ioHelper, template, language, canUseNetwork, ge
 }
 async function assertIsEmptyDirectory(workDir) {
   try {
-    const stats = await fs43.stat(workDir);
+    const stats = await fs44.stat(workDir);
     if (!stats.isDirectory()) {
       throw new import_toolkit_lib11.ToolkitError("PathNotDirectory", `Path exists but is not a directory: ${workDir}`);
     }
-    const files = await fs43.readdir(workDir);
+    const files = await fs44.readdir(workDir);
     const visibleFiles = files.filter((f6) => !f6.startsWith("."));
     if (visibleFiles.length > 0) {
       throw new import_toolkit_lib11.ToolkitError(
@@ -296512,8 +296596,8 @@ async function postInstallTypescript(ioHelper, canUseNetwork, cwd, packageManage
   }
 }
 async function postInstallJava(ioHelper, canUseNetwork, cwd) {
-  const hasGradleBuild = await fs43.pathExists(path42.join(cwd, "build.gradle"));
-  const hasMavenPom = await fs43.pathExists(path42.join(cwd, "pom.xml"));
+  const hasGradleBuild = await fs44.pathExists(path42.join(cwd, "build.gradle"));
+  const hasMavenPom = await fs44.pathExists(path42.join(cwd, "pom.xml"));
   if (hasGradleBuild) {
     const gradleWarning = "Please run './gradlew build'!";
     if (!canUseNetwork) {
@@ -296546,7 +296630,7 @@ async function postInstallJava(ioHelper, canUseNetwork, cwd) {
 }
 async function postInstallPython(ioHelper, cwd) {
   const python = pythonExecutable();
-  const hasRequirements = await fs43.pathExists(path42.join(cwd, "requirements.txt"));
+  const hasRequirements = await fs44.pathExists(path42.join(cwd, "requirements.txt"));
   if (hasRequirements) {
     await ioHelper.defaults.info(`Executing ${import_chalk30.default.green("Creating virtualenv...")}`);
     try {
@@ -296596,7 +296680,7 @@ async function postInstallFSharp(ioHelper, canUseNetwork, cwd) {
 }
 async function isInGitRepository(dir) {
   while (true) {
-    if (await fs43.pathExists(path42.join(dir, ".git"))) {
+    if (await fs44.pathExists(path42.join(dir, ".git"))) {
       return true;
     }
     if (isRoot(dir)) {
@@ -296614,25 +296698,25 @@ async function execute(ioHelper, cmd, args, { cwd }) {
     shell: true,
     stdio: ["ignore", "pipe", "inherit"]
   });
-  let stdout = "";
-  child.stdout.on("data", (chunk) => stdout += chunk.toString());
+  let stdout2 = "";
+  child.stdout.on("data", (chunk) => stdout2 += chunk.toString());
   return new Promise((ok, fail) => {
     child.once("error", (err) => fail(err));
     child.once("exit", (status) => {
       if (status === 0) {
-        return ok(stdout);
+        return ok(stdout2);
       } else {
         return fail(new import_toolkit_lib11.ToolkitError("CommandFailed", `${cmd} exited with status ${status}`));
       }
     });
   }).catch(async (err) => {
-    await ioHelper.defaults.error(stdout);
+    await ioHelper.defaults.error(stdout2);
     throw err;
   });
 }
 async function loadInitVersions() {
   const initVersionFile = path42.join(cliRootDir(), "lib", "init-templates", ".init-version.json");
-  const contents = JSON.parse(await fs43.readFile(initVersionFile, { encoding: "utf-8" }));
+  const contents = JSON.parse(await fs44.readFile(initVersionFile, { encoding: "utf-8" }));
   const ret = {
     "aws-cdk-lib": contents["aws-cdk-lib"],
     "constructs": contents.constructs,
@@ -296647,11 +296731,11 @@ async function loadInitVersions() {
 }
 async function currentlyRecommendedAwsCdkLibFlags() {
   const recommendedFlagsFile = path42.join(cliRootDir(), "lib", "init-templates", ".recommended-feature-flags.json");
-  const flags = JSON.parse(await fs43.readFile(recommendedFlagsFile, { encoding: "utf-8" }));
+  const flags = JSON.parse(await fs44.readFile(recommendedFlagsFile, { encoding: "utf-8" }));
   const sortedKeys = Object.keys(flags).sort();
   return Object.fromEntries(sortedKeys.map((k6) => [k6, flags[k6]]));
 }
-var childProcess, path42, import_toolkit_lib11, import_chalk30, fs43, camelCase, decamelize, SUPPORTED_LANGUAGE_NAMES, INFO_DOT_JSON, InitTemplate;
+var childProcess, path42, import_toolkit_lib11, import_chalk30, fs44, camelCase, decamelize, SUPPORTED_LANGUAGE_NAMES, INFO_DOT_JSON, InitTemplate;
 var init_init = __esm({
   "lib/commands/init/init.ts"() {
     "use strict";
@@ -296659,7 +296743,7 @@ var init_init = __esm({
     path42 = __toESM(require("path"));
     import_toolkit_lib11 = __toESM(require_lib12());
     import_chalk30 = __toESM(require_source());
-    fs43 = __toESM(require_lib4());
+    fs44 = __toESM(require_lib4());
     init_init_hooks();
     init_root_dir();
     init_version();
@@ -296701,12 +296785,12 @@ var init_init = __esm({
       static async fromName(templatesDir, name) {
         const basePath = path42.join(templatesDir, name);
         const languages = await listDirectory(basePath);
-        const initInfo = await fs43.readJson(path42.join(basePath, INFO_DOT_JSON));
+        const initInfo = await fs44.readJson(path42.join(basePath, INFO_DOT_JSON));
         return new _InitTemplate(basePath, name, languages, initInfo, "builtin" /* BUILT_IN */);
       }
       static async fromPath(templatePath) {
         const basePath = path42.resolve(templatePath);
-        if (!await fs43.pathExists(basePath)) {
+        if (!await fs44.pathExists(basePath)) {
           throw new import_toolkit_lib11.ToolkitError("TemplatePathNotFound", `Template path does not exist: ${basePath}`);
         }
         let templateSourcePath = basePath;
@@ -296778,8 +296862,8 @@ var init_init = __esm({
               substitutePlaceholdersIn: /* @__PURE__ */ __name(async (...fileNames) => {
                 const fileProcessingPromises = fileNames.map(async (fileName) => {
                   const fullPath = path42.join(targetDirectory, fileName);
-                  const template = await fs43.readFile(fullPath, { encoding: "utf-8" });
-                  await fs43.writeFile(fullPath, expandPlaceholders(template, language, projectInfo, packageManager));
+                  const template = await fs44.readFile(fullPath, { encoding: "utf-8" });
+                  await fs44.writeFile(fullPath, expandPlaceholders(template, language, projectInfo, packageManager));
                 });
                 await Promise.all(fileProcessingPromises);
               }, "substitutePlaceholdersIn"),
@@ -296789,11 +296873,11 @@ var init_init = __esm({
         }
       }
       async installFiles(sourceDirectory, targetDirectory, language, project, packageManager) {
-        for (const file of await fs43.readdir(sourceDirectory)) {
+        for (const file of await fs44.readdir(sourceDirectory)) {
           const fromFile = path42.join(sourceDirectory, file);
           const toFile = path42.join(targetDirectory, expandPlaceholders(file, language, project, packageManager));
-          if ((await fs43.stat(fromFile)).isDirectory()) {
-            await fs43.mkdir(toFile);
+          if ((await fs44.stat(fromFile)).isDirectory()) {
+            await fs44.mkdir(toFile);
             await this.installFiles(fromFile, toFile, language, project, packageManager);
             continue;
           } else if (file.match(/^.*\.template\.[^.]+$/)) {
@@ -296802,19 +296886,19 @@ var init_init = __esm({
           } else if (file.match(/^.*\.hook\.(d.)?[^.]+$/)) {
             continue;
           } else {
-            await fs43.copy(fromFile, toFile);
+            await fs44.copy(fromFile, toFile);
           }
         }
       }
       async installProcessed(templatePath, toFile, language, project, packageManager) {
-        const template = await fs43.readFile(templatePath, { encoding: "utf-8" });
-        await fs43.writeFile(toFile, expandPlaceholders(template, language, project, packageManager));
+        const template = await fs44.readFile(templatePath, { encoding: "utf-8" });
+        await fs44.writeFile(toFile, expandPlaceholders(template, language, project, packageManager));
       }
       /**
        * Copy template files without processing placeholders (for custom templates)
        */
       async installFilesWithoutProcessing(sourceDirectory, targetDirectory) {
-        await fs43.copy(sourceDirectory, targetDirectory, {
+        await fs44.copy(sourceDirectory, targetDirectory, {
           filter: /* @__PURE__ */ __name((src) => {
             const filename = path42.basename(src);
             return !filename.match(/^.*\.hook\.(d.)?[^.]+$/);
@@ -296827,27 +296911,27 @@ var init_init = __esm({
        */
       async applyFutureFlags(projectDir) {
         const cdkJson = path42.join(projectDir, "cdk.json");
-        if (!await fs43.pathExists(cdkJson)) {
+        if (!await fs44.pathExists(cdkJson)) {
           return;
         }
-        const config2 = await fs43.readJson(cdkJson);
+        const config2 = await fs44.readJson(cdkJson);
         config2.context = {
           ...config2.context,
           ...await currentlyRecommendedAwsCdkLibFlags()
         };
-        await fs43.writeJson(cdkJson, config2, { spaces: 2 });
+        await fs44.writeJson(cdkJson, config2, { spaces: 2 });
       }
       async addMigrateContext(projectDir) {
         const cdkJson = path42.join(projectDir, "cdk.json");
-        if (!await fs43.pathExists(cdkJson)) {
+        if (!await fs44.pathExists(cdkJson)) {
           return;
         }
-        const config2 = await fs43.readJson(cdkJson);
+        const config2 = await fs44.readJson(cdkJson);
         config2.context = {
           ...config2.context,
           "cdk-migrate": true
         };
-        await fs43.writeJson(cdkJson, config2, { spaces: 2 });
+        await fs44.writeJson(cdkJson, config2, { spaces: 2 });
       }
     };
     __name(expandPlaceholders, "expandPlaceholders");
@@ -296894,8 +296978,8 @@ async function generateCdkApp(ioHelper, stackName, stack, language, outputPath,
   const resolvedOutputPath = path43.join(outputPath ?? process.cwd(), stackName);
   const formattedStackName = decamelize2(stackName);
   try {
-    fs44.rmSync(resolvedOutputPath, { recursive: true, force: true });
-    fs44.mkdirSync(resolvedOutputPath, { recursive: true });
+    fs45.rmSync(resolvedOutputPath, { recursive: true, force: true });
+    fs45.mkdirSync(resolvedOutputPath, { recursive: true });
     const generateOnly = compress2;
     await cliInit({
       ioHelper,
@@ -296930,13 +297014,13 @@ async function generateCdkApp(ioHelper, stackName, stack, language, outputPath,
           `${language} is not supported by CDK Migrate. Please choose from: ${MIGRATE_SUPPORTED_LANGUAGES.join(", ")}`
         );
     }
-    fs44.writeFileSync(stackFileName, stack);
+    fs45.writeFileSync(stackFileName, stack);
     if (compress2) {
       await (0, import_zip.zipDirectory)(resolvedOutputPath, `${resolvedOutputPath}.zip`);
-      fs44.rmSync(resolvedOutputPath, { recursive: true, force: true });
+      fs45.rmSync(resolvedOutputPath, { recursive: true, force: true });
     }
   } catch (error3) {
-    fs44.rmSync(resolvedOutputPath, { recursive: true, force: true });
+    fs45.rmSync(resolvedOutputPath, { recursive: true, force: true });
     throw error3;
   }
 }
@@ -296949,16 +297033,16 @@ function generateStack(template, stackName, language) {
   }
 }
 function readFromPath(inputPath) {
-  let readFile11;
+  let readFile12;
   try {
-    readFile11 = fs44.readFileSync(inputPath, "utf8");
+    readFile12 = fs45.readFileSync(inputPath, "utf8");
   } catch (e6) {
     throw new import_toolkit_lib12.ToolkitError("InvalidPath", `'${inputPath}' is not a valid path.`);
   }
-  if (readFile11 == "") {
+  if (readFile12 == "") {
     throw new import_toolkit_lib12.ToolkitError("EmptyTemplateFile", `Cloudformation template filepath: '${inputPath}' is an empty file.`);
   }
-  return readFile11;
+  return readFile12;
 }
 async function readFromStack(stackName, sdkProvider, environment) {
   const cloudFormation = (await sdkProvider.forEnvironment(environment, 0 /* ForReading */)).sdk.cloudFormation();
@@ -297073,8 +297157,8 @@ function chunks(list2, chunkSize) {
 }
 function setEnvironment(account, region) {
   return {
-    account: account ?? import_cloud_assembly_api16.UNKNOWN_ACCOUNT,
-    region: region ?? import_cloud_assembly_api16.UNKNOWN_REGION,
+    account: account ?? import_cloud_assembly_api15.UNKNOWN_ACCOUNT,
+    region: region ?? import_cloud_assembly_api15.UNKNOWN_REGION,
     name: "cdk-migrate-env"
   };
 }
@@ -297169,7 +297253,7 @@ function writeMigrateJsonFile(outputPath, stackName, migrateJson) {
     "Source": migrateJson.source,
     "Resources": migrateJson.resources
   };
-  fs44.writeFileSync(
+  fs45.writeFileSync(
     `${path43.join(outputPath ?? process.cwd(), stackName)}/migrate.json`,
     JSON.stringify(outputToJson, null, 2)
   );
@@ -297222,7 +297306,7 @@ async function buildCfnClient(sdkProvider, environment) {
   return sdk.cloudFormation();
 }
 function appendWarningsToReadme(filepath, resources) {
-  const readme = fs44.readFileSync(filepath, "utf8");
+  const readme = fs45.readFileSync(filepath, "utf8");
   const lines = readme.split("\n");
   const index = lines.findIndex((line) => line.trim() === "Enjoy!");
   let linesToAdd = ["\n## Warnings"];
@@ -297246,7 +297330,7 @@ function appendWarningsToReadme(filepath, resources) {
     }
   }
   lines.splice(index, 0, ...linesToAdd);
-  fs44.writeFileSync(filepath, lines.join("\n"));
+  fs45.writeFileSync(filepath, lines.join("\n"));
 }
 function deduplicateResources(resources) {
   let uniqueResources = {};
@@ -297257,13 +297341,13 @@ function deduplicateResources(resources) {
   }
   return Object.values(uniqueResources);
 }
-var fs44, path43, import_cloud_assembly_api16, import_zip, import_toolkit_lib12, cdk_from_cfn, import_chalk31, camelCase2, decamelize2, MIGRATE_SUPPORTED_LANGUAGES, FilterType, CfnTemplateGeneratorProvider;
+var fs45, path43, import_cloud_assembly_api15, import_zip, import_toolkit_lib12, cdk_from_cfn, import_chalk31, camelCase2, decamelize2, MIGRATE_SUPPORTED_LANGUAGES, FilterType, CfnTemplateGeneratorProvider;
 var init_migrate = __esm({
   "lib/commands/migrate.ts"() {
     "use strict";
-    fs44 = __toESM(require("fs"));
+    fs45 = __toESM(require("fs"));
     path43 = __toESM(require("path"));
-    import_cloud_assembly_api16 = __toESM(require_lib3());
+    import_cloud_assembly_api15 = __toESM(require_lib3());
     import_zip = __toESM(require_zip());
     import_toolkit_lib12 = __toESM(require_lib12());
     cdk_from_cfn = __toESM(require_cdk_from_cfn());
@@ -297782,7 +297866,7 @@ var init_environments = __esm({
 // lib/cli/util/fs-util.ts
 async function tryReadJson(fileName) {
   try {
-    return JSON.parse(await fs45.readFile(fileName, "utf-8"));
+    return JSON.parse(await fs46.readFile(fileName, "utf-8"));
   } catch (e6) {
     if (e6.code === "ENOENT") {
       return void 0;
@@ -297790,11 +297874,11 @@ async function tryReadJson(fileName) {
     throw e6;
   }
 }
-var fs45;
+var fs46;
 var init_fs_util = __esm({
   "lib/cli/util/fs-util.ts"() {
     "use strict";
-    fs45 = __toESM(require("fs/promises"));
+    fs46 = __toESM(require("fs/promises"));
     __name(tryReadJson, "tryReadJson");
   }
 });
@@ -297826,7 +297910,7 @@ async function execProgram(aws, ioHelper, config2) {
   if (!app) {
     throw new import_toolkit_lib16.ToolkitError("AppRequired", `--app is required either in command-line, in ${PROJECT_CONFIG} or in ${USER_DEFAULTS}`);
   }
-  if (await fs46.pathExists(app) && (await fs46.stat(app)).isDirectory()) {
+  if (await fs47.pathExists(app) && (await fs47.stat(app)).isDirectory()) {
     await debugFn("--app points to a cloud assembly, so we bypass synth");
     const lock = await new RWLock(app).acquireRead();
     return { assembly: createAssembly(app), lock };
@@ -297843,7 +297927,7 @@ async function execProgram(aws, ioHelper, config2) {
     throw new import_toolkit_lib16.ToolkitError("OutputNotString", `--output takes a string, got ${JSON.stringify(outdir)}`);
   }
   try {
-    await fs46.mkdirp(outdir);
+    await fs47.mkdirp(outdir);
   } catch (error3) {
     throw new import_toolkit_lib16.ToolkitError("OutputDirCreateFailed", `Could not create output directory ${outdir} (${error3.message})`);
   }
@@ -297853,10 +297937,10 @@ async function execProgram(aws, ioHelper, config2) {
   env3[cxapi11.CLI_VERSION_ENV] = versionNumber2();
   const writerLock = await new RWLock(outdir).acquireWrite();
   errorFile = path44.join(outdir, "error.txt");
-  await fs46.promises.rm(errorFile, { force: true });
+  await fs47.promises.rm(errorFile, { force: true });
   env3.CDK_ERROR_FILE = errorFile;
   const perfCountersFile = path44.join(outdir, "performance-counters.json");
-  await fs46.promises.rm(perfCountersFile, { force: true });
+  await fs47.promises.rm(perfCountersFile, { force: true });
   env3.CDK_PERF_COUNTERS_FILE = perfCountersFile;
   await debugFn((0, import_util75.format)("env:", env3));
   const cleanupTemp = writeContextToEnv(env3, context, "add-process-env-later");
@@ -297896,7 +297980,7 @@ async function execProgram(aws, ioHelper, config2) {
 }
 function createAssembly(appDir) {
   try {
-    return new import_cloud_assembly_api17.CloudAssembly(appDir, {
+    return new import_cloud_assembly_api16.CloudAssembly(appDir, {
       // We sort as we deploy
       topoSort: false
     });
@@ -297911,17 +297995,17 @@ function createAssembly(appDir) {
 function noUndefined2(xs) {
   return Object.fromEntries(Object.entries(xs).filter(([_, v]) => v !== void 0));
 }
-var path44, import_util75, import_cloud_assembly_api17, cxschema11, cxapi11, import_toolkit_lib16, fs46;
+var path44, import_util75, import_cloud_assembly_api16, cxschema11, cxapi11, import_toolkit_lib16, fs47;
 var init_exec2 = __esm({
   "lib/cxapp/exec.ts"() {
     "use strict";
     path44 = __toESM(require("path"));
     import_util75 = require("util");
-    import_cloud_assembly_api17 = __toESM(require_lib3());
+    import_cloud_assembly_api16 = __toESM(require_lib3());
     cxschema11 = __toESM(require_lib2());
     cxapi11 = __toESM(require_lib11());
     import_toolkit_lib16 = __toESM(require_lib12());
-    fs46 = __toESM(require_lib4());
+    fs47 = __toESM(require_lib4());
     init_api();
     init_user_configuration();
     init_fs_util();
@@ -298546,16 +298630,16 @@ function effectiveValue(flag) {
 function defaultValue(flag) {
   return flag.unconfiguredBehavesLike?.v2 ?? false;
 }
-var os12, path45, import_cloudformation_diff4, import_toolkit_lib17, import_chalk32, fs47, import_p_queue, FlagOperations;
+var os13, path45, import_cloudformation_diff4, import_toolkit_lib17, import_chalk32, fs48, import_p_queue, FlagOperations;
 var init_operations = __esm({
   "lib/commands/flags/operations.ts"() {
     "use strict";
-    os12 = __toESM(require("os"));
+    os13 = __toESM(require("os"));
     path45 = __toESM(require("path"));
     import_cloudformation_diff4 = __toESM(require_lib9());
     import_toolkit_lib17 = __toESM(require_lib12());
     import_chalk32 = __toESM(require_source());
-    fs47 = __toESM(require_lib4());
+    fs48 = __toESM(require_lib4());
     import_p_queue = __toESM(require_dist3());
     init_obsolete_flags();
     init_api();
@@ -298656,7 +298740,7 @@ var init_operations = __esm({
       }
       /** Sets flags that don't cause template changes */
       async setSafeFlags(params) {
-        const cdkJson = await JSON.parse(await fs47.readFile(path45.join(process.cwd(), "cdk.json"), "utf-8"));
+        const cdkJson = await JSON.parse(await fs48.readFile(path45.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")) {
@@ -298684,7 +298768,7 @@ var init_operations = __esm({
       async initializeSafetyCheck() {
         const baseContext = new import_toolkit_lib17.CdkAppMultiContext(process.cwd());
         this.baseContextValues = { ...await baseContext.read(), ...this.cliContextValues };
-        this.baselineTempDir = fs47.mkdtempSync(path45.join(os12.tmpdir(), "cdk-baseline-"));
+        this.baselineTempDir = fs48.mkdtempSync(path45.join(os13.tmpdir(), "cdk-baseline-"));
         const mergedContext = new import_toolkit_lib17.MemoryContext(this.baseContextValues);
         const baseSource = await this.toolkit.fromCdkApp(this.app, {
           contextStore: mergedContext,
@@ -298698,7 +298782,7 @@ var init_operations = __esm({
       /** Cleans up temporary directories created during safety checks */
       async cleanupSafetyCheck() {
         if (this.baselineTempDir) {
-          await fs47.remove(this.baselineTempDir);
+          await fs48.remove(this.baselineTempDir);
           this.baselineTempDir = void 0;
         }
       }
@@ -298716,7 +298800,7 @@ var init_operations = __esm({
       /** Tests if a set of context values causes template changes by synthesizing and diffing */
       async testBatch(contextValues) {
         const testContext = new import_toolkit_lib17.MemoryContext(contextValues);
-        const tempDir = fs47.mkdtempSync(path45.join(os12.tmpdir(), "cdk-test-"));
+        const tempDir = fs48.mkdtempSync(path45.join(os13.tmpdir(), "cdk-test-"));
         const testSource = await this.toolkit.fromCdkApp(this.app, {
           contextStore: testContext,
           outdir: tempDir
@@ -298740,7 +298824,7 @@ var init_operations = __esm({
           }
           return true;
         } finally {
-          await fs47.remove(tempDir);
+          await fs48.remove(tempDir);
         }
       }
       /** Uses binary search to isolate which flags are safe to set without template changes */
@@ -298778,11 +298862,11 @@ var init_operations = __esm({
         const baseContext = new import_toolkit_lib17.CdkAppMultiContext(process.cwd());
         const baseContextValues = { ...await baseContext.read(), ...this.cliContextValues };
         const memoryContext = new import_toolkit_lib17.MemoryContext(baseContextValues);
-        const cdkJson = await JSON.parse(await fs47.readFile(path45.join(process.cwd(), "cdk.json"), "utf-8"));
+        const cdkJson = await JSON.parse(await fs48.readFile(path45.join(process.cwd(), "cdk.json"), "utf-8"));
         const app = cdkJson.app;
         const source = await this.toolkit.fromCdkApp(app, {
           contextStore: memoryContext,
-          outdir: fs47.mkdtempSync(path45.join(os12.tmpdir(), "cdk-original-"))
+          outdir: fs48.mkdtempSync(path45.join(os13.tmpdir(), "cdk-original-"))
         });
         const updateObj = await this.buildUpdateObject(flagNames, params, baseContextValues);
         if (!updateObj) return false;
@@ -298791,7 +298875,7 @@ var init_operations = __esm({
         const assembly = cx.cloudAssembly;
         const modifiedSource = await this.toolkit.fromCdkApp(app, {
           contextStore: memoryContext,
-          outdir: fs47.mkdtempSync(path45.join(os12.tmpdir(), "cdk-temp-"))
+          outdir: fs48.mkdtempSync(path45.join(os13.tmpdir(), "cdk-temp-"))
         });
         const modifiedCx = await this.toolkit.synth(modifiedSource);
         const allStacks = assembly.stacksRecursively;
@@ -298866,13 +298950,13 @@ var init_operations = __esm({
       async cleanupTempDirectories() {
         const originalDir = path45.join(process.cwd(), "original");
         const tempDir = path45.join(process.cwd(), "temp");
-        await fs47.remove(originalDir);
-        await fs47.remove(tempDir);
+        await fs48.remove(originalDir);
+        await fs48.remove(tempDir);
       }
       /** Actually modifies the cdk.json file with the new flag values */
       async modifyValues(flagNames, params) {
         const cdkJsonPath = path45.join(process.cwd(), "cdk.json");
-        const cdkJsonContent = await fs47.readFile(cdkJsonPath, "utf-8");
+        const cdkJsonContent = await fs48.readFile(cdkJsonPath, "utf-8");
         const cdkJson = JSON.parse(cdkJsonContent);
         if (flagNames.length === 1 && !params.safe && !params.all) {
           const boolValue = params.value === "true";
@@ -298885,7 +298969,7 @@ var init_operations = __esm({
             cdkJson.context[flagName] = newValue;
           }
         }
-        await fs47.writeFile(cdkJsonPath, JSON.stringify(cdkJson, null, 2), "utf-8");
+        await fs48.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) {
@@ -299024,7 +299108,7 @@ async function displayFlagsMessage(ioHost, toolkit, cloudExecutable) {
 function requiresApproval(requireApproval, permissionChangeType) {
   return requireApproval === import_cloud_assembly_schema9.RequireApproval.ANYCHANGE || requireApproval === import_cloud_assembly_schema9.RequireApproval.BROADENING && permissionChangeType === import_toolkit_lib18.PermissionChangeType.BROADENING;
 }
-var import_node_crypto17, path46, import_node_util8, cxapi12, import_cloud_assembly_schema9, import_toolkit_lib18, import_chalk33, fs48, pLimit5, FILE_EVENTS2, InternalToolkit, CdkToolkit, WorkGraphDeploymentActions;
+var import_node_crypto17, path46, import_node_util8, cxapi12, import_cloud_assembly_schema9, import_toolkit_lib18, import_chalk33, fs49, pLimit5, FILE_EVENTS2, InternalToolkit, CdkToolkit, WorkGraphDeploymentActions;
 var init_cdk_toolkit = __esm({
   "lib/cli/cdk-toolkit.ts"() {
     "use strict";
@@ -299037,7 +299121,7 @@ var init_cdk_toolkit = __esm({
     import_chalk33 = __toESM(require_source());
     init_esm2();
     init_handler();
-    fs48 = __toESM(require_lib4());
+    fs49 = __toESM(require_lib4());
     init_io_host2();
     init_user_configuration();
     init_api_private();
@@ -299141,7 +299225,7 @@ var init_cdk_toolkit = __esm({
               "Can only select one stack when comparing to fixed template. Use --exclusively to avoid selecting multiple stacks."
             );
           }
-          if (!await fs48.pathExists(options.templatePath)) {
+          if (!await fs49.pathExists(options.templatePath)) {
             throw new import_toolkit_lib18.ToolkitError("TemplateNotFound", `There is no file at ${options.templatePath}`);
           }
           if (options.importExistingResources) {
@@ -299150,7 +299234,7 @@ var init_cdk_toolkit = __esm({
               "Can only use --import-existing-resources flag when comparing against deployed stacks."
             );
           }
-          const template = deserializeStructure(await fs48.readFile(options.templatePath, { encoding: "utf-8" }));
+          const template = deserializeStructure(await fs49.readFile(options.templatePath, { encoding: "utf-8" }));
           const formatter = new DiffFormatter({
             templateInfo: {
               oldTemplate: template,
@@ -299592,8 +299676,8 @@ var init_cdk_toolkit = __esm({
         }
         if (options.recordResourceMapping) {
           const outputFile = options.recordResourceMapping;
-          fs48.ensureFileSync(outputFile);
-          await fs48.writeJson(outputFile, actualImport.resourceMap, {
+          fs49.ensureFileSync(outputFile);
+          await fs49.writeJson(outputFile, actualImport.resourceMap, {
             spaces: 2,
             encoding: "utf8"
           });
@@ -299898,10 +299982,10 @@ var init_cdk_toolkit = __esm({
           if (filePath == null) {
             return [];
           }
-          if (!fs48.pathExistsSync(filePath)) {
+          if (!fs49.pathExistsSync(filePath)) {
             throw new import_toolkit_lib18.ToolkitError("MappingFileNotFound", `The mapping file ${filePath} does not exist`);
           }
-          const groups = parseMappingGroups(fs48.readFileSync(filePath).toString("utf-8"));
+          const groups = parseMappingGroups(fs49.readFileSync(filePath).toString("utf-8"));
           return revert ? groups.map((group4) => ({
             ...group4,
             resources: Object.fromEntries(Object.entries(group4.resources ?? {}).map(([src, dst]) => [dst, src]))
@@ -300313,8 +300397,8 @@ var init_cdk_toolkit = __esm({
         }
       }
       async writeOutputs(outputsFile) {
-        fs48.ensureFileSync(outputsFile);
-        await fs48.writeJson(outputsFile, this.stackOutputs, {
+        fs49.ensureFileSync(outputsFile);
+        await fs49.writeJson(outputsFile, this.stackOutputs, {
           spaces: 2,
           encoding: "utf8"
         });
@@ -300424,14 +300508,14 @@ async function displayVersionMessage(ioHelper, currentVersion = versionNumber(),
     await ioHelper.defaults.debug(`Could not run version check - ${err.message}`);
   }
 }
-var path47, import_toolkit_lib20, import_chalk34, fs49, semver5, ONE_DAY_IN_SECONDS, UPGRADE_DOCUMENTATION_LINKS, VersionCheckTTL;
+var path47, import_toolkit_lib20, import_chalk34, fs50, semver5, ONE_DAY_IN_SECONDS, UPGRADE_DOCUMENTATION_LINKS, VersionCheckTTL;
 var init_display_version = __esm({
   "lib/cli/display-version.ts"() {
     "use strict";
     path47 = __toESM(require("path"));
     import_toolkit_lib20 = __toESM(require_lib12());
     import_chalk34 = __toESM(require_source());
-    fs49 = __toESM(require_lib4());
+    fs50 = __toESM(require_lib4());
     semver5 = __toESM(require_semver4());
     init_util9();
     init_console_formatters();
@@ -300453,8 +300537,8 @@ var init_display_version = __esm({
       constructor(file, ttlSecs) {
         this.file = file || _VersionCheckTTL.timestampFilePath();
         try {
-          fs49.mkdirsSync(path47.dirname(this.file));
-          fs49.accessSync(path47.dirname(this.file), fs49.constants.W_OK);
+          fs50.mkdirsSync(path47.dirname(this.file));
+          fs50.accessSync(path47.dirname(this.file), fs50.constants.W_OK);
         } catch {
           throw new import_toolkit_lib20.ToolkitError("DirectoryNotWritable", `Directory (${path47.dirname(this.file)}) is not writable.`);
         }
@@ -300462,7 +300546,7 @@ var init_display_version = __esm({
       }
       async hasExpired() {
         try {
-          const lastCheckTime = (await fs49.stat(this.file)).mtimeMs;
+          const lastCheckTime = (await fs50.stat(this.file)).mtimeMs;
           const today = (/* @__PURE__ */ new Date()).getTime();
           if ((today - lastCheckTime) / 1e3 > this.ttlSecs) {
             return true;
@@ -300480,7 +300564,7 @@ var init_display_version = __esm({
         if (!latestVersion) {
           latestVersion = "";
         }
-        await fs49.writeFile(this.file, latestVersion);
+        await fs50.writeFile(this.file, latestVersion);
       }
     };
     __name(getVersionMessages, "getVersionMessages");
@@ -300766,8 +300850,8 @@ var require_middleware = __commonJS({
 var require_require_directory = __commonJS({
   "../../node_modules/require-directory/index.js"(exports2, module2) {
     "use strict";
-    var fs57 = require("fs");
-    var join54 = require("path").join;
+    var fs58 = require("fs");
+    var join55 = require("path").join;
     var resolve16 = require("path").resolve;
     var dirname17 = require("path").dirname;
     var defaultOptions2 = {
@@ -300804,9 +300888,9 @@ var require_require_directory = __commonJS({
         }
       }
       path54 = !path54 ? dirname17(m4.filename) : resolve16(dirname17(m4.filename), path54);
-      fs57.readdirSync(path54).forEach(function(filename) {
-        var joined = join54(path54, filename), files, key, obj;
-        if (fs57.statSync(joined).isDirectory() && options.recurse) {
+      fs58.readdirSync(path54).forEach(function(filename) {
+        var joined = join55(path54, filename), files, key, obj;
+        if (fs58.statSync(joined).isDirectory() && options.recurse) {
           files = requireDirectory(m4, joined, options);
           if (Object.keys(files).length) {
             retval[options.rename(filename, joined, filename)] = files;
@@ -303595,7 +303679,7 @@ var require_apply_extends = __commonJS({
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.applyExtends = void 0;
-    var fs57 = require("fs");
+    var fs58 = require("fs");
     var path54 = require("path");
     var yerror_1 = require_yerror();
     var previouslyVisitedConfigs = [];
@@ -303647,7 +303731,7 @@ var require_apply_extends = __commonJS({
           throw new yerror_1.YError(`Unable to find extended config '${config2.extends}' in '${cwd}'.`);
         checkForCircularExtends(pathToDefault);
         previouslyVisitedConfigs.push(pathToDefault);
-        defaultConfig = isPath ? JSON.parse(fs57.readFileSync(pathToDefault, "utf8")) : require(config2.extends);
+        defaultConfig = isPath ? JSON.parse(fs58.readFileSync(pathToDefault, "utf8")) : require(config2.extends);
         delete config2.extends;
         defaultConfig = applyExtends(defaultConfig, path54.dirname(pathToDefault), mergeExtends);
       }
@@ -303695,7 +303779,7 @@ var require_process_argv = __commonJS({
 // node_modules/y18n/index.js
 var require_y18n = __commonJS({
   "node_modules/y18n/index.js"(exports2, module2) {
-    var fs57 = require("fs");
+    var fs58 = require("fs");
     var path54 = require("path");
     var util11 = require("util");
     function Y18N(opts) {
@@ -303752,7 +303836,7 @@ var require_y18n = __commonJS({
       var cb = work[2];
       var languageFile = this._resolveLocaleFile(directory, locale);
       var serializedLocale = JSON.stringify(this.cache[locale], null, 2);
-      fs57.writeFile(languageFile, serializedLocale, "utf-8", function(err) {
+      fs58.writeFile(languageFile, serializedLocale, "utf-8", function(err) {
         _this.writeQueue.shift();
         if (_this.writeQueue.length > 0) _this._processWriteQueue();
         cb(err);
@@ -303762,7 +303846,7 @@ var require_y18n = __commonJS({
       var localeLookup = {};
       var languageFile = this._resolveLocaleFile(this.directory, this.locale);
       try {
-        localeLookup = JSON.parse(fs57.readFileSync(languageFile, "utf-8"));
+        localeLookup = JSON.parse(fs58.readFileSync(languageFile, "utf-8"));
       } catch (err) {
         if (err instanceof SyntaxError) {
           err.message = "syntax error in " + languageFile;
@@ -303782,7 +303866,7 @@ var require_y18n = __commonJS({
     };
     Y18N.prototype._fileExistsSync = function(file) {
       try {
-        return fs57.statSync(file).isFile();
+        return fs58.statSync(file).isFile();
       } catch (err) {
         return false;
       }
@@ -303950,11 +304034,11 @@ var require_locate_path = __commonJS({
   "../../node_modules/find-up/node_modules/locate-path/index.js"(exports2, module2) {
     "use strict";
     var path54 = require("path");
-    var fs57 = require("fs");
+    var fs58 = require("fs");
     var { promisify: promisify4 } = require("util");
     var pLocate = require_p_locate();
-    var fsStat = promisify4(fs57.stat);
-    var fsLStat = promisify4(fs57.lstat);
+    var fsStat = promisify4(fs58.stat);
+    var fsLStat = promisify4(fs58.lstat);
     var typeMappings = {
       directory: "isDirectory",
       file: "isFile"
@@ -303966,7 +304050,7 @@ var require_locate_path = __commonJS({
       throw new Error(`Invalid type specified: ${type}`);
     }
     __name(checkType, "checkType");
-    var matchType = /* @__PURE__ */ __name((type, stat8) => type === void 0 || stat8[typeMappings[type]](), "matchType");
+    var matchType = /* @__PURE__ */ __name((type, stat9) => type === void 0 || stat9[typeMappings[type]](), "matchType");
     module2.exports = async (paths, options) => {
       options = {
         cwd: process.cwd(),
@@ -303978,8 +304062,8 @@ var require_locate_path = __commonJS({
       const statFn = options.allowSymlinks ? fsStat : fsLStat;
       return pLocate(paths, async (path_) => {
         try {
-          const stat8 = await statFn(path54.resolve(options.cwd, path_));
-          return matchType(options.type, stat8);
+          const stat9 = await statFn(path54.resolve(options.cwd, path_));
+          return matchType(options.type, stat9);
         } catch (_) {
           return false;
         }
@@ -303993,11 +304077,11 @@ var require_locate_path = __commonJS({
         ...options
       };
       checkType(options);
-      const statFn = options.allowSymlinks ? fs57.statSync : fs57.lstatSync;
+      const statFn = options.allowSymlinks ? fs58.statSync : fs58.lstatSync;
       for (const path_ of paths) {
         try {
-          const stat8 = statFn(path54.resolve(options.cwd, path_));
-          if (matchType(options.type, stat8)) {
+          const stat9 = statFn(path54.resolve(options.cwd, path_));
+          if (matchType(options.type, stat9)) {
             return path_;
           }
         } catch (_) {
@@ -304011,9 +304095,9 @@ var require_locate_path = __commonJS({
 var require_path_exists2 = __commonJS({
   "../../node_modules/path-exists/index.js"(exports2, module2) {
     "use strict";
-    var fs57 = require("fs");
+    var fs58 = require("fs");
     var { promisify: promisify4 } = require("util");
-    var pAccess = promisify4(fs57.access);
+    var pAccess = promisify4(fs58.access);
     module2.exports = async (path54) => {
       try {
         await pAccess(path54);
@@ -304024,7 +304108,7 @@ var require_path_exists2 = __commonJS({
     };
     module2.exports.sync = (path54) => {
       try {
-        fs57.accessSync(path54);
+        fs58.accessSync(path54);
         return true;
       } catch (_) {
         return false;
@@ -304162,7 +304246,7 @@ var require_yargs = __commonJS({
     var yerror_1 = require_yerror();
     var usage_1 = require_usage();
     var argsert_1 = require_argsert();
-    var fs57 = require("fs");
+    var fs58 = require("fs");
     var completion_1 = require_completion();
     var path54 = require("path");
     var validation_1 = require_validation();
@@ -304659,7 +304743,7 @@ var require_yargs = __commonJS({
             cwd: startDir
           });
           common_types_1.assertNotStrictEqual(pkgJsonPath, void 0);
-          obj = JSON.parse(fs57.readFileSync(pkgJsonPath).toString());
+          obj = JSON.parse(fs58.readFileSync(pkgJsonPath).toString());
         } catch (noop) {
         }
         pkgs[npath] = obj || {};
@@ -306234,7 +306318,15 @@ function parseCommandLineArguments(args) {
       desc: "the command to use to open the browser, using %u as a placeholder for the path of the file to open",
       type: "string"
     })
-  ).command("doctor", "Check your set-up for potential problems").command("lsp", "Start the CDK Language Server (LSP) over stdio for editor and AI-agent integration").command("orphan [PATHS..]", "Detach resources from a CloudFormation stack without deleting them", (yargs2) => yargs2).command(
+  ).command("doctor", "Check your set-up for potential problems").command(
+    "lsp",
+    "Start the CDK Language Server (LSP) over stdio for editor and AI-agent integration",
+    (yargs2) => yargs2.option("features", {
+      default: false,
+      type: "boolean",
+      desc: "Print the LSP feature manifest as JSON and exit instead of starting the server. Lets a client probe LSP presence and capabilities without opening a session."
+    })
+  ).command("orphan [PATHS..]", "Detach resources from a CloudFormation stack without deleting them", (yargs2) => yargs2).command(
     "refactor [STACKS..]",
     "Moves resources between stacks or within the same stack",
     (yargs2) => yargs2.option("additional-stack-name", {
@@ -306300,10 +306392,10 @@ async function checkForPlatformWarnings(ioHelper) {
   }
 }
 async function hasDockerCopyBug() {
-  return await runningInDocker() && os13.platform() === "linux" && isVersionBetween(os13.release(), "5.6", "5.10");
+  return await runningInDocker() && os14.platform() === "linux" && isVersionBetween(os14.release(), "5.6", "5.10");
 }
 async function runningInDocker() {
-  return fs50.pathExists("/.dockerenv");
+  return fs51.pathExists("/.dockerenv");
 }
 function isVersionBetween(version, lower, upper) {
   const ver = splitVersion(version);
@@ -306329,12 +306421,12 @@ function isVersionBetween(version, lower, upper) {
 function splitVersion(version) {
   return `${version}`.split(".").map((x) => parseInt(x, 10)).map((x) => isNaN(x) ? 0 : x);
 }
-var os13, fs50;
+var os14, fs51;
 var init_platform_warnings = __esm({
   "lib/cli/platform-warnings.ts"() {
     "use strict";
-    os13 = __toESM(require("os"));
-    fs50 = __toESM(require_lib4());
+    os14 = __toESM(require("os"));
+    fs51 = __toESM(require_lib4());
     __name(checkForPlatformWarnings, "checkForPlatformWarnings");
     __name(hasDockerCopyBug, "hasDockerCopyBug");
     __name(runningInDocker, "runningInDocker");
@@ -313360,8 +313452,8 @@ var require_file2 = __commonJS({
         debug2("Normalized pathname: %o", filepath);
         const fdHandle = await fs_1.promises.open(filepath, flags, mode);
         const fd = fdHandle.fd;
-        const stat8 = await fdHandle.stat();
-        if (cache6 && cache6.stat && stat8 && isNotModified(cache6.stat, stat8)) {
+        const stat9 = await fdHandle.stat();
+        if (cache6 && cache6.stat && stat9 && isNotModified(cache6.stat, stat9)) {
           await fdHandle.close();
           throw new notmodified_1.default();
         }
@@ -313370,7 +313462,7 @@ var require_file2 = __commonJS({
           ...opts,
           fd
         });
-        rs.stat = stat8;
+        rs.stat = stat9;
         return rs;
       } catch (err) {
         if (err.code === "ENOENT") {
@@ -316974,7 +317066,7 @@ var require_util3 = __commonJS({
     }
     __name(normalize4, "normalize");
     exports2.normalize = normalize4;
-    function join54(aRoot, aPath) {
+    function join55(aRoot, aPath) {
       if (aRoot === "") {
         aRoot = ".";
       }
@@ -317006,8 +317098,8 @@ var require_util3 = __commonJS({
       }
       return joined;
     }
-    __name(join54, "join");
-    exports2.join = join54;
+    __name(join55, "join");
+    exports2.join = join55;
     exports2.isAbsolute = function(aPath) {
       return aPath.charAt(0) === "/" || urlRegexp.test(aPath);
     };
@@ -317190,7 +317282,7 @@ var require_util3 = __commonJS({
             parsed.path = parsed.path.substring(0, index + 1);
           }
         }
-        sourceURL = join54(urlGenerate(parsed), sourceURL);
+        sourceURL = join55(urlGenerate(parsed), sourceURL);
       }
       return normalize4(sourceURL);
     }
@@ -319027,7 +319119,7 @@ var require_escodegen = __commonJS({
         return space ? space : " ";
       }
       __name(noEmptySpace, "noEmptySpace");
-      function join54(left, right) {
+      function join55(left, right) {
         var leftSource, rightSource, leftCharCode, rightCharCode;
         leftSource = toSourceNodeWhenNeeded(left).toString();
         if (leftSource.length === 0) {
@@ -319046,7 +319138,7 @@ var require_escodegen = __commonJS({
         }
         return [left, space, right];
       }
-      __name(join54, "join");
+      __name(join55, "join");
       function addIndent(stmt) {
         return [base, stmt];
       }
@@ -319374,8 +319466,8 @@ var require_escodegen = __commonJS({
           } else {
             result2.push(that.generateExpression(stmt.left, Precedence.Call, E_TTT));
           }
-          result2 = join54(result2, operator);
-          result2 = [join54(
+          result2 = join55(result2, operator);
+          result2 = [join55(
             result2,
             that.generateExpression(stmt.right, Precedence.Assignment, E_TTT)
           ), ")"];
@@ -319518,11 +319610,11 @@ var require_escodegen = __commonJS({
           var result2, fragment;
           result2 = ["class"];
           if (stmt.id) {
-            result2 = join54(result2, this.generateExpression(stmt.id, Precedence.Sequence, E_TTT));
+            result2 = join55(result2, this.generateExpression(stmt.id, Precedence.Sequence, E_TTT));
           }
           if (stmt.superClass) {
-            fragment = join54("extends", this.generateExpression(stmt.superClass, Precedence.Unary, E_TTT));
-            result2 = join54(result2, fragment);
+            fragment = join55("extends", this.generateExpression(stmt.superClass, Precedence.Unary, E_TTT));
+            result2 = join55(result2, fragment);
           }
           result2.push(space);
           result2.push(this.generateStatement(stmt.body, S_TFFT));
@@ -319535,9 +319627,9 @@ var require_escodegen = __commonJS({
           return escapeDirective(stmt.directive) + this.semicolon(flags);
         }, "DirectiveStatement"),
         DoWhileStatement: /* @__PURE__ */ __name(function(stmt, flags) {
-          var result2 = join54("do", this.maybeBlock(stmt.body, S_TFFF));
+          var result2 = join55("do", this.maybeBlock(stmt.body, S_TFFF));
           result2 = this.maybeBlockSuffix(stmt.body, result2);
-          return join54(result2, [
+          return join55(result2, [
             "while" + space + "(",
             this.generateExpression(stmt.test, Precedence.Sequence, E_TTT),
             ")" + this.semicolon(flags)
@@ -319573,11 +319665,11 @@ var require_escodegen = __commonJS({
         ExportDefaultDeclaration: /* @__PURE__ */ __name(function(stmt, flags) {
           var result2 = ["export"], bodyFlags;
           bodyFlags = flags & F_SEMICOLON_OPT ? S_TFFT : S_TFFF;
-          result2 = join54(result2, "default");
+          result2 = join55(result2, "default");
           if (isStatement(stmt.declaration)) {
-            result2 = join54(result2, this.generateStatement(stmt.declaration, bodyFlags));
+            result2 = join55(result2, this.generateStatement(stmt.declaration, bodyFlags));
           } else {
-            result2 = join54(result2, this.generateExpression(stmt.declaration, Precedence.Assignment, E_TTT) + this.semicolon(flags));
+            result2 = join55(result2, this.generateExpression(stmt.declaration, Precedence.Assignment, E_TTT) + this.semicolon(flags));
           }
           return result2;
         }, "ExportDefaultDeclaration"),
@@ -319585,15 +319677,15 @@ var require_escodegen = __commonJS({
           var result2 = ["export"], bodyFlags, that = this;
           bodyFlags = flags & F_SEMICOLON_OPT ? S_TFFT : S_TFFF;
           if (stmt.declaration) {
-            return join54(result2, this.generateStatement(stmt.declaration, bodyFlags));
+            return join55(result2, this.generateStatement(stmt.declaration, bodyFlags));
           }
           if (stmt.specifiers) {
             if (stmt.specifiers.length === 0) {
-              result2 = join54(result2, "{" + space + "}");
+              result2 = join55(result2, "{" + space + "}");
             } else if (stmt.specifiers[0].type === Syntax.ExportBatchSpecifier) {
-              result2 = join54(result2, this.generateExpression(stmt.specifiers[0], Precedence.Sequence, E_TTT));
+              result2 = join55(result2, this.generateExpression(stmt.specifiers[0], Precedence.Sequence, E_TTT));
             } else {
-              result2 = join54(result2, "{");
+              result2 = join55(result2, "{");
               withIndent(function(indent2) {
                 var i6, iz;
                 result2.push(newline);
@@ -319611,7 +319703,7 @@ var require_escodegen = __commonJS({
               result2.push(base + "}");
             }
             if (stmt.source) {
-              result2 = join54(result2, [
+              result2 = join55(result2, [
                 "from" + space,
                 // ModuleSpecifier
                 this.generateExpression(stmt.source, Precedence.Sequence, E_TTT),
@@ -319702,7 +319794,7 @@ var require_escodegen = __commonJS({
           ];
           cursor2 = 0;
           if (stmt.specifiers[cursor2].type === Syntax.ImportDefaultSpecifier) {
-            result2 = join54(result2, [
+            result2 = join55(result2, [
               this.generateExpression(stmt.specifiers[cursor2], Precedence.Sequence, E_TTT)
             ]);
             ++cursor2;
@@ -319712,7 +319804,7 @@ var require_escodegen = __commonJS({
               result2.push(",");
             }
             if (stmt.specifiers[cursor2].type === Syntax.ImportNamespaceSpecifier) {
-              result2 = join54(result2, [
+              result2 = join55(result2, [
                 space,
                 this.generateExpression(stmt.specifiers[cursor2], Precedence.Sequence, E_TTT)
               ]);
@@ -319741,7 +319833,7 @@ var require_escodegen = __commonJS({
               }
             }
           }
-          result2 = join54(result2, [
+          result2 = join55(result2, [
             "from" + space,
             // ModuleSpecifier
             this.generateExpression(stmt.source, Precedence.Sequence, E_TTT),
@@ -319796,7 +319888,7 @@ var require_escodegen = __commonJS({
           return result2;
         }, "VariableDeclaration"),
         ThrowStatement: /* @__PURE__ */ __name(function(stmt, flags) {
-          return [join54(
+          return [join55(
             "throw",
             this.generateExpression(stmt.argument, Precedence.Sequence, E_TTT)
           ), this.semicolon(flags)];
@@ -319807,7 +319899,7 @@ var require_escodegen = __commonJS({
           result2 = this.maybeBlockSuffix(stmt.block, result2);
           if (stmt.handlers) {
             for (i6 = 0, iz = stmt.handlers.length; i6 < iz; ++i6) {
-              result2 = join54(result2, this.generateStatement(stmt.handlers[i6], S_TFFF));
+              result2 = join55(result2, this.generateStatement(stmt.handlers[i6], S_TFFF));
               if (stmt.finalizer || i6 + 1 !== iz) {
                 result2 = this.maybeBlockSuffix(stmt.handlers[i6].body, result2);
               }
@@ -319815,7 +319907,7 @@ var require_escodegen = __commonJS({
           } else {
             guardedHandlers = stmt.guardedHandlers || [];
             for (i6 = 0, iz = guardedHandlers.length; i6 < iz; ++i6) {
-              result2 = join54(result2, this.generateStatement(guardedHandlers[i6], S_TFFF));
+              result2 = join55(result2, this.generateStatement(guardedHandlers[i6], S_TFFF));
               if (stmt.finalizer || i6 + 1 !== iz) {
                 result2 = this.maybeBlockSuffix(guardedHandlers[i6].body, result2);
               }
@@ -319823,13 +319915,13 @@ var require_escodegen = __commonJS({
             if (stmt.handler) {
               if (Array.isArray(stmt.handler)) {
                 for (i6 = 0, iz = stmt.handler.length; i6 < iz; ++i6) {
-                  result2 = join54(result2, this.generateStatement(stmt.handler[i6], S_TFFF));
+                  result2 = join55(result2, this.generateStatement(stmt.handler[i6], S_TFFF));
                   if (stmt.finalizer || i6 + 1 !== iz) {
                     result2 = this.maybeBlockSuffix(stmt.handler[i6].body, result2);
                   }
                 }
               } else {
-                result2 = join54(result2, this.generateStatement(stmt.handler, S_TFFF));
+                result2 = join55(result2, this.generateStatement(stmt.handler, S_TFFF));
                 if (stmt.finalizer) {
                   result2 = this.maybeBlockSuffix(stmt.handler.body, result2);
                 }
@@ -319837,7 +319929,7 @@ var require_escodegen = __commonJS({
             }
           }
           if (stmt.finalizer) {
-            result2 = join54(result2, ["finally", this.maybeBlock(stmt.finalizer, S_TFFF)]);
+            result2 = join55(result2, ["finally", this.maybeBlock(stmt.finalizer, S_TFFF)]);
           }
           return result2;
         }, "TryStatement"),
@@ -319871,7 +319963,7 @@ var require_escodegen = __commonJS({
           withIndent(function() {
             if (stmt.test) {
               result2 = [
-                join54("case", that.generateExpression(stmt.test, Precedence.Sequence, E_TTT)),
+                join55("case", that.generateExpression(stmt.test, Precedence.Sequence, E_TTT)),
                 ":"
               ];
             } else {
@@ -319919,9 +320011,9 @@ var require_escodegen = __commonJS({
             result2.push(this.maybeBlock(stmt.consequent, S_TFFF));
             result2 = this.maybeBlockSuffix(stmt.consequent, result2);
             if (stmt.alternate.type === Syntax.IfStatement) {
-              result2 = join54(result2, ["else ", this.generateStatement(stmt.alternate, bodyFlags)]);
+              result2 = join55(result2, ["else ", this.generateStatement(stmt.alternate, bodyFlags)]);
             } else {
-              result2 = join54(result2, join54("else", this.maybeBlock(stmt.alternate, bodyFlags)));
+              result2 = join55(result2, join55("else", this.maybeBlock(stmt.alternate, bodyFlags)));
             }
           } else {
             result2.push(this.maybeBlock(stmt.consequent, bodyFlags));
@@ -320022,7 +320114,7 @@ var require_escodegen = __commonJS({
         }, "FunctionDeclaration"),
         ReturnStatement: /* @__PURE__ */ __name(function(stmt, flags) {
           if (stmt.argument) {
-            return [join54(
+            return [join55(
               "return",
               this.generateExpression(stmt.argument, Precedence.Sequence, E_TTT)
             ), this.semicolon(flags)];
@@ -320111,14 +320203,14 @@ var require_escodegen = __commonJS({
           if (leftSource.charCodeAt(leftSource.length - 1) === 47 && esutils.code.isIdentifierPartES5(expr.operator.charCodeAt(0))) {
             result2 = [fragment, noEmptySpace(), expr.operator];
           } else {
-            result2 = join54(fragment, expr.operator);
+            result2 = join55(fragment, expr.operator);
           }
           fragment = this.generateExpression(expr.right, rightPrecedence, flags);
           if (expr.operator === "/" && fragment.toString().charAt(0) === "/" || expr.operator.slice(-1) === "<" && fragment.toString().slice(0, 3) === "!--") {
             result2.push(noEmptySpace());
             result2.push(fragment);
           } else {
-            result2 = join54(result2, fragment);
+            result2 = join55(result2, fragment);
           }
           if (expr.operator === "in" && !(flags & F_ALLOW_IN)) {
             return ["(", result2, ")"];
@@ -320158,7 +320250,7 @@ var require_escodegen = __commonJS({
           var result2, length, i6, iz, itemFlags;
           length = expr["arguments"].length;
           itemFlags = flags & F_ALLOW_UNPARATH_NEW && !parentheses && length === 0 ? E_TFT : E_TFF;
-          result2 = join54(
+          result2 = join55(
             "new",
             this.generateExpression(expr.callee, Precedence.New, itemFlags)
           );
@@ -320208,11 +320300,11 @@ var require_escodegen = __commonJS({
           var result2, fragment, rightCharCode, leftSource, leftCharCode;
           fragment = this.generateExpression(expr.argument, Precedence.Unary, E_TTT);
           if (space === "") {
-            result2 = join54(expr.operator, fragment);
+            result2 = join55(expr.operator, fragment);
           } else {
             result2 = [expr.operator];
             if (expr.operator.length > 2) {
-              result2 = join54(result2, fragment);
+              result2 = join55(result2, fragment);
             } else {
               leftSource = toSourceNodeWhenNeeded(result2).toString();
               leftCharCode = leftSource.charCodeAt(leftSource.length - 1);
@@ -320235,7 +320327,7 @@ var require_escodegen = __commonJS({
             result2 = "yield";
           }
           if (expr.argument) {
-            result2 = join54(
+            result2 = join55(
               result2,
               this.generateExpression(expr.argument, Precedence.Yield, E_TTT)
             );
@@ -320243,7 +320335,7 @@ var require_escodegen = __commonJS({
           return parenthesize(result2, Precedence.Yield, precedence);
         }, "YieldExpression"),
         AwaitExpression: /* @__PURE__ */ __name(function(expr, precedence, flags) {
-          var result2 = join54(
+          var result2 = join55(
             expr.all ? "await*" : "await",
             this.generateExpression(expr.argument, Precedence.Await, E_TTT)
           );
@@ -320326,11 +320418,11 @@ var require_escodegen = __commonJS({
           var result2, fragment;
           result2 = ["class"];
           if (expr.id) {
-            result2 = join54(result2, this.generateExpression(expr.id, Precedence.Sequence, E_TTT));
+            result2 = join55(result2, this.generateExpression(expr.id, Precedence.Sequence, E_TTT));
           }
           if (expr.superClass) {
-            fragment = join54("extends", this.generateExpression(expr.superClass, Precedence.Unary, E_TTT));
-            result2 = join54(result2, fragment);
+            fragment = join55("extends", this.generateExpression(expr.superClass, Precedence.Unary, E_TTT));
+            result2 = join55(result2, fragment);
           }
           result2.push(space);
           result2.push(this.generateStatement(expr.body, S_TFFT));
@@ -320345,7 +320437,7 @@ var require_escodegen = __commonJS({
           }
           if (expr.kind === "get" || expr.kind === "set") {
             fragment = [
-              join54(expr.kind, this.generatePropertyKey(expr.key, expr.computed)),
+              join55(expr.kind, this.generatePropertyKey(expr.key, expr.computed)),
               this.generateFunctionBody(expr.value)
             ];
           } else {
@@ -320355,7 +320447,7 @@ var require_escodegen = __commonJS({
               this.generateFunctionBody(expr.value)
             ];
           }
-          return join54(result2, fragment);
+          return join55(result2, fragment);
         }, "MethodDefinition"),
         Property: /* @__PURE__ */ __name(function(expr, precedence, flags) {
           if (expr.kind === "get" || expr.kind === "set") {
@@ -320550,7 +320642,7 @@ var require_escodegen = __commonJS({
               for (i6 = 0, iz = expr.blocks.length; i6 < iz; ++i6) {
                 fragment = that.generateExpression(expr.blocks[i6], Precedence.Sequence, E_TTT);
                 if (i6 > 0 || extra.moz.comprehensionExpressionStartsWithAssignment) {
-                  result2 = join54(result2, fragment);
+                  result2 = join55(result2, fragment);
                 } else {
                   result2.push(fragment);
                 }
@@ -320558,13 +320650,13 @@ var require_escodegen = __commonJS({
             });
           }
           if (expr.filter) {
-            result2 = join54(result2, "if" + space);
+            result2 = join55(result2, "if" + space);
             fragment = this.generateExpression(expr.filter, Precedence.Sequence, E_TTT);
-            result2 = join54(result2, ["(", fragment, ")"]);
+            result2 = join55(result2, ["(", fragment, ")"]);
           }
           if (!extra.moz.comprehensionExpressionStartsWithAssignment) {
             fragment = this.generateExpression(expr.body, Precedence.Assignment, E_TTT);
-            result2 = join54(result2, fragment);
+            result2 = join55(result2, fragment);
           }
           result2.push(expr.type === Syntax.GeneratorExpression ? ")" : "]");
           return result2;
@@ -320580,8 +320672,8 @@ var require_escodegen = __commonJS({
           } else {
             fragment = this.generateExpression(expr.left, Precedence.Call, E_TTT);
           }
-          fragment = join54(fragment, expr.of ? "of" : "in");
-          fragment = join54(fragment, this.generateExpression(expr.right, Precedence.Sequence, E_TTT));
+          fragment = join55(fragment, expr.of ? "of" : "in");
+          fragment = join55(fragment, this.generateExpression(expr.right, Precedence.Sequence, E_TTT));
           return ["for" + space + "(", fragment, ")"];
         }, "ComprehensionBlock"),
         SpreadElement: /* @__PURE__ */ __name(function(expr, precedence, flags) {
@@ -334006,14 +334098,14 @@ var require_emscripten_module_WASM_RELEASE_SYNC = __commonJS({
         });
         var p3 = Object.assign({}, a6), t = "./this.program", u = "object" == typeof window, v = "function" == typeof importScripts, w = "object" == typeof process && "object" == typeof process.versions && "string" == typeof process.versions.node, x = "", y, z, A;
         if (w) {
-          var fs57 = require("fs"), B = require("path");
+          var fs58 = require("fs"), B = require("path");
           x = v ? B.dirname(x) + "/" : __dirname + "/";
           y = /* @__PURE__ */ __name((b6, c6) => {
             var d6 = C(b6);
             if (d6)
               return c6 ? d6 : d6.toString();
             b6 = b6.startsWith("file://") ? new URL(b6) : B.normalize(b6);
-            return fs57.readFileSync(b6, c6 ? void 0 : "utf8");
+            return fs58.readFileSync(b6, c6 ? void 0 : "utf8");
           }, "y");
           A = /* @__PURE__ */ __name((b6) => {
             b6 = y(b6, true);
@@ -334024,7 +334116,7 @@ var require_emscripten_module_WASM_RELEASE_SYNC = __commonJS({
             var e6 = C(b6);
             e6 && c6(e6);
             b6 = b6.startsWith("file://") ? new URL(b6) : B.normalize(b6);
-            fs57.readFile(b6, function(f6, g6) {
+            fs58.readFile(b6, function(f6, g6) {
               f6 ? d6(f6) : c6(g6.buffer);
             });
           }, "z");
@@ -335383,11 +335475,11 @@ var require_dist14 = __commonJS({
 });
 
 // lib/cli/proxy-agent.ts
-var fs51, import_proxy_agent, ProxyAgentProvider;
+var fs52, import_proxy_agent, ProxyAgentProvider;
 var init_proxy_agent = __esm({
   "lib/cli/proxy-agent.ts"() {
     "use strict";
-    fs51 = __toESM(require_lib4());
+    fs52 = __toESM(require_lib4());
     import_proxy_agent = __toESM(require_dist14());
     ProxyAgentProvider = class {
       static {
@@ -335409,10 +335501,10 @@ var init_proxy_agent = __esm({
         if (path54) {
           await this.ioHelper.defaults.debug(`Using CA bundle path: ${path54}`);
           try {
-            if (!fs51.pathExistsSync(path54)) {
+            if (!fs52.pathExistsSync(path54)) {
               return void 0;
             }
-            return fs51.readFileSync(path54, { encoding: "utf-8" });
+            return fs52.readFileSync(path54, { encoding: "utf-8" });
           } catch (e6) {
             await this.ioHelper.defaults.debug(String(e6));
             return void 0;
@@ -335629,9 +335721,9 @@ async function docs(options) {
   await ioHelper.defaults.debug(`Opening documentation ${import_chalk37.default.green(browserCommand)}`);
   const exec5 = (0, import_node_util9.promisify)(childProcess2.exec);
   try {
-    const { stdout, stderr } = await exec5(browserCommand);
-    if (stdout) {
-      await ioHelper.defaults.debug(stdout);
+    const { stdout: stdout2, stderr } = await exec5(browserCommand);
+    if (stdout2) {
+      await ioHelper.defaults.debug(stdout2);
     }
     if (stderr) {
       await ioHelper.defaults.warn(stderr);
@@ -341408,16 +341500,16 @@ async function isWithinRoot(root6, candidate) {
 }
 async function realOrSelf(p3) {
   try {
-    return await fs52.promises.realpath(p3);
+    return await fs53.promises.realpath(p3);
   } catch {
     return p3;
   }
 }
-var fs52, path48, import_url, convertSourceMap, SourceMapResolver, TS_JS_EXTENSIONS, HOST_LANGUAGE_EXTENSIONS, FRAME_RE;
+var fs53, path48, import_url, convertSourceMap, SourceMapResolver, TS_JS_EXTENSIONS, HOST_LANGUAGE_EXTENSIONS, FRAME_RE;
 var init_source_resolver = __esm({
   "../@aws-cdk/cdk-explorer/lib/core/source-resolver.ts"() {
     "use strict";
-    fs52 = __toESM(require("fs"));
+    fs53 = __toESM(require("fs"));
     path48 = __toESM(require("path"));
     import_url = require("url");
     init_trace_mapping();
@@ -341491,7 +341583,7 @@ var init_source_resolver = __esm({
       async readSourceMap(jsFile) {
         let code;
         try {
-          code = await fs52.promises.readFile(jsFile, "utf-8");
+          code = await fs53.promises.readFile(jsFile, "utf-8");
         } catch {
           return null;
         }
@@ -341503,7 +341595,7 @@ var init_source_resolver = __esm({
               throw new Error(`source map path escapes the project root: ${mapPath}`);
             }
             mapUrl = (0, import_url.pathToFileURL)(mapPath).href;
-            return fs52.promises.readFile(mapPath, "utf-8");
+            return fs53.promises.readFile(mapPath, "utf-8");
           });
           return converter ? new TraceMap(converter.toObject(), mapUrl) : null;
         } catch (err) {
@@ -341529,15 +341621,15 @@ __export(assembly_reader_exports, {
   readAssembly: () => readAssembly
 });
 async function readAssembly(assemblyDir) {
-  const manifestPath = path49.join(assemblyDir, import_cloud_assembly_api18.MANIFEST_FILE);
-  if (!fs53.existsSync(manifestPath)) {
+  const manifestPath = path49.join(assemblyDir, import_cloud_assembly_api17.MANIFEST_FILE);
+  if (!fs54.existsSync(manifestPath)) {
     return { status: "not-found" };
   }
   try {
-    const assembly = new import_cloud_assembly_api18.CloudAssembly(assemblyDir);
+    const assembly = new import_cloud_assembly_api17.CloudAssembly(assemblyDir);
     const projectRoot = path49.dirname(assemblyDir);
     const sourceResolver = new SourceMapResolver(projectRoot);
-    const tree = await (0, import_cloud_assembly_api18.buildConstructTreeAsync)(assembly, async (fields, stack, constructPath) => ({
+    const tree = await (0, import_cloud_assembly_api17.buildConstructTreeAsync)(assembly, async (fields, stack, constructPath) => ({
       ...fields,
       // templateFile comes from the manifest / a nested stack's aws:asset:path,
       // both attacker-influenceable if cdk.out is tampered with. Drop any that
@@ -341563,16 +341655,16 @@ async function readAssembly(assemblyDir) {
 }
 function loadViolations(assemblyDir) {
   const reportPath = path49.join(assemblyDir, import_cloud_assembly_schema10.VALIDATION_REPORT_FILE);
-  if (!fs53.existsSync(reportPath)) return void 0;
-  return JSON.parse(fs53.readFileSync(reportPath, "utf-8"));
+  if (!fs54.existsSync(reportPath)) return void 0;
+  return JSON.parse(fs54.readFileSync(reportPath, "utf-8"));
 }
-var fs53, path49, import_cloud_assembly_api18, import_cloud_assembly_schema10;
+var fs54, path49, import_cloud_assembly_api17, import_cloud_assembly_schema10;
 var init_assembly_reader = __esm({
   "../@aws-cdk/cdk-explorer/lib/core/assembly-reader.ts"() {
     "use strict";
-    fs53 = __toESM(require("fs"));
+    fs54 = __toESM(require("fs"));
     path49 = __toESM(require("path"));
-    import_cloud_assembly_api18 = __toESM(require_lib3());
+    import_cloud_assembly_api17 = __toESM(require_lib3());
     import_cloud_assembly_schema10 = __toESM(require_lib2());
     init_api_private2();
     init_source_resolver();
@@ -341740,7 +341832,7 @@ var require_messages = __commonJS({
       }
     };
     exports2.AbstractMessageSignature = AbstractMessageSignature;
-    var RequestType0 = class extends AbstractMessageSignature {
+    var RequestType02 = class extends AbstractMessageSignature {
       static {
         __name(this, "RequestType0");
       }
@@ -341748,7 +341840,7 @@ var require_messages = __commonJS({
         super(method, 0);
       }
     };
-    exports2.RequestType0 = RequestType0;
+    exports2.RequestType0 = RequestType02;
     var RequestType = class extends AbstractMessageSignature {
       static {
         __name(this, "RequestType");
@@ -344840,7 +344932,7 @@ var require_main2 = __commonJS({
     var ril_1 = require_ril();
     ril_1.default.install();
     var path54 = require("path");
-    var os14 = require("os");
+    var os15 = require("os");
     var crypto_1 = require("crypto");
     var net_1 = require("net");
     var api_1 = require_api2();
@@ -345001,7 +345093,7 @@ var require_main2 = __commonJS({
       if (XDG_RUNTIME_DIR) {
         result2 = path54.join(XDG_RUNTIME_DIR, `vscode-ipc-${randomSuffix}.sock`);
       } else {
-        result2 = path54.join(os14.tmpdir(), `vscode-${randomSuffix}.sock`);
+        result2 = path54.join(os15.tmpdir(), `vscode-${randomSuffix}.sock`);
       }
       const limit = safeIpcPathLengths.get(process.platform);
       if (limit !== void 0 && result2.length > limit) {
@@ -345291,7 +345383,7 @@ var require_messages2 = __commonJS({
       }
     };
     exports2.AbstractMessageSignature = AbstractMessageSignature;
-    var RequestType0 = class extends AbstractMessageSignature {
+    var RequestType02 = class extends AbstractMessageSignature {
       static {
         __name(this, "RequestType0");
       }
@@ -345299,7 +345391,7 @@ var require_messages2 = __commonJS({
         super(method, 0);
       }
     };
-    exports2.RequestType0 = RequestType0;
+    exports2.RequestType0 = RequestType02;
     var RequestType = class extends AbstractMessageSignature {
       static {
         __name(this, "RequestType");
@@ -348390,7 +348482,7 @@ var require_main3 = __commonJS({
     var ril_1 = require_ril2();
     ril_1.default.install();
     var path54 = require("path");
-    var os14 = require("os");
+    var os15 = require("os");
     var crypto_1 = require("crypto");
     var net_1 = require("net");
     var api_1 = require_api3();
@@ -348551,7 +348643,7 @@ var require_main3 = __commonJS({
       if (XDG_RUNTIME_DIR) {
         result2 = path54.join(XDG_RUNTIME_DIR, `vscode-ipc-${randomSuffix}.sock`);
       } else {
-        result2 = path54.join(os14.tmpdir(), `vscode-${randomSuffix}.sock`);
+        result2 = path54.join(os15.tmpdir(), `vscode-${randomSuffix}.sock`);
       }
       const limit = safeIpcPathLengths.get(process.platform);
       if (limit !== void 0 && result2.length > limit) {
@@ -353915,7 +354007,7 @@ var require_files = __commonJS({
     exports2.resolveModulePath = exports2.FileSystem = exports2.resolveGlobalYarnPath = exports2.resolveGlobalNodePath = exports2.resolve = exports2.uriToFilePath = void 0;
     var url = require("url");
     var path54 = require("path");
-    var fs57 = require("fs");
+    var fs58 = require("fs");
     var child_process_1 = require("child_process");
     function uriToFilePath(uri) {
       let parsed = url.parse(uri);
@@ -353964,7 +354056,7 @@ var require_files = __commonJS({
         let env3 = process.env;
         let newEnv = /* @__PURE__ */ Object.create(null);
         Object.keys(env3).forEach((key) => newEnv[key] = env3[key]);
-        if (nodePath && fs57.existsSync(nodePath)) {
+        if (nodePath && fs58.existsSync(nodePath)) {
           if (newEnv[nodePathKey]) {
             newEnv[nodePathKey] = nodePath + path54.delimiter + newEnv[nodePathKey];
           } else {
@@ -354027,14 +354119,14 @@ var require_files = __commonJS({
       }, "handler");
       try {
         process.on("SIGPIPE", handler);
-        let stdout = (0, child_process_1.spawnSync)(npmCommand, ["config", "get", "prefix"], options).stdout;
-        if (!stdout) {
+        let stdout2 = (0, child_process_1.spawnSync)(npmCommand, ["config", "get", "prefix"], options).stdout;
+        if (!stdout2) {
           if (tracer) {
             tracer(`'npm config get prefix' didn't return a value.`);
           }
           return void 0;
         }
-        let prefix = stdout.trim();
+        let prefix = stdout2.trim();
         if (tracer) {
           tracer(`'npm config get prefix' value is: ${prefix}`);
         }
@@ -354068,8 +354160,8 @@ var require_files = __commonJS({
       try {
         process.on("SIGPIPE", handler);
         let results = (0, child_process_1.spawnSync)(yarnCommand, ["global", "dir", "--json"], options);
-        let stdout = results.stdout;
-        if (!stdout) {
+        let stdout2 = results.stdout;
+        if (!stdout2) {
           if (tracer) {
             tracer(`'yarn global dir' didn't return a value.`);
             if (results.stderr) {
@@ -354078,7 +354170,7 @@ var require_files = __commonJS({
           }
           return void 0;
         }
-        let lines = stdout.trim().split(/\r?\n/);
+        let lines = stdout2.trim().split(/\r?\n/);
         for (let line of lines) {
           try {
             let yarn = JSON.parse(line);
@@ -354107,7 +354199,7 @@ var require_files = __commonJS({
         if (process.platform === "win32") {
           _isCaseSensitive = false;
         } else {
-          _isCaseSensitive = !fs57.existsSync(__filename.toUpperCase()) || !fs57.existsSync(__filename.toLowerCase());
+          _isCaseSensitive = !fs58.existsSync(__filename.toUpperCase()) || !fs58.existsSync(__filename.toLowerCase());
         }
         return _isCaseSensitive;
       }
@@ -354836,11 +354928,11 @@ async function resourceTarget(node) {
   }
   let templateText;
   try {
-    templateText = await fs54.promises.readFile(node.templateFile, "utf-8");
+    templateText = await fs55.promises.readFile(node.templateFile, "utf-8");
   } catch {
     return void 0;
   }
-  const block = (0, import_cloud_assembly_api19.resolveResourceRange)(templateText, node.logicalId);
+  const block = (0, import_cloud_assembly_api18.resolveResourceRange)(templateText, node.logicalId);
   if (block === void 0) {
     return void 0;
   }
@@ -354850,7 +354942,7 @@ async function resourceTarget(node) {
   };
 }
 function sourceTargetAtTemplateOffset(index, templateFile, templateText, offset) {
-  const logicalId = (0, import_cloud_assembly_api19.resolveLogicalIdAtOffset)(templateText, offset);
+  const logicalId = (0, import_cloud_assembly_api18.resolveLogicalIdAtOffset)(templateText, offset);
   if (logicalId === void 0) {
     return void 0;
   }
@@ -354864,13 +354956,13 @@ function sourceTargetAtTemplateOffset(index, templateFile, templateText, offset)
     range: { start: position, end: position }
   };
 }
-var fs54, import_url2, import_cloud_assembly_api19;
+var fs55, import_url2, import_cloud_assembly_api18;
 var init_template_locator = __esm({
   "../@aws-cdk/cdk-explorer/lib/lsp/template-locator.ts"() {
     "use strict";
-    fs54 = __toESM(require("fs"));
+    fs55 = __toESM(require("fs"));
     import_url2 = require("url");
-    import_cloud_assembly_api19 = __toESM(require_lib3());
+    import_cloud_assembly_api18 = __toESM(require_lib3());
     init_positions();
     __name(resourceTarget, "resourceTarget");
     __name(sourceTargetAtTemplateOffset, "sourceTargetAtTemplateOffset");
@@ -354959,6 +355051,17 @@ var init_codelens = __esm({
   }
 });
 
+// ../@aws-cdk/cdk-explorer/lib/lsp/construct-tree-request.ts
+var import_vscode_languageserver, GET_CONSTRUCT_TREE_METHOD, GetConstructTreeRequest;
+var init_construct_tree_request = __esm({
+  "../@aws-cdk/cdk-explorer/lib/lsp/construct-tree-request.ts"() {
+    "use strict";
+    import_vscode_languageserver = __toESM(require_main6());
+    GET_CONSTRUCT_TREE_METHOD = "cdk/getConstructTree";
+    GetConstructTreeRequest = new import_vscode_languageserver.RequestType0(GET_CONSTRUCT_TREE_METHOD);
+  }
+});
+
 // ../@aws-cdk/cdk-explorer/lib/lsp/diagnostics.ts
 function mapViolationsToDiagnostics(violations, index) {
   const dropped = [];
@@ -355047,6 +355150,34 @@ var init_diagnostics = __esm({
   }
 });
 
+// ../@aws-cdk/cdk-explorer/lib/lsp/features.ts
+var features_exports = {};
+__export(features_exports, {
+  CDK_LSP_FEATURES: () => CDK_LSP_FEATURES,
+  CDK_LSP_PROTOCOL: () => CDK_LSP_PROTOCOL,
+  cdkLspManifest: () => cdkLspManifest
+});
+function cdkLspManifest(version) {
+  return {
+    protocol: CDK_LSP_PROTOCOL,
+    version,
+    features: [...CDK_LSP_FEATURES],
+    // Deliberately mirrors executeCommandProvider.commands on the wire so the
+    // `cdk lsp --features` probe (which has no LSP session) can see them too.
+    commands: [...SUPPORTED_COMMANDS]
+  };
+}
+var CDK_LSP_PROTOCOL, CDK_LSP_FEATURES;
+var init_features = __esm({
+  "../@aws-cdk/cdk-explorer/lib/lsp/features.ts"() {
+    "use strict";
+    init_commands7();
+    CDK_LSP_PROTOCOL = 1;
+    CDK_LSP_FEATURES = ["hover", "codeLens", "definition", "synth", "autoSynth"];
+    __name(cdkLspManifest, "cdkLspManifest");
+  }
+});
+
 // ../@aws-cdk/cdk-explorer/lib/lsp/hover.ts
 function resourceNodesOnLine(index, uri, position) {
   const line = position.line + 1;
@@ -355072,7 +355203,7 @@ async function resolveHoverLinks(nodes6, primary, readTemplate) {
   const resolveOnce = /* @__PURE__ */ __name(async (file) => {
     if (!templates.has(file)) {
       const text = await readTemplate(file);
-      const ranges = text === void 0 ? void 0 : (0, import_cloud_assembly_api20.indexTemplateRanges)(text);
+      const ranges = text === void 0 ? void 0 : (0, import_cloud_assembly_api19.indexTemplateRanges)(text);
       templates.set(file, text !== void 0 && ranges !== void 0 ? { text, ranges } : void 0);
     }
     return templates.get(file);
@@ -355228,12 +355359,12 @@ function histogram(nodes6) {
 function truncate(text, max) {
   return text.length <= max ? text : `${text.slice(0, max - 1)}\u2026`;
 }
-var import_url5, import_cloud_assembly_api20, import_node2, MAX_PROPERTIES, MAX_LINKED_AUX, MAX_STRING_LENGTH, MAX_OBJECT_KEYS, MAX_HISTOGRAM_TYPES;
+var import_url5, import_cloud_assembly_api19, import_node2, MAX_PROPERTIES, MAX_LINKED_AUX, MAX_STRING_LENGTH, MAX_OBJECT_KEYS, MAX_HISTOGRAM_TYPES;
 var init_hover = __esm({
   "../@aws-cdk/cdk-explorer/lib/lsp/hover.ts"() {
     "use strict";
     import_url5 = require("url");
-    import_cloud_assembly_api20 = __toESM(require_lib3());
+    import_cloud_assembly_api19 = __toESM(require_lib3());
     import_node2 = __toESM(require_node6());
     init_codelens();
     init_positions();
@@ -355360,17 +355491,17 @@ function startAssemblyWatcher(options) {
     }
   };
 }
-var path51, import_cloud_assembly_api21, import_cloud_assembly_schema11, TREE_FILE, ASSEMBLY_SIGNAL_FILES, DEBOUNCE_MS;
+var path51, import_cloud_assembly_api20, import_cloud_assembly_schema11, TREE_FILE, ASSEMBLY_SIGNAL_FILES, DEBOUNCE_MS;
 var init_assembly_watcher = __esm({
   "../@aws-cdk/cdk-explorer/lib/core/assembly-watcher.ts"() {
     "use strict";
     path51 = __toESM(require("path"));
-    import_cloud_assembly_api21 = __toESM(require_lib3());
+    import_cloud_assembly_api20 = __toESM(require_lib3());
     import_cloud_assembly_schema11 = __toESM(require_lib2());
     init_esm2();
     TREE_FILE = "tree.json";
     ASSEMBLY_SIGNAL_FILES = /* @__PURE__ */ new Set([
-      import_cloud_assembly_api21.MANIFEST_FILE,
+      import_cloud_assembly_api20.MANIFEST_FILE,
       TREE_FILE,
       import_cloud_assembly_schema11.VALIDATION_REPORT_FILE
     ]);
@@ -355428,7 +355559,10 @@ function createLspHandlers(options) {
   let autoSynthEnabled = false;
   let shouldIgnore = /* @__PURE__ */ __name(() => false, "shouldIgnore");
   let assemblyWatcher;
-  let cachedIndex = import_cloud_assembly_api22.ConstructIndex.fromTree([]);
+  let cachedIndex = import_cloud_assembly_api21.ConstructIndex.fromTree([]);
+  let cachedTree = [];
+  let cachedWarnings = [];
+  let cachedAssemblyDir;
   let publishedUris = /* @__PURE__ */ new Set();
   let codeLensRefreshSupported = false;
   function currentProjectDir() {
@@ -355471,7 +355605,10 @@ function createLspHandlers(options) {
     for (const warning2 of warnings) {
       log.warn(warning2);
     }
-    cachedIndex = import_cloud_assembly_api22.ConstructIndex.fromTree(tree);
+    cachedIndex = import_cloud_assembly_api21.ConstructIndex.fromTree(tree);
+    cachedTree = tree;
+    cachedWarnings = warnings;
+    cachedAssemblyDir = assemblyDir;
     const { byUri, dropped } = mapViolationsToDiagnostics(violations, cachedIndex);
     for (const drop of dropped) {
       log.warn(`Dropped diagnostic for '${drop.ruleName}' at '${drop.constructPath}': ${drop.reason}`);
@@ -355553,7 +355690,9 @@ function createLspHandlers(options) {
     onInitialize(params) {
       applicationDir = params.initializationOptions?.applicationDir;
       codeLensRefreshSupported = params.capabilities.workspace?.codeLens?.refreshSupport ?? false;
+      const manifest = cdkLspManifest(options.version);
       return {
+        serverInfo: { name: "cdk-lsp", version: manifest.version },
         capabilities: {
           textDocumentSync: {
             openClose: false,
@@ -355568,7 +355707,10 @@ function createLspHandlers(options) {
           definitionProvider: true,
           executeCommandProvider: { commands: [...SUPPORTED_COMMANDS] },
           // Hover a construct's creation line to see its resolved CFN properties.
-          hoverProvider: true
+          hoverProvider: true,
+          // Non-standard: lets a client discover CDK-specific features and the
+          // wire protocol version ahead of use; also backs `cdk lsp --features`.
+          experimental: { cdk: manifest }
         }
       };
     },
@@ -355615,7 +355757,7 @@ function createLspHandlers(options) {
       }
       let templateText;
       try {
-        templateText = await fs55.promises.readFile(filePath, "utf-8");
+        templateText = await fs56.promises.readFile(filePath, "utf-8");
       } catch {
         return void 0;
       }
@@ -355637,9 +355779,44 @@ function createLspHandlers(options) {
         cachedIndex,
         params.textDocument.uri,
         params.position,
-        (file) => fs55.promises.readFile(file, "utf-8").catch(() => void 0)
+        (file) => fs56.promises.readFile(file, "utf-8").catch(() => void 0)
       );
     },
+    onGetConstructTree() {
+      const assemblyDir = cachedAssemblyDir ?? path52.join(currentProjectDir(), "cdk.out");
+      if (cachedAssemblyDir === void 0) {
+        return { status: "no-assembly", assemblyDir, entries: [], warnings: [] };
+      }
+      const rangesByTemplate = /* @__PURE__ */ new Map();
+      const templateRangesFor = /* @__PURE__ */ __name((templateFile) => {
+        if (!rangesByTemplate.has(templateFile)) {
+          try {
+            rangesByTemplate.set(templateFile, (0, import_cloud_assembly_api21.indexTemplateRanges)(fs56.readFileSync(templateFile, "utf-8")));
+          } catch {
+            rangesByTemplate.set(templateFile, void 0);
+          }
+        }
+        return rangesByTemplate.get(templateFile);
+      }, "templateRangesFor");
+      const entries = [];
+      const collect = /* @__PURE__ */ __name((nodes6) => {
+        for (const node of nodes6) {
+          const templateOffset = node.templateFile && node.logicalId ? templateRangesFor(node.templateFile)?.block(node.logicalId)?.start : void 0;
+          entries.push({
+            path: node.path,
+            id: node.id,
+            type: node.type,
+            logicalId: node.logicalId,
+            sourceLocation: node.sourceLocation,
+            templateFile: node.templateFile,
+            templateOffset
+          });
+          collect(node.children);
+        }
+      }, "collect");
+      collect(cachedTree);
+      return { status: "ok", assemblyDir, entries, warnings: [...cachedWarnings] };
+    },
     onShutdown() {
       shutdownRequested = true;
       void assemblyWatcher?.close();
@@ -355665,6 +355842,7 @@ function startServer(options) {
         void connection.sendRequest(import_node5.CodeLensRefreshRequest.type);
       }
     }, "onRefreshCodeLenses"),
+    version: options.version,
     synthRunner,
     acquireAssemblyLock,
     notify: {
@@ -355702,25 +355880,28 @@ function startServer(options) {
   connection.onDefinition((params) => handlers.onDefinition(params));
   connection.onExecuteCommand((params) => handlers.onExecuteCommand(params));
   connection.onHover((params) => handlers.onHover(params));
+  connection.onRequest(GetConstructTreeRequest, () => handlers.onGetConstructTree());
   connection.onShutdown(() => handlers.onShutdown());
   connection.onExit(() => process.exit(0));
   connection.listen();
 }
-var fs55, path52, import_url7, import_cloud_assembly_api22, import_toolkit_lib22, import_node4, import_node5, REFRESH_LOCK_RETRIES, REFRESH_LOCK_RETRY_MS, SYNTH_LOCK_RETRY_BASE_MS, SYNTH_LOCK_RETRY_MAX_MS, NOOP_LOGGER;
+var fs56, path52, import_url7, import_cloud_assembly_api21, import_toolkit_lib22, import_node4, import_node5, REFRESH_LOCK_RETRIES, REFRESH_LOCK_RETRY_MS, SYNTH_LOCK_RETRY_BASE_MS, SYNTH_LOCK_RETRY_MAX_MS, NOOP_LOGGER;
 var init_server = __esm({
   "../@aws-cdk/cdk-explorer/lib/lsp/server.ts"() {
     "use strict";
-    fs55 = __toESM(require("fs"));
+    fs56 = __toESM(require("fs"));
     path52 = __toESM(require("path"));
     import_url7 = require("url");
-    import_cloud_assembly_api22 = __toESM(require_lib3());
+    import_cloud_assembly_api21 = __toESM(require_lib3());
     import_toolkit_lib22 = __toESM(require_lib12());
     import_node4 = __toESM(require_node3());
     import_node5 = __toESM(require_node6());
     init_api_private2();
     init_codelens();
     init_commands7();
+    init_construct_tree_request();
     init_diagnostics();
+    init_features();
     init_hover();
     init_positions();
     init_synth_diagnostics();
@@ -355763,10 +355944,10 @@ var init_assembly_lock = __esm({
 // ../@aws-cdk/cdk-explorer/lib/core/cdk-config.ts
 function readCdkConfig(projectDir) {
   const configPath = path53.join(projectDir, "cdk.json");
-  if (!fs56.existsSync(configPath)) return { app: void 0 };
+  if (!fs57.existsSync(configPath)) return { app: void 0 };
   let parsed;
   try {
-    parsed = JSON.parse(fs56.readFileSync(configPath, "utf-8"));
+    parsed = JSON.parse(fs57.readFileSync(configPath, "utf-8"));
   } catch {
     return { app: void 0 };
   }
@@ -355774,11 +355955,11 @@ function readCdkConfig(projectDir) {
   const app = parsed.app;
   return { app: typeof app === "string" ? app : void 0 };
 }
-var fs56, path53;
+var fs57, path53;
 var init_cdk_config = __esm({
   "../@aws-cdk/cdk-explorer/lib/core/cdk-config.ts"() {
     "use strict";
-    fs56 = __toESM(require("fs"));
+    fs57 = __toESM(require("fs"));
     path53 = __toESM(require("path"));
     __name(readCdkConfig, "readCdkConfig");
   }
@@ -355840,10 +356021,11 @@ var main_exports = {};
 __export(main_exports, {
   startLspServer: () => startLspServer
 });
-function startLspServer() {
+function startLspServer(version) {
   startServer({
     readable: process.stdin,
     writable: process.stdout,
+    version,
     // Build the Toolkit once connection.console exists (so output reaches the
     // editor Output panel), then bind the two ops the handlers need. The read
     // lock comes from fromAssemblyDirectory().produce(), so we never touch RWLock.
@@ -355874,7 +356056,7 @@ var require_lib13 = __commonJS({
   "../@aws-cdk/cdk-explorer/lib/index.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.createLspHandlers = exports2.startServer = exports2.startLspServer = exports2.readAssembly = exports2.VERSION = void 0;
+    exports2.createLspHandlers = exports2.startServer = exports2.cdkLspManifest = exports2.startLspServer = exports2.readAssembly = exports2.VERSION = void 0;
     exports2.VERSION = "0.0.0";
     var assembly_reader_1 = (init_assembly_reader(), __toCommonJS(assembly_reader_exports));
     Object.defineProperty(exports2, "readAssembly", { enumerable: true, get: /* @__PURE__ */ __name(function() {
@@ -355884,6 +356066,10 @@ var require_lib13 = __commonJS({
     Object.defineProperty(exports2, "startLspServer", { enumerable: true, get: /* @__PURE__ */ __name(function() {
       return main_1.startLspServer;
     }, "get") });
+    var features_1 = (init_features(), __toCommonJS(features_exports));
+    Object.defineProperty(exports2, "cdkLspManifest", { enumerable: true, get: /* @__PURE__ */ __name(function() {
+      return features_1.cdkLspManifest;
+    }, "get") });
     var server_1 = (init_server(), __toCommonJS(server_exports));
     Object.defineProperty(exports2, "startServer", { enumerable: true, get: /* @__PURE__ */ __name(function() {
       return server_1.startServer;
@@ -355895,8 +356081,12 @@ var require_lib13 = __commonJS({
 });
 
 // lib/commands/lsp.ts
-async function lsp() {
-  (0, import_cdk_explorer.startLspServer)();
+async function lsp(options = {}) {
+  if (options.features) {
+    process3.stdout.write(JSON.stringify((0, import_cdk_explorer.cdkLspManifest)(versionNumber2())) + "\n");
+    return 0;
+  }
+  (0, import_cdk_explorer.startLspServer)(versionNumber2());
   await new Promise((resolve16) => {
     const done = /* @__PURE__ */ __name(() => resolve16(), "done");
     process3.stdin.once("end", done);
@@ -355910,6 +356100,7 @@ var init_lsp = __esm({
     "use strict";
     process3 = __toESM(require("process"));
     import_cdk_explorer = __toESM(require_lib13());
+    init_version();
     __name(lsp, "lsp");
   }
 });
@@ -356236,7 +356427,7 @@ async function exec4(args, synthesizer) {
         });
       case "lsp":
         ioHost.currentAction = "lsp";
-        return lsp();
+        return lsp({ features: argv.features });
       case "ls":
       case "list":
         ioHost.currentAction = "list";