@fern-api/fern-api-dev 3.44.0 → 3.44.1

package/cli.cjs

@@ -31948,14 +31948,14 @@ var require_urlencoded = __commonJS({
       }
       return output2;
     }
-    function strictlySplitByteSequence(buf, cp11) {
+    function strictlySplitByteSequence(buf, cp10) {
       const list14 = [];
       let last4 = 0;
-      let i11 = buf.indexOf(cp11);
+      let i11 = buf.indexOf(cp10);
       while (i11 >= 0) {
         list14.push(buf.slice(last4, i11));
         last4 = i11 + 1;
-        i11 = buf.indexOf(cp11, last4);
+        i11 = buf.indexOf(cp10, last4);
       }
       if (last4 !== buf.length) {
         list14.push(buf.slice(last4));
@@ -35853,7 +35853,7 @@ var require_base64 = __commonJS({
       var cb_btou = function(cccc) {
         switch (cccc.length) {
           case 4:
-            var cp11 = (7 & cccc.charCodeAt(0)) << 18 | (63 & cccc.charCodeAt(1)) << 12 | (63 & cccc.charCodeAt(2)) << 6 | 63 & cccc.charCodeAt(3), offset2 = cp11 - 65536;
+            var cp10 = (7 & cccc.charCodeAt(0)) << 18 | (63 & cccc.charCodeAt(1)) << 12 | (63 & cccc.charCodeAt(2)) << 6 | 63 & cccc.charCodeAt(3), offset2 = cp10 - 65536;
             return _fromCC2((offset2 >>> 10) + 55296) + _fromCC2((offset2 & 1023) + 56320);
           case 3:
             return _fromCC2((15 & cccc.charCodeAt(0)) << 12 | (63 & cccc.charCodeAt(1)) << 6 | 63 & cccc.charCodeAt(2));
@@ -157604,12 +157604,12 @@ var require_code3 = __commonJS({
       function isLineTerminator(ch3) {
         return ch3 === 10 || ch3 === 13 || ch3 === 8232 || ch3 === 8233;
       }
-      function fromCodePoint2(cp11) {
-        if (cp11 <= 65535) {
-          return String.fromCharCode(cp11);
+      function fromCodePoint2(cp10) {
+        if (cp10 <= 65535) {
+          return String.fromCharCode(cp10);
         }
-        var cu1 = String.fromCharCode(Math.floor((cp11 - 65536) / 1024) + 55296);
-        var cu22 = String.fromCharCode((cp11 - 65536) % 1024 + 56320);
+        var cu1 = String.fromCharCode(Math.floor((cp10 - 65536) / 1024) + 55296);
+        var cu22 = String.fromCharCode((cp10 - 65536) % 1024 + 56320);
         return cu1 + cu22;
       }
       IDENTIFIER_START = new Array(128);
@@ -162201,8 +162201,8 @@ var require_esprima = __commonJS({
                 return result;
               };
               JSXParser2.prototype.lexJSX = function() {
-                var cp11 = this.scanner.source.charCodeAt(this.scanner.index);
-                if (cp11 === 60 || cp11 === 62 || cp11 === 47 || cp11 === 58 || cp11 === 61 || cp11 === 123 || cp11 === 125) {
+                var cp10 = this.scanner.source.charCodeAt(this.scanner.index);
+                if (cp10 === 60 || cp10 === 62 || cp10 === 47 || cp10 === 58 || cp10 === 61 || cp10 === 123 || cp10 === 125) {
                   var value = this.scanner.source[this.scanner.index++];
                   return {
                     type: 7,
@@ -162213,7 +162213,7 @@ var require_esprima = __commonJS({
                     end: this.scanner.index
                   };
                 }
-                if (cp11 === 34 || cp11 === 39) {
+                if (cp10 === 34 || cp10 === 39) {
                   var start2 = this.scanner.index;
                   var quote2 = this.scanner.source[this.scanner.index++];
                   var str3 = "";
@@ -162236,7 +162236,7 @@ var require_esprima = __commonJS({
                     end: this.scanner.index
                   };
                 }
-                if (cp11 === 46) {
+                if (cp10 === 46) {
                   var n1 = this.scanner.source.charCodeAt(this.scanner.index + 1);
                   var n23 = this.scanner.source.charCodeAt(this.scanner.index + 2);
                   var value = n1 === 46 && n23 === 46 ? "..." : ".";
@@ -162251,7 +162251,7 @@ var require_esprima = __commonJS({
                     end: this.scanner.index
                   };
                 }
-                if (cp11 === 96) {
+                if (cp10 === 96) {
                   return {
                     type: 10,
                     value: "",
@@ -162261,7 +162261,7 @@ var require_esprima = __commonJS({
                     end: this.scanner.index
                   };
                 }
-                if (character_1.Character.isIdentifierStart(cp11) && cp11 !== 92) {
+                if (character_1.Character.isIdentifierStart(cp10) && cp10 !== 92) {
                   var start2 = this.scanner.index;
                   ++this.scanner.index;
                   while (!this.scanner.eof()) {
@@ -162591,33 +162591,33 @@ var require_esprima = __commonJS({
             };
             exports3.Character = {
               /* tslint:disable:no-bitwise */
-              fromCodePoint: function(cp11) {
-                return cp11 < 65536 ? String.fromCharCode(cp11) : String.fromCharCode(55296 + (cp11 - 65536 >> 10)) + String.fromCharCode(56320 + (cp11 - 65536 & 1023));
+              fromCodePoint: function(cp10) {
+                return cp10 < 65536 ? String.fromCharCode(cp10) : String.fromCharCode(55296 + (cp10 - 65536 >> 10)) + String.fromCharCode(56320 + (cp10 - 65536 & 1023));
               },
               // https://tc39.github.io/ecma262/#sec-white-space
-              isWhiteSpace: function(cp11) {
-                return cp11 === 32 || cp11 === 9 || cp11 === 11 || cp11 === 12 || cp11 === 160 || cp11 >= 5760 && [5760, 8192, 8193, 8194, 8195, 8196, 8197, 8198, 8199, 8200, 8201, 8202, 8239, 8287, 12288, 65279].indexOf(cp11) >= 0;
+              isWhiteSpace: function(cp10) {
+                return cp10 === 32 || cp10 === 9 || cp10 === 11 || cp10 === 12 || cp10 === 160 || cp10 >= 5760 && [5760, 8192, 8193, 8194, 8195, 8196, 8197, 8198, 8199, 8200, 8201, 8202, 8239, 8287, 12288, 65279].indexOf(cp10) >= 0;
               },
               // https://tc39.github.io/ecma262/#sec-line-terminators
-              isLineTerminator: function(cp11) {
-                return cp11 === 10 || cp11 === 13 || cp11 === 8232 || cp11 === 8233;
+              isLineTerminator: function(cp10) {
+                return cp10 === 10 || cp10 === 13 || cp10 === 8232 || cp10 === 8233;
               },
               // https://tc39.github.io/ecma262/#sec-names-and-keywords
-              isIdentifierStart: function(cp11) {
-                return cp11 === 36 || cp11 === 95 || cp11 >= 65 && cp11 <= 90 || cp11 >= 97 && cp11 <= 122 || cp11 === 92 || cp11 >= 128 && Regex.NonAsciiIdentifierStart.test(exports3.Character.fromCodePoint(cp11));
+              isIdentifierStart: function(cp10) {
+                return cp10 === 36 || cp10 === 95 || cp10 >= 65 && cp10 <= 90 || cp10 >= 97 && cp10 <= 122 || cp10 === 92 || cp10 >= 128 && Regex.NonAsciiIdentifierStart.test(exports3.Character.fromCodePoint(cp10));
               },
-              isIdentifierPart: function(cp11) {
-                return cp11 === 36 || cp11 === 95 || cp11 >= 65 && cp11 <= 90 || cp11 >= 97 && cp11 <= 122 || cp11 >= 48 && cp11 <= 57 || cp11 === 92 || cp11 >= 128 && Regex.NonAsciiIdentifierPart.test(exports3.Character.fromCodePoint(cp11));
+              isIdentifierPart: function(cp10) {
+                return cp10 === 36 || cp10 === 95 || cp10 >= 65 && cp10 <= 90 || cp10 >= 97 && cp10 <= 122 || cp10 >= 48 && cp10 <= 57 || cp10 === 92 || cp10 >= 128 && Regex.NonAsciiIdentifierPart.test(exports3.Character.fromCodePoint(cp10));
               },
               // https://tc39.github.io/ecma262/#sec-literals-numeric-literals
-              isDecimalDigit: function(cp11) {
-                return cp11 >= 48 && cp11 <= 57;
+              isDecimalDigit: function(cp10) {
+                return cp10 >= 48 && cp10 <= 57;
               },
-              isHexDigit: function(cp11) {
-                return cp11 >= 48 && cp11 <= 57 || cp11 >= 65 && cp11 <= 70 || cp11 >= 97 && cp11 <= 102;
+              isHexDigit: function(cp10) {
+                return cp10 >= 48 && cp10 <= 57 || cp10 >= 65 && cp10 <= 70 || cp10 >= 97 && cp10 <= 102;
               },
-              isOctalDigit: function(cp11) {
-                return cp11 >= 48 && cp11 <= 55;
+              isOctalDigit: function(cp10) {
+                return cp10 >= 48 && cp10 <= 55;
               }
             };
           },
@@ -166691,15 +166691,15 @@ var require_esprima = __commonJS({
                 }
               };
               Scanner2.prototype.codePointAt = function(i11) {
-                var cp11 = this.source.charCodeAt(i11);
-                if (cp11 >= 55296 && cp11 <= 56319) {
+                var cp10 = this.source.charCodeAt(i11);
+                if (cp10 >= 55296 && cp10 <= 56319) {
                   var second = this.source.charCodeAt(i11 + 1);
                   if (second >= 56320 && second <= 57343) {
-                    var first3 = cp11;
-                    cp11 = (first3 - 55296) * 1024 + second - 56320 + 65536;
+                    var first3 = cp10;
+                    cp10 = (first3 - 55296) * 1024 + second - 56320 + 65536;
                   }
                 }
-                return cp11;
+                return cp10;
               };
               Scanner2.prototype.scanHexEscape = function(prefix2) {
                 var len = prefix2 === "u" ? 4 : 2;
@@ -166751,11 +166751,11 @@ var require_esprima = __commonJS({
                 return this.source.slice(start2, this.index);
               };
               Scanner2.prototype.getComplexIdentifier = function() {
-                var cp11 = this.codePointAt(this.index);
-                var id2 = character_1.Character.fromCodePoint(cp11);
+                var cp10 = this.codePointAt(this.index);
+                var id2 = character_1.Character.fromCodePoint(cp10);
                 this.index += id2.length;
                 var ch2;
-                if (cp11 === 92) {
+                if (cp10 === 92) {
                   if (this.source.charCodeAt(this.index) !== 117) {
                     this.throwUnexpectedToken();
                   }
@@ -166772,14 +166772,14 @@ var require_esprima = __commonJS({
                   id2 = ch2;
                 }
                 while (!this.eof()) {
-                  cp11 = this.codePointAt(this.index);
-                  if (!character_1.Character.isIdentifierPart(cp11)) {
+                  cp10 = this.codePointAt(this.index);
+                  if (!character_1.Character.isIdentifierPart(cp10)) {
                     break;
                   }
-                  ch2 = character_1.Character.fromCodePoint(cp11);
+                  ch2 = character_1.Character.fromCodePoint(cp10);
                   id2 += ch2;
                   this.index += ch2.length;
-                  if (cp11 === 92) {
+                  if (cp10 === 92) {
                     id2 = id2.substr(0, id2.length - 1);
                     if (this.source.charCodeAt(this.index) !== 117) {
                       this.throwUnexpectedToken();
@@ -167405,29 +167405,29 @@ var require_esprima = __commonJS({
                     end: this.index
                   };
                 }
-                var cp11 = this.source.charCodeAt(this.index);
-                if (character_1.Character.isIdentifierStart(cp11)) {
+                var cp10 = this.source.charCodeAt(this.index);
+                if (character_1.Character.isIdentifierStart(cp10)) {
                   return this.scanIdentifier();
                 }
-                if (cp11 === 40 || cp11 === 41 || cp11 === 59) {
+                if (cp10 === 40 || cp10 === 41 || cp10 === 59) {
                   return this.scanPunctuator();
                 }
-                if (cp11 === 39 || cp11 === 34) {
+                if (cp10 === 39 || cp10 === 34) {
                   return this.scanStringLiteral();
                 }
-                if (cp11 === 46) {
+                if (cp10 === 46) {
                   if (character_1.Character.isDecimalDigit(this.source.charCodeAt(this.index + 1))) {
                     return this.scanNumericLiteral();
                   }
                   return this.scanPunctuator();
                 }
-                if (character_1.Character.isDecimalDigit(cp11)) {
+                if (character_1.Character.isDecimalDigit(cp10)) {
                   return this.scanNumericLiteral();
                 }
-                if (cp11 === 96 || cp11 === 125 && this.curlyStack[this.curlyStack.length - 1] === "${") {
+                if (cp10 === 96 || cp10 === 125 && this.curlyStack[this.curlyStack.length - 1] === "${") {
                   return this.scanTemplate();
                 }
-                if (cp11 >= 55296 && cp11 < 57343) {
+                if (cp10 >= 55296 && cp10 < 57343) {
                   if (character_1.Character.isIdentifierStart(this.codePointAt(this.index))) {
                     return this.scanIdentifier();
                   }
@@ -176369,19 +176369,19 @@ var require_identifier = __commonJS({
     function isIdentifierName(name2) {
       let isFirst = true;
       for (let i11 = 0; i11 < name2.length; i11++) {
-        let cp11 = name2.charCodeAt(i11);
-        if ((cp11 & 64512) === 55296 && i11 + 1 < name2.length) {
+        let cp10 = name2.charCodeAt(i11);
+        if ((cp10 & 64512) === 55296 && i11 + 1 < name2.length) {
           const trail2 = name2.charCodeAt(++i11);
           if ((trail2 & 64512) === 56320) {
-            cp11 = 65536 + ((cp11 & 1023) << 10) + (trail2 & 1023);
+            cp10 = 65536 + ((cp10 & 1023) << 10) + (trail2 & 1023);
           }
         }
         if (isFirst) {
           isFirst = false;
-          if (!isIdentifierStart2(cp11)) {
+          if (!isIdentifierStart2(cp10)) {
             return false;
           }
-        } else if (!isIdentifierChar2(cp11)) {
+        } else if (!isIdentifierChar2(cp10)) {
           return false;
         }
       }
@@ -225417,19 +225417,19 @@ var require_enoent = __commonJS({
         spawnargs: original.args
       });
     }
-    function hookChildProcess(cp11, parsed) {
+    function hookChildProcess(cp10, parsed) {
       if (!isWin) {
         return;
       }
-      const originalEmit = cp11.emit;
-      cp11.emit = function(name2, arg1) {
+      const originalEmit = cp10.emit;
+      cp10.emit = function(name2, arg1) {
         if (name2 === "exit") {
           const err = verifyENOENT(arg1, parsed);
           if (err) {
-            return originalEmit.call(cp11, "error", err);
+            return originalEmit.call(cp10, "error", err);
           }
         }
-        return originalEmit.apply(cp11, arguments);
+        return originalEmit.apply(cp10, arguments);
       };
     }
     function verifyENOENT(status, parsed) {
@@ -225457,18 +225457,18 @@ var require_enoent = __commonJS({
 var require_cross_spawn = __commonJS({
   "../../../node_modules/.pnpm/cross-spawn@7.0.5/node_modules/cross-spawn/index.js"(exports2, module2) {
     "use strict";
-    var cp11 = require("child_process");
+    var cp10 = require("child_process");
     var parse12 = require_parse5();
     var enoent = require_enoent();
     function spawn5(command2, args, options2) {
       const parsed = parse12(command2, args, options2);
-      const spawned = cp11.spawn(parsed.command, parsed.args, parsed.options);
+      const spawned = cp10.spawn(parsed.command, parsed.args, parsed.options);
       enoent.hookChildProcess(spawned, parsed);
       return spawned;
     }
     function spawnSync5(command2, args, options2) {
       const parsed = parse12(command2, args, options2);
-      const result = cp11.spawnSync(parsed.command, parsed.args, parsed.options);
+      const result = cp10.spawnSync(parsed.command, parsed.args, parsed.options);
       result.error = result.error || enoent.verifyENOENTSync(result.status, parsed);
       return result;
     }
@@ -235165,12 +235165,12 @@ var require_send = __commonJS({
         path70 = resolve10(path70);
       }
       if (containsDotFile(parts)) {
-        var access5 = this._dotfiles;
-        if (access5 === void 0) {
-          access5 = parts[parts.length - 1][0] === "." ? this._hidden ? "allow" : "ignore" : "allow";
+        var access4 = this._dotfiles;
+        if (access4 === void 0) {
+          access4 = parts[parts.length - 1][0] === "." ? this._hidden ? "allow" : "ignore" : "allow";
         }
-        debug7('%s dotfile "%s"', access5, path70);
-        switch (access5) {
+        debug7('%s dotfile "%s"', access4, path70);
+        switch (access4) {
           case "allow":
             break;
           case "deny":
@@ -1283612,8 +1283612,8 @@ var require_formdata_parser = __commonJS({
         return false;
       }
       for (let i11 = 0; i11 < length; ++i11) {
-        const cp11 = boundary.charCodeAt(i11);
-        if (!(cp11 >= 48 && cp11 <= 57 || cp11 >= 65 && cp11 <= 90 || cp11 >= 97 && cp11 <= 122 || cp11 === 39 || cp11 === 45 || cp11 === 95)) {
+        const cp10 = boundary.charCodeAt(i11);
+        if (!(cp10 >= 48 && cp10 <= 57 || cp10 >= 65 && cp10 <= 90 || cp10 >= 97 && cp10 <= 122 || cp10 === 39 || cp10 === 45 || cp10 === 95)) {
           return false;
         }
       }
@@ -1420006,7 +1420006,7 @@ var AccessTokenPosthogManager = class {
         properties: {
           ...event,
           ...event.properties,
-          version: "3.44.0",
+          version: "3.44.1",
           usingAccessToken: true
         }
       });
@@ -1420105,7 +1420105,7 @@ var UserPosthogManager = class {
       distinctId: this.userId ?? await this.getPersistedDistinctId(),
       event: "CLI",
       properties: {
-        version: "3.44.0",
+        version: "3.44.1",
         ...event,
         ...event.properties,
         usingAccessToken: false,
@@ -1449437,20 +1449437,20 @@ var SEQUENCES = {
   PUBLIC: "public",
   SYSTEM: "system"
 };
-function isSurrogate(cp11) {
-  return cp11 >= 55296 && cp11 <= 57343;
+function isSurrogate(cp10) {
+  return cp10 >= 55296 && cp10 <= 57343;
 }
-function isSurrogatePair(cp11) {
-  return cp11 >= 56320 && cp11 <= 57343;
+function isSurrogatePair(cp10) {
+  return cp10 >= 56320 && cp10 <= 57343;
 }
 function getSurrogatePairCodePoint(cp1, cp22) {
   return (cp1 - 55296) * 1024 + 9216 + cp22;
 }
-function isControlCodePoint(cp11) {
-  return cp11 !== 32 && cp11 !== 10 && cp11 !== 13 && cp11 !== 9 && cp11 !== 12 && cp11 >= 1 && cp11 <= 31 || cp11 >= 127 && cp11 <= 159;
+function isControlCodePoint(cp10) {
+  return cp10 !== 32 && cp10 !== 10 && cp10 !== 13 && cp10 !== 9 && cp10 !== 12 && cp10 >= 1 && cp10 <= 31 || cp10 >= 127 && cp10 <= 159;
 }
-function isUndefinedCodePoint(cp11) {
-  return cp11 >= 64976 && cp11 <= 65007 || UNDEFINED_CODE_POINTS.has(cp11);
+function isUndefinedCodePoint(cp10) {
+  return cp10 >= 64976 && cp10 <= 65007 || UNDEFINED_CODE_POINTS.has(cp10);
 }
 
 // ../../../node_modules/.pnpm/parse5@7.3.0/node_modules/parse5/dist/common/error-codes.js
@@ -1449568,20 +1449568,20 @@ var Preprocessor = class {
     this.gapStack.push(this.lastGapPos);
     this.lastGapPos = this.pos;
   }
-  _processSurrogate(cp11) {
+  _processSurrogate(cp10) {
     if (this.pos !== this.html.length - 1) {
       const nextCp = this.html.charCodeAt(this.pos + 1);
       if (isSurrogatePair(nextCp)) {
         this.pos++;
         this._addGap();
-        return getSurrogatePairCodePoint(cp11, nextCp);
+        return getSurrogatePairCodePoint(cp10, nextCp);
       }
     } else if (!this.lastChunkWritten) {
       this.endOfChunkHit = true;
       return CODE_POINTS.EOF;
     }
     this._err(ERR.surrogateInInputStream);
-    return cp11;
+    return cp10;
   }
   willDropParsedChunk() {
     return this.pos > this.bufferWaterline;
@@ -1449618,8 +1449618,8 @@ var Preprocessor = class {
       return this.html.startsWith(pattern, this.pos);
     }
     for (let i11 = 0; i11 < pattern.length; i11++) {
-      const cp11 = this.html.charCodeAt(this.pos + i11) | 32;
-      if (cp11 !== pattern.charCodeAt(i11)) {
+      const cp10 = this.html.charCodeAt(this.pos + i11) | 32;
+      if (cp10 !== pattern.charCodeAt(i11)) {
         return false;
       }
     }
@@ -1449645,13 +1449645,13 @@ var Preprocessor = class {
       this.endOfChunkHit = !this.lastChunkWritten;
       return CODE_POINTS.EOF;
     }
-    let cp11 = this.html.charCodeAt(this.pos);
-    if (cp11 === CODE_POINTS.CARRIAGE_RETURN) {
+    let cp10 = this.html.charCodeAt(this.pos);
+    if (cp10 === CODE_POINTS.CARRIAGE_RETURN) {
       this.isEol = true;
       this.skipNextNewLine = true;
       return CODE_POINTS.LINE_FEED;
     }
-    if (cp11 === CODE_POINTS.LINE_FEED) {
+    if (cp10 === CODE_POINTS.LINE_FEED) {
       this.isEol = true;
       if (this.skipNextNewLine) {
         this.line--;
@@ -1449661,19 +1449661,19 @@ var Preprocessor = class {
       }
     }
     this.skipNextNewLine = false;
-    if (isSurrogate(cp11)) {
-      cp11 = this._processSurrogate(cp11);
+    if (isSurrogate(cp10)) {
+      cp10 = this._processSurrogate(cp10);
     }
-    const isCommonValidRange = this.handler.onParseError === null || cp11 > 31 && cp11 < 127 || cp11 === CODE_POINTS.LINE_FEED || cp11 === CODE_POINTS.CARRIAGE_RETURN || cp11 > 159 && cp11 < 64976;
+    const isCommonValidRange = this.handler.onParseError === null || cp10 > 31 && cp10 < 127 || cp10 === CODE_POINTS.LINE_FEED || cp10 === CODE_POINTS.CARRIAGE_RETURN || cp10 > 159 && cp10 < 64976;
     if (!isCommonValidRange) {
-      this._checkForProblematicCharacters(cp11);
+      this._checkForProblematicCharacters(cp10);
     }
-    return cp11;
+    return cp10;
   }
-  _checkForProblematicCharacters(cp11) {
-    if (isControlCodePoint(cp11)) {
+  _checkForProblematicCharacters(cp10) {
+    if (isControlCodePoint(cp10)) {
       this._err(ERR.controlCharacterInInputStream);
-    } else if (isUndefinedCodePoint(cp11)) {
+    } else if (isUndefinedCodePoint(cp10)) {
       this._err(ERR.noncharacterInInputStream);
     }
   }
@@ -1450701,29 +1450701,29 @@ var TokenizerMode = {
   PLAINTEXT: State2.PLAINTEXT,
   CDATA_SECTION: State2.CDATA_SECTION
 };
-function isAsciiDigit(cp11) {
-  return cp11 >= CODE_POINTS.DIGIT_0 && cp11 <= CODE_POINTS.DIGIT_9;
+function isAsciiDigit(cp10) {
+  return cp10 >= CODE_POINTS.DIGIT_0 && cp10 <= CODE_POINTS.DIGIT_9;
 }
-function isAsciiUpper(cp11) {
-  return cp11 >= CODE_POINTS.LATIN_CAPITAL_A && cp11 <= CODE_POINTS.LATIN_CAPITAL_Z;
+function isAsciiUpper(cp10) {
+  return cp10 >= CODE_POINTS.LATIN_CAPITAL_A && cp10 <= CODE_POINTS.LATIN_CAPITAL_Z;
 }
-function isAsciiLower(cp11) {
-  return cp11 >= CODE_POINTS.LATIN_SMALL_A && cp11 <= CODE_POINTS.LATIN_SMALL_Z;
+function isAsciiLower(cp10) {
+  return cp10 >= CODE_POINTS.LATIN_SMALL_A && cp10 <= CODE_POINTS.LATIN_SMALL_Z;
 }
-function isAsciiLetter(cp11) {
-  return isAsciiLower(cp11) || isAsciiUpper(cp11);
+function isAsciiLetter(cp10) {
+  return isAsciiLower(cp10) || isAsciiUpper(cp10);
 }
-function isAsciiAlphaNumeric2(cp11) {
-  return isAsciiLetter(cp11) || isAsciiDigit(cp11);
+function isAsciiAlphaNumeric2(cp10) {
+  return isAsciiLetter(cp10) || isAsciiDigit(cp10);
 }
-function toAsciiLower(cp11) {
-  return cp11 + 32;
+function toAsciiLower(cp10) {
+  return cp10 + 32;
 }
-function isWhitespace2(cp11) {
-  return cp11 === CODE_POINTS.SPACE || cp11 === CODE_POINTS.LINE_FEED || cp11 === CODE_POINTS.TABULATION || cp11 === CODE_POINTS.FORM_FEED;
+function isWhitespace2(cp10) {
+  return cp10 === CODE_POINTS.SPACE || cp10 === CODE_POINTS.LINE_FEED || cp10 === CODE_POINTS.TABULATION || cp10 === CODE_POINTS.FORM_FEED;
 }
-function isScriptDataDoubleEscapeSequenceEnd(cp11) {
-  return isWhitespace2(cp11) || cp11 === CODE_POINTS.SOLIDUS || cp11 === CODE_POINTS.GREATER_THAN_SIGN;
+function isScriptDataDoubleEscapeSequenceEnd(cp10) {
+  return isWhitespace2(cp10) || cp10 === CODE_POINTS.SOLIDUS || cp10 === CODE_POINTS.GREATER_THAN_SIGN;
 }
 function getErrorForNumericCharacterReference(code5) {
   if (code5 === CODE_POINTS.NULL) {
@@ -1450757,9 +1450757,9 @@ var Tokenizer = class {
     this.currentAttr = { name: "", value: "" };
     this.preprocessor = new Preprocessor(handler3);
     this.currentLocation = this.getCurrentLocation(-1);
-    this.entityDecoder = new EntityDecoder(htmlDecodeTree, (cp11, consumed) => {
+    this.entityDecoder = new EntityDecoder(htmlDecodeTree, (cp10, consumed) => {
       this.preprocessor.pos = this.entityStartPos + consumed - 1;
-      this._flushCodePointConsumedAsCharacterReference(cp11);
+      this._flushCodePointConsumedAsCharacterReference(cp10);
     }, handler3.onParseError ? {
       missingSemicolonAfterCharacterReference: () => {
         this._err(ERR.missingSemicolonAfterCharacterReference, 1);
@@ -1450799,9 +1450799,9 @@ var Tokenizer = class {
     this.inLoop = true;
     while (this.active && !this.paused) {
       this.consumedAfterSnapshot = 0;
-      const cp11 = this._consume();
+      const cp10 = this._consume();
       if (!this._ensureHibernation()) {
-        this._callState(cp11);
+        this._callState(cp10);
       }
     }
     this.inLoop = false;
@@ -1451036,9 +1451036,9 @@ var Tokenizer = class {
     }
     this._createCharacterToken(type8, ch2);
   }
-  _emitCodePoint(cp11) {
-    const type8 = isWhitespace2(cp11) ? TokenType3.WHITESPACE_CHARACTER : cp11 === CODE_POINTS.NULL ? TokenType3.NULL_CHARACTER : TokenType3.CHARACTER;
-    this._appendCharToCurrentCharacterToken(type8, String.fromCodePoint(cp11));
+  _emitCodePoint(cp10) {
+    const type8 = isWhitespace2(cp10) ? TokenType3.WHITESPACE_CHARACTER : cp10 === CODE_POINTS.NULL ? TokenType3.NULL_CHARACTER : TokenType3.CHARACTER;
+    this._appendCharToCurrentCharacterToken(type8, String.fromCodePoint(cp10));
   }
   //NOTE: used when we emit characters explicitly.
   //This is always for non-whitespace and non-null characters, which allows us to avoid additional checks.
@@ -1451055,298 +1451055,298 @@ var Tokenizer = class {
   _isCharacterReferenceInAttribute() {
     return this.returnState === State2.ATTRIBUTE_VALUE_DOUBLE_QUOTED || this.returnState === State2.ATTRIBUTE_VALUE_SINGLE_QUOTED || this.returnState === State2.ATTRIBUTE_VALUE_UNQUOTED;
   }
-  _flushCodePointConsumedAsCharacterReference(cp11) {
+  _flushCodePointConsumedAsCharacterReference(cp10) {
     if (this._isCharacterReferenceInAttribute()) {
-      this.currentAttr.value += String.fromCodePoint(cp11);
+      this.currentAttr.value += String.fromCodePoint(cp10);
     } else {
-      this._emitCodePoint(cp11);
+      this._emitCodePoint(cp10);
     }
   }
   // Calling states this way turns out to be much faster than any other approach.
-  _callState(cp11) {
+  _callState(cp10) {
     switch (this.state) {
       case State2.DATA: {
-        this._stateData(cp11);
+        this._stateData(cp10);
         break;
       }
       case State2.RCDATA: {
-        this._stateRcdata(cp11);
+        this._stateRcdata(cp10);
         break;
       }
       case State2.RAWTEXT: {
-        this._stateRawtext(cp11);
+        this._stateRawtext(cp10);
         break;
       }
       case State2.SCRIPT_DATA: {
-        this._stateScriptData(cp11);
+        this._stateScriptData(cp10);
         break;
       }
       case State2.PLAINTEXT: {
-        this._statePlaintext(cp11);
+        this._statePlaintext(cp10);
         break;
       }
       case State2.TAG_OPEN: {
-        this._stateTagOpen(cp11);
+        this._stateTagOpen(cp10);
         break;
       }
       case State2.END_TAG_OPEN: {
-        this._stateEndTagOpen(cp11);
+        this._stateEndTagOpen(cp10);
         break;
       }
       case State2.TAG_NAME: {
-        this._stateTagName(cp11);
+        this._stateTagName(cp10);
         break;
       }
       case State2.RCDATA_LESS_THAN_SIGN: {
-        this._stateRcdataLessThanSign(cp11);
+        this._stateRcdataLessThanSign(cp10);
         break;
       }
       case State2.RCDATA_END_TAG_OPEN: {
-        this._stateRcdataEndTagOpen(cp11);
+        this._stateRcdataEndTagOpen(cp10);
         break;
       }
       case State2.RCDATA_END_TAG_NAME: {
-        this._stateRcdataEndTagName(cp11);
+        this._stateRcdataEndTagName(cp10);
         break;
       }
       case State2.RAWTEXT_LESS_THAN_SIGN: {
-        this._stateRawtextLessThanSign(cp11);
+        this._stateRawtextLessThanSign(cp10);
         break;
       }
       case State2.RAWTEXT_END_TAG_OPEN: {
-        this._stateRawtextEndTagOpen(cp11);
+        this._stateRawtextEndTagOpen(cp10);
         break;
       }
       case State2.RAWTEXT_END_TAG_NAME: {
-        this._stateRawtextEndTagName(cp11);
+        this._stateRawtextEndTagName(cp10);
         break;
       }
       case State2.SCRIPT_DATA_LESS_THAN_SIGN: {
-        this._stateScriptDataLessThanSign(cp11);
+        this._stateScriptDataLessThanSign(cp10);
         break;
       }
       case State2.SCRIPT_DATA_END_TAG_OPEN: {
-        this._stateScriptDataEndTagOpen(cp11);
+        this._stateScriptDataEndTagOpen(cp10);
         break;
       }
       case State2.SCRIPT_DATA_END_TAG_NAME: {
-        this._stateScriptDataEndTagName(cp11);
+        this._stateScriptDataEndTagName(cp10);
         break;
       }
       case State2.SCRIPT_DATA_ESCAPE_START: {
-        this._stateScriptDataEscapeStart(cp11);
+        this._stateScriptDataEscapeStart(cp10);
         break;
       }
       case State2.SCRIPT_DATA_ESCAPE_START_DASH: {
-        this._stateScriptDataEscapeStartDash(cp11);
+        this._stateScriptDataEscapeStartDash(cp10);
         break;
       }
       case State2.SCRIPT_DATA_ESCAPED: {
-        this._stateScriptDataEscaped(cp11);
+        this._stateScriptDataEscaped(cp10);
         break;
       }
       case State2.SCRIPT_DATA_ESCAPED_DASH: {
-        this._stateScriptDataEscapedDash(cp11);
+        this._stateScriptDataEscapedDash(cp10);
         break;
       }
       case State2.SCRIPT_DATA_ESCAPED_DASH_DASH: {
-        this._stateScriptDataEscapedDashDash(cp11);
+        this._stateScriptDataEscapedDashDash(cp10);
         break;
       }
       case State2.SCRIPT_DATA_ESCAPED_LESS_THAN_SIGN: {
-        this._stateScriptDataEscapedLessThanSign(cp11);
+        this._stateScriptDataEscapedLessThanSign(cp10);
         break;
       }
       case State2.SCRIPT_DATA_ESCAPED_END_TAG_OPEN: {
-        this._stateScriptDataEscapedEndTagOpen(cp11);
+        this._stateScriptDataEscapedEndTagOpen(cp10);
         break;
       }
       case State2.SCRIPT_DATA_ESCAPED_END_TAG_NAME: {
-        this._stateScriptDataEscapedEndTagName(cp11);
+        this._stateScriptDataEscapedEndTagName(cp10);
         break;
       }
       case State2.SCRIPT_DATA_DOUBLE_ESCAPE_START: {
-        this._stateScriptDataDoubleEscapeStart(cp11);
+        this._stateScriptDataDoubleEscapeStart(cp10);
         break;
       }
       case State2.SCRIPT_DATA_DOUBLE_ESCAPED: {
-        this._stateScriptDataDoubleEscaped(cp11);
+        this._stateScriptDataDoubleEscaped(cp10);
         break;
       }
       case State2.SCRIPT_DATA_DOUBLE_ESCAPED_DASH: {
-        this._stateScriptDataDoubleEscapedDash(cp11);
+        this._stateScriptDataDoubleEscapedDash(cp10);
         break;
       }
       case State2.SCRIPT_DATA_DOUBLE_ESCAPED_DASH_DASH: {
-        this._stateScriptDataDoubleEscapedDashDash(cp11);
+        this._stateScriptDataDoubleEscapedDashDash(cp10);
         break;
       }
       case State2.SCRIPT_DATA_DOUBLE_ESCAPED_LESS_THAN_SIGN: {
-        this._stateScriptDataDoubleEscapedLessThanSign(cp11);
+        this._stateScriptDataDoubleEscapedLessThanSign(cp10);
         break;
       }
       case State2.SCRIPT_DATA_DOUBLE_ESCAPE_END: {
-        this._stateScriptDataDoubleEscapeEnd(cp11);
+        this._stateScriptDataDoubleEscapeEnd(cp10);
         break;
       }
       case State2.BEFORE_ATTRIBUTE_NAME: {
-        this._stateBeforeAttributeName(cp11);
+        this._stateBeforeAttributeName(cp10);
         break;
       }
       case State2.ATTRIBUTE_NAME: {
-        this._stateAttributeName(cp11);
+        this._stateAttributeName(cp10);
         break;
       }
       case State2.AFTER_ATTRIBUTE_NAME: {
-        this._stateAfterAttributeName(cp11);
+        this._stateAfterAttributeName(cp10);
         break;
       }
       case State2.BEFORE_ATTRIBUTE_VALUE: {
-        this._stateBeforeAttributeValue(cp11);
+        this._stateBeforeAttributeValue(cp10);
         break;
       }
       case State2.ATTRIBUTE_VALUE_DOUBLE_QUOTED: {
-        this._stateAttributeValueDoubleQuoted(cp11);
+        this._stateAttributeValueDoubleQuoted(cp10);
         break;
       }
       case State2.ATTRIBUTE_VALUE_SINGLE_QUOTED: {
-        this._stateAttributeValueSingleQuoted(cp11);
+        this._stateAttributeValueSingleQuoted(cp10);
         break;
       }
       case State2.ATTRIBUTE_VALUE_UNQUOTED: {
-        this._stateAttributeValueUnquoted(cp11);
+        this._stateAttributeValueUnquoted(cp10);
         break;
       }
       case State2.AFTER_ATTRIBUTE_VALUE_QUOTED: {
-        this._stateAfterAttributeValueQuoted(cp11);
+        this._stateAfterAttributeValueQuoted(cp10);
         break;
       }
       case State2.SELF_CLOSING_START_TAG: {
-        this._stateSelfClosingStartTag(cp11);
+        this._stateSelfClosingStartTag(cp10);
         break;
       }
       case State2.BOGUS_COMMENT: {
-        this._stateBogusComment(cp11);
+        this._stateBogusComment(cp10);
         break;
       }
       case State2.MARKUP_DECLARATION_OPEN: {
-        this._stateMarkupDeclarationOpen(cp11);
+        this._stateMarkupDeclarationOpen(cp10);
         break;
       }
       case State2.COMMENT_START: {
-        this._stateCommentStart(cp11);
+        this._stateCommentStart(cp10);
         break;
       }
       case State2.COMMENT_START_DASH: {
-        this._stateCommentStartDash(cp11);
+        this._stateCommentStartDash(cp10);
         break;
       }
       case State2.COMMENT: {
-        this._stateComment(cp11);
+        this._stateComment(cp10);
         break;
       }
       case State2.COMMENT_LESS_THAN_SIGN: {
-        this._stateCommentLessThanSign(cp11);
+        this._stateCommentLessThanSign(cp10);
         break;
       }
       case State2.COMMENT_LESS_THAN_SIGN_BANG: {
-        this._stateCommentLessThanSignBang(cp11);
+        this._stateCommentLessThanSignBang(cp10);
         break;
       }
       case State2.COMMENT_LESS_THAN_SIGN_BANG_DASH: {
-        this._stateCommentLessThanSignBangDash(cp11);
+        this._stateCommentLessThanSignBangDash(cp10);
         break;
       }
       case State2.COMMENT_LESS_THAN_SIGN_BANG_DASH_DASH: {
-        this._stateCommentLessThanSignBangDashDash(cp11);
+        this._stateCommentLessThanSignBangDashDash(cp10);
         break;
       }
       case State2.COMMENT_END_DASH: {
-        this._stateCommentEndDash(cp11);
+        this._stateCommentEndDash(cp10);
         break;
       }
       case State2.COMMENT_END: {
-        this._stateCommentEnd(cp11);
+        this._stateCommentEnd(cp10);
         break;
       }
       case State2.COMMENT_END_BANG: {
-        this._stateCommentEndBang(cp11);
+        this._stateCommentEndBang(cp10);
         break;
       }
       case State2.DOCTYPE: {
-        this._stateDoctype(cp11);
+        this._stateDoctype(cp10);
         break;
       }
       case State2.BEFORE_DOCTYPE_NAME: {
-        this._stateBeforeDoctypeName(cp11);
+        this._stateBeforeDoctypeName(cp10);
         break;
       }
       case State2.DOCTYPE_NAME: {
-        this._stateDoctypeName(cp11);
+        this._stateDoctypeName(cp10);
         break;
       }
       case State2.AFTER_DOCTYPE_NAME: {
-        this._stateAfterDoctypeName(cp11);
+        this._stateAfterDoctypeName(cp10);
         break;
       }
       case State2.AFTER_DOCTYPE_PUBLIC_KEYWORD: {
-        this._stateAfterDoctypePublicKeyword(cp11);
+        this._stateAfterDoctypePublicKeyword(cp10);
         break;
       }
       case State2.BEFORE_DOCTYPE_PUBLIC_IDENTIFIER: {
-        this._stateBeforeDoctypePublicIdentifier(cp11);
+        this._stateBeforeDoctypePublicIdentifier(cp10);
         break;
       }
       case State2.DOCTYPE_PUBLIC_IDENTIFIER_DOUBLE_QUOTED: {
-        this._stateDoctypePublicIdentifierDoubleQuoted(cp11);
+        this._stateDoctypePublicIdentifierDoubleQuoted(cp10);
         break;
       }
       case State2.DOCTYPE_PUBLIC_IDENTIFIER_SINGLE_QUOTED: {
-        this._stateDoctypePublicIdentifierSingleQuoted(cp11);
+        this._stateDoctypePublicIdentifierSingleQuoted(cp10);
         break;
       }
       case State2.AFTER_DOCTYPE_PUBLIC_IDENTIFIER: {
-        this._stateAfterDoctypePublicIdentifier(cp11);
+        this._stateAfterDoctypePublicIdentifier(cp10);
         break;
       }
       case State2.BETWEEN_DOCTYPE_PUBLIC_AND_SYSTEM_IDENTIFIERS: {
-        this._stateBetweenDoctypePublicAndSystemIdentifiers(cp11);
+        this._stateBetweenDoctypePublicAndSystemIdentifiers(cp10);
         break;
       }
       case State2.AFTER_DOCTYPE_SYSTEM_KEYWORD: {
-        this._stateAfterDoctypeSystemKeyword(cp11);
+        this._stateAfterDoctypeSystemKeyword(cp10);
         break;
       }
       case State2.BEFORE_DOCTYPE_SYSTEM_IDENTIFIER: {
-        this._stateBeforeDoctypeSystemIdentifier(cp11);
+        this._stateBeforeDoctypeSystemIdentifier(cp10);
         break;
       }
       case State2.DOCTYPE_SYSTEM_IDENTIFIER_DOUBLE_QUOTED: {
-        this._stateDoctypeSystemIdentifierDoubleQuoted(cp11);
+        this._stateDoctypeSystemIdentifierDoubleQuoted(cp10);
         break;
       }
       case State2.DOCTYPE_SYSTEM_IDENTIFIER_SINGLE_QUOTED: {
-        this._stateDoctypeSystemIdentifierSingleQuoted(cp11);
+        this._stateDoctypeSystemIdentifierSingleQuoted(cp10);
         break;
       }
       case State2.AFTER_DOCTYPE_SYSTEM_IDENTIFIER: {
-        this._stateAfterDoctypeSystemIdentifier(cp11);
+        this._stateAfterDoctypeSystemIdentifier(cp10);
         break;
       }
       case State2.BOGUS_DOCTYPE: {
-        this._stateBogusDoctype(cp11);
+        this._stateBogusDoctype(cp10);
         break;
       }
       case State2.CDATA_SECTION: {
-        this._stateCdataSection(cp11);
+        this._stateCdataSection(cp10);
         break;
       }
       case State2.CDATA_SECTION_BRACKET: {
-        this._stateCdataSectionBracket(cp11);
+        this._stateCdataSectionBracket(cp10);
         break;
       }
       case State2.CDATA_SECTION_END: {
-        this._stateCdataSectionEnd(cp11);
+        this._stateCdataSectionEnd(cp10);
         break;
       }
       case State2.CHARACTER_REFERENCE: {
@@ -1451354,7 +1451354,7 @@ var Tokenizer = class {
         break;
       }
       case State2.AMBIGUOUS_AMPERSAND: {
-        this._stateAmbiguousAmpersand(cp11);
+        this._stateAmbiguousAmpersand(cp10);
         break;
       }
       default: {
@@ -1451365,8 +1451365,8 @@ var Tokenizer = class {
   // State machine
   // Data state
   //------------------------------------------------------------------
-  _stateData(cp11) {
-    switch (cp11) {
+  _stateData(cp10) {
+    switch (cp10) {
       case CODE_POINTS.LESS_THAN_SIGN: {
         this.state = State2.TAG_OPEN;
         break;
@@ -1451377,7 +1451377,7 @@ var Tokenizer = class {
       }
       case CODE_POINTS.NULL: {
         this._err(ERR.unexpectedNullCharacter);
-        this._emitCodePoint(cp11);
+        this._emitCodePoint(cp10);
         break;
       }
       case CODE_POINTS.EOF: {
@@ -1451385,14 +1451385,14 @@ var Tokenizer = class {
         break;
       }
       default: {
-        this._emitCodePoint(cp11);
+        this._emitCodePoint(cp10);
       }
     }
   }
   //  RCDATA state
   //------------------------------------------------------------------
-  _stateRcdata(cp11) {
-    switch (cp11) {
+  _stateRcdata(cp10) {
+    switch (cp10) {
       case CODE_POINTS.AMPERSAND: {
         this._startCharacterReference();
         break;
@@ -1451411,14 +1451411,14 @@ var Tokenizer = class {
         break;
       }
       default: {
-        this._emitCodePoint(cp11);
+        this._emitCodePoint(cp10);
       }
     }
   }
   // RAWTEXT state
   //------------------------------------------------------------------
-  _stateRawtext(cp11) {
-    switch (cp11) {
+  _stateRawtext(cp10) {
+    switch (cp10) {
       case CODE_POINTS.LESS_THAN_SIGN: {
         this.state = State2.RAWTEXT_LESS_THAN_SIGN;
         break;
@@ -1451433,14 +1451433,14 @@ var Tokenizer = class {
         break;
       }
       default: {
-        this._emitCodePoint(cp11);
+        this._emitCodePoint(cp10);
       }
     }
   }
   // Script data state
   //------------------------------------------------------------------
-  _stateScriptData(cp11) {
-    switch (cp11) {
+  _stateScriptData(cp10) {
+    switch (cp10) {
       case CODE_POINTS.LESS_THAN_SIGN: {
         this.state = State2.SCRIPT_DATA_LESS_THAN_SIGN;
         break;
@@ -1451455,14 +1451455,14 @@ var Tokenizer = class {
         break;
       }
       default: {
-        this._emitCodePoint(cp11);
+        this._emitCodePoint(cp10);
       }
     }
   }
   // PLAINTEXT state
   //------------------------------------------------------------------
-  _statePlaintext(cp11) {
-    switch (cp11) {
+  _statePlaintext(cp10) {
+    switch (cp10) {
       case CODE_POINTS.NULL: {
         this._err(ERR.unexpectedNullCharacter);
         this._emitChars(REPLACEMENT_CHARACTER);
@@ -1451473,19 +1451473,19 @@ var Tokenizer = class {
         break;
       }
       default: {
-        this._emitCodePoint(cp11);
+        this._emitCodePoint(cp10);
       }
     }
   }
   // Tag open state
   //------------------------------------------------------------------
-  _stateTagOpen(cp11) {
-    if (isAsciiLetter(cp11)) {
+  _stateTagOpen(cp10) {
+    if (isAsciiLetter(cp10)) {
       this._createStartTagToken();
       this.state = State2.TAG_NAME;
-      this._stateTagName(cp11);
+      this._stateTagName(cp10);
     } else
-      switch (cp11) {
+      switch (cp10) {
         case CODE_POINTS.EXCLAMATION_MARK: {
           this.state = State2.MARKUP_DECLARATION_OPEN;
           break;
@@ -1451498,7 +1451498,7 @@ var Tokenizer = class {
           this._err(ERR.unexpectedQuestionMarkInsteadOfTagName);
           this._createCommentToken(1);
           this.state = State2.BOGUS_COMMENT;
-          this._stateBogusComment(cp11);
+          this._stateBogusComment(cp10);
           break;
         }
         case CODE_POINTS.EOF: {
@@ -1451511,19 +1451511,19 @@ var Tokenizer = class {
           this._err(ERR.invalidFirstCharacterOfTagName);
           this._emitChars("<");
           this.state = State2.DATA;
-          this._stateData(cp11);
+          this._stateData(cp10);
         }
       }
   }
   // End tag open state
   //------------------------------------------------------------------
-  _stateEndTagOpen(cp11) {
-    if (isAsciiLetter(cp11)) {
+  _stateEndTagOpen(cp10) {
+    if (isAsciiLetter(cp10)) {
       this._createEndTagToken();
       this.state = State2.TAG_NAME;
-      this._stateTagName(cp11);
+      this._stateTagName(cp10);
     } else
-      switch (cp11) {
+      switch (cp10) {
         case CODE_POINTS.GREATER_THAN_SIGN: {
           this._err(ERR.missingEndTagName);
           this.state = State2.DATA;
@@ -1451539,15 +1451539,15 @@ var Tokenizer = class {
           this._err(ERR.invalidFirstCharacterOfTagName);
           this._createCommentToken(2);
           this.state = State2.BOGUS_COMMENT;
-          this._stateBogusComment(cp11);
+          this._stateBogusComment(cp10);
         }
       }
   }
   // Tag name state
   //------------------------------------------------------------------
-  _stateTagName(cp11) {
+  _stateTagName(cp10) {
     const token = this.currentToken;
-    switch (cp11) {
+    switch (cp10) {
       case CODE_POINTS.SPACE:
       case CODE_POINTS.LINE_FEED:
       case CODE_POINTS.TABULATION:
@@ -1451575,31 +1451575,31 @@ var Tokenizer = class {
         break;
       }
       default: {
-        token.tagName += String.fromCodePoint(isAsciiUpper(cp11) ? toAsciiLower(cp11) : cp11);
+        token.tagName += String.fromCodePoint(isAsciiUpper(cp10) ? toAsciiLower(cp10) : cp10);
       }
     }
   }
   // RCDATA less-than sign state
   //------------------------------------------------------------------
-  _stateRcdataLessThanSign(cp11) {
-    if (cp11 === CODE_POINTS.SOLIDUS) {
+  _stateRcdataLessThanSign(cp10) {
+    if (cp10 === CODE_POINTS.SOLIDUS) {
       this.state = State2.RCDATA_END_TAG_OPEN;
     } else {
       this._emitChars("<");
       this.state = State2.RCDATA;
-      this._stateRcdata(cp11);
+      this._stateRcdata(cp10);
     }
   }
   // RCDATA end tag open state
   //------------------------------------------------------------------
-  _stateRcdataEndTagOpen(cp11) {
-    if (isAsciiLetter(cp11)) {
+  _stateRcdataEndTagOpen(cp10) {
+    if (isAsciiLetter(cp10)) {
       this.state = State2.RCDATA_END_TAG_NAME;
-      this._stateRcdataEndTagName(cp11);
+      this._stateRcdataEndTagName(cp10);
     } else {
       this._emitChars("</");
       this.state = State2.RCDATA;
-      this._stateRcdata(cp11);
+      this._stateRcdata(cp10);
     }
   }
   handleSpecialEndTag(_cp) {
@@ -1451609,8 +1451609,8 @@ var Tokenizer = class {
     this._createEndTagToken();
     const token = this.currentToken;
     token.tagName = this.lastStartTagName;
-    const cp11 = this.preprocessor.peek(this.lastStartTagName.length);
-    switch (cp11) {
+    const cp10 = this.preprocessor.peek(this.lastStartTagName.length);
+    switch (cp10) {
       case CODE_POINTS.SPACE:
       case CODE_POINTS.LINE_FEED:
       case CODE_POINTS.TABULATION:
@@ -1451637,49 +1451637,49 @@ var Tokenizer = class {
   }
   // RCDATA end tag name state
   //------------------------------------------------------------------
-  _stateRcdataEndTagName(cp11) {
-    if (this.handleSpecialEndTag(cp11)) {
+  _stateRcdataEndTagName(cp10) {
+    if (this.handleSpecialEndTag(cp10)) {
       this._emitChars("</");
       this.state = State2.RCDATA;
-      this._stateRcdata(cp11);
+      this._stateRcdata(cp10);
     }
   }
   // RAWTEXT less-than sign state
   //------------------------------------------------------------------
-  _stateRawtextLessThanSign(cp11) {
-    if (cp11 === CODE_POINTS.SOLIDUS) {
+  _stateRawtextLessThanSign(cp10) {
+    if (cp10 === CODE_POINTS.SOLIDUS) {
       this.state = State2.RAWTEXT_END_TAG_OPEN;
     } else {
       this._emitChars("<");
       this.state = State2.RAWTEXT;
-      this._stateRawtext(cp11);
+      this._stateRawtext(cp10);
     }
   }
   // RAWTEXT end tag open state
   //------------------------------------------------------------------
-  _stateRawtextEndTagOpen(cp11) {
-    if (isAsciiLetter(cp11)) {
+  _stateRawtextEndTagOpen(cp10) {
+    if (isAsciiLetter(cp10)) {
       this.state = State2.RAWTEXT_END_TAG_NAME;
-      this._stateRawtextEndTagName(cp11);
+      this._stateRawtextEndTagName(cp10);
     } else {
       this._emitChars("</");
       this.state = State2.RAWTEXT;
-      this._stateRawtext(cp11);
+      this._stateRawtext(cp10);
     }
   }
   // RAWTEXT end tag name state
   //------------------------------------------------------------------
-  _stateRawtextEndTagName(cp11) {
-    if (this.handleSpecialEndTag(cp11)) {
+  _stateRawtextEndTagName(cp10) {
+    if (this.handleSpecialEndTag(cp10)) {
       this._emitChars("</");
       this.state = State2.RAWTEXT;
-      this._stateRawtext(cp11);
+      this._stateRawtext(cp10);
     }
   }
   // Script data less-than sign state
   //------------------------------------------------------------------
-  _stateScriptDataLessThanSign(cp11) {
-    switch (cp11) {
+  _stateScriptDataLessThanSign(cp10) {
+    switch (cp10) {
       case CODE_POINTS.SOLIDUS: {
         this.state = State2.SCRIPT_DATA_END_TAG_OPEN;
         break;
@@ -1451692,57 +1451692,57 @@ var Tokenizer = class {
       default: {
         this._emitChars("<");
         this.state = State2.SCRIPT_DATA;
-        this._stateScriptData(cp11);
+        this._stateScriptData(cp10);
       }
     }
   }
   // Script data end tag open state
   //------------------------------------------------------------------
-  _stateScriptDataEndTagOpen(cp11) {
-    if (isAsciiLetter(cp11)) {
+  _stateScriptDataEndTagOpen(cp10) {
+    if (isAsciiLetter(cp10)) {
       this.state = State2.SCRIPT_DATA_END_TAG_NAME;
-      this._stateScriptDataEndTagName(cp11);
+      this._stateScriptDataEndTagName(cp10);
     } else {
       this._emitChars("</");
       this.state = State2.SCRIPT_DATA;
-      this._stateScriptData(cp11);
+      this._stateScriptData(cp10);
     }
   }
   // Script data end tag name state
   //------------------------------------------------------------------
-  _stateScriptDataEndTagName(cp11) {
-    if (this.handleSpecialEndTag(cp11)) {
+  _stateScriptDataEndTagName(cp10) {
+    if (this.handleSpecialEndTag(cp10)) {
       this._emitChars("</");
       this.state = State2.SCRIPT_DATA;
-      this._stateScriptData(cp11);
+      this._stateScriptData(cp10);
     }
   }
   // Script data escape start state
   //------------------------------------------------------------------
-  _stateScriptDataEscapeStart(cp11) {
-    if (cp11 === CODE_POINTS.HYPHEN_MINUS) {
+  _stateScriptDataEscapeStart(cp10) {
+    if (cp10 === CODE_POINTS.HYPHEN_MINUS) {
       this.state = State2.SCRIPT_DATA_ESCAPE_START_DASH;
       this._emitChars("-");
     } else {
       this.state = State2.SCRIPT_DATA;
-      this._stateScriptData(cp11);
+      this._stateScriptData(cp10);
     }
   }
   // Script data escape start dash state
   //------------------------------------------------------------------
-  _stateScriptDataEscapeStartDash(cp11) {
-    if (cp11 === CODE_POINTS.HYPHEN_MINUS) {
+  _stateScriptDataEscapeStartDash(cp10) {
+    if (cp10 === CODE_POINTS.HYPHEN_MINUS) {
       this.state = State2.SCRIPT_DATA_ESCAPED_DASH_DASH;
       this._emitChars("-");
     } else {
       this.state = State2.SCRIPT_DATA;
-      this._stateScriptData(cp11);
+      this._stateScriptData(cp10);
     }
   }
   // Script data escaped state
   //------------------------------------------------------------------
-  _stateScriptDataEscaped(cp11) {
-    switch (cp11) {
+  _stateScriptDataEscaped(cp10) {
+    switch (cp10) {
       case CODE_POINTS.HYPHEN_MINUS: {
         this.state = State2.SCRIPT_DATA_ESCAPED_DASH;
         this._emitChars("-");
@@ -1451763,14 +1451763,14 @@ var Tokenizer = class {
         break;
       }
       default: {
-        this._emitCodePoint(cp11);
+        this._emitCodePoint(cp10);
       }
     }
   }
   // Script data escaped dash state
   //------------------------------------------------------------------
-  _stateScriptDataEscapedDash(cp11) {
-    switch (cp11) {
+  _stateScriptDataEscapedDash(cp10) {
+    switch (cp10) {
       case CODE_POINTS.HYPHEN_MINUS: {
         this.state = State2.SCRIPT_DATA_ESCAPED_DASH_DASH;
         this._emitChars("-");
@@ -1451793,14 +1451793,14 @@ var Tokenizer = class {
       }
       default: {
         this.state = State2.SCRIPT_DATA_ESCAPED;
-        this._emitCodePoint(cp11);
+        this._emitCodePoint(cp10);
       }
     }
   }
   // Script data escaped dash dash state
   //------------------------------------------------------------------
-  _stateScriptDataEscapedDashDash(cp11) {
-    switch (cp11) {
+  _stateScriptDataEscapedDashDash(cp10) {
+    switch (cp10) {
       case CODE_POINTS.HYPHEN_MINUS: {
         this._emitChars("-");
         break;
@@ -1451827,64 +1451827,64 @@ var Tokenizer = class {
       }
       default: {
         this.state = State2.SCRIPT_DATA_ESCAPED;
-        this._emitCodePoint(cp11);
+        this._emitCodePoint(cp10);
       }
     }
   }
   // Script data escaped less-than sign state
   //------------------------------------------------------------------
-  _stateScriptDataEscapedLessThanSign(cp11) {
-    if (cp11 === CODE_POINTS.SOLIDUS) {
+  _stateScriptDataEscapedLessThanSign(cp10) {
+    if (cp10 === CODE_POINTS.SOLIDUS) {
       this.state = State2.SCRIPT_DATA_ESCAPED_END_TAG_OPEN;
-    } else if (isAsciiLetter(cp11)) {
+    } else if (isAsciiLetter(cp10)) {
       this._emitChars("<");
       this.state = State2.SCRIPT_DATA_DOUBLE_ESCAPE_START;
-      this._stateScriptDataDoubleEscapeStart(cp11);
+      this._stateScriptDataDoubleEscapeStart(cp10);
     } else {
       this._emitChars("<");
       this.state = State2.SCRIPT_DATA_ESCAPED;
-      this._stateScriptDataEscaped(cp11);
+      this._stateScriptDataEscaped(cp10);
     }
   }
   // Script data escaped end tag open state
   //------------------------------------------------------------------
-  _stateScriptDataEscapedEndTagOpen(cp11) {
-    if (isAsciiLetter(cp11)) {
+  _stateScriptDataEscapedEndTagOpen(cp10) {
+    if (isAsciiLetter(cp10)) {
       this.state = State2.SCRIPT_DATA_ESCAPED_END_TAG_NAME;
-      this._stateScriptDataEscapedEndTagName(cp11);
+      this._stateScriptDataEscapedEndTagName(cp10);
     } else {
       this._emitChars("</");
       this.state = State2.SCRIPT_DATA_ESCAPED;
-      this._stateScriptDataEscaped(cp11);
+      this._stateScriptDataEscaped(cp10);
     }
   }
   // Script data escaped end tag name state
   //------------------------------------------------------------------
-  _stateScriptDataEscapedEndTagName(cp11) {
-    if (this.handleSpecialEndTag(cp11)) {
+  _stateScriptDataEscapedEndTagName(cp10) {
+    if (this.handleSpecialEndTag(cp10)) {
       this._emitChars("</");
       this.state = State2.SCRIPT_DATA_ESCAPED;
-      this._stateScriptDataEscaped(cp11);
+      this._stateScriptDataEscaped(cp10);
     }
   }
   // Script data double escape start state
   //------------------------------------------------------------------
-  _stateScriptDataDoubleEscapeStart(cp11) {
+  _stateScriptDataDoubleEscapeStart(cp10) {
     if (this.preprocessor.startsWith(SEQUENCES.SCRIPT, false) && isScriptDataDoubleEscapeSequenceEnd(this.preprocessor.peek(SEQUENCES.SCRIPT.length))) {
-      this._emitCodePoint(cp11);
+      this._emitCodePoint(cp10);
       for (let i11 = 0; i11 < SEQUENCES.SCRIPT.length; i11++) {
         this._emitCodePoint(this._consume());
       }
       this.state = State2.SCRIPT_DATA_DOUBLE_ESCAPED;
     } else if (!this._ensureHibernation()) {
       this.state = State2.SCRIPT_DATA_ESCAPED;
-      this._stateScriptDataEscaped(cp11);
+      this._stateScriptDataEscaped(cp10);
     }
   }
   // Script data double escaped state
   //------------------------------------------------------------------
-  _stateScriptDataDoubleEscaped(cp11) {
-    switch (cp11) {
+  _stateScriptDataDoubleEscaped(cp10) {
+    switch (cp10) {
       case CODE_POINTS.HYPHEN_MINUS: {
         this.state = State2.SCRIPT_DATA_DOUBLE_ESCAPED_DASH;
         this._emitChars("-");
@@ -1451906,14 +1451906,14 @@ var Tokenizer = class {
         break;
       }
       default: {
-        this._emitCodePoint(cp11);
+        this._emitCodePoint(cp10);
       }
     }
   }
   // Script data double escaped dash state
   //------------------------------------------------------------------
-  _stateScriptDataDoubleEscapedDash(cp11) {
-    switch (cp11) {
+  _stateScriptDataDoubleEscapedDash(cp10) {
+    switch (cp10) {
       case CODE_POINTS.HYPHEN_MINUS: {
         this.state = State2.SCRIPT_DATA_DOUBLE_ESCAPED_DASH_DASH;
         this._emitChars("-");
@@ -1451937,14 +1451937,14 @@ var Tokenizer = class {
       }
       default: {
         this.state = State2.SCRIPT_DATA_DOUBLE_ESCAPED;
-        this._emitCodePoint(cp11);
+        this._emitCodePoint(cp10);
       }
     }
   }
   // Script data double escaped dash dash state
   //------------------------------------------------------------------
-  _stateScriptDataDoubleEscapedDashDash(cp11) {
-    switch (cp11) {
+  _stateScriptDataDoubleEscapedDashDash(cp10) {
+    switch (cp10) {
       case CODE_POINTS.HYPHEN_MINUS: {
         this._emitChars("-");
         break;
@@ -1451972,39 +1451972,39 @@ var Tokenizer = class {
       }
       default: {
         this.state = State2.SCRIPT_DATA_DOUBLE_ESCAPED;
-        this._emitCodePoint(cp11);
+        this._emitCodePoint(cp10);
       }
     }
   }
   // Script data double escaped less-than sign state
   //------------------------------------------------------------------
-  _stateScriptDataDoubleEscapedLessThanSign(cp11) {
-    if (cp11 === CODE_POINTS.SOLIDUS) {
+  _stateScriptDataDoubleEscapedLessThanSign(cp10) {
+    if (cp10 === CODE_POINTS.SOLIDUS) {
       this.state = State2.SCRIPT_DATA_DOUBLE_ESCAPE_END;
       this._emitChars("/");
     } else {
       this.state = State2.SCRIPT_DATA_DOUBLE_ESCAPED;
-      this._stateScriptDataDoubleEscaped(cp11);
+      this._stateScriptDataDoubleEscaped(cp10);
     }
   }
   // Script data double escape end state
   //------------------------------------------------------------------
-  _stateScriptDataDoubleEscapeEnd(cp11) {
+  _stateScriptDataDoubleEscapeEnd(cp10) {
     if (this.preprocessor.startsWith(SEQUENCES.SCRIPT, false) && isScriptDataDoubleEscapeSequenceEnd(this.preprocessor.peek(SEQUENCES.SCRIPT.length))) {
-      this._emitCodePoint(cp11);
+      this._emitCodePoint(cp10);
       for (let i11 = 0; i11 < SEQUENCES.SCRIPT.length; i11++) {
         this._emitCodePoint(this._consume());
       }
       this.state = State2.SCRIPT_DATA_ESCAPED;
     } else if (!this._ensureHibernation()) {
       this.state = State2.SCRIPT_DATA_DOUBLE_ESCAPED;
-      this._stateScriptDataDoubleEscaped(cp11);
+      this._stateScriptDataDoubleEscaped(cp10);
     }
   }
   // Before attribute name state
   //------------------------------------------------------------------
-  _stateBeforeAttributeName(cp11) {
-    switch (cp11) {
+  _stateBeforeAttributeName(cp10) {
+    switch (cp10) {
       case CODE_POINTS.SPACE:
       case CODE_POINTS.LINE_FEED:
       case CODE_POINTS.TABULATION:
@@ -1452015,7 +1452015,7 @@ var Tokenizer = class {
       case CODE_POINTS.GREATER_THAN_SIGN:
       case CODE_POINTS.EOF: {
         this.state = State2.AFTER_ATTRIBUTE_NAME;
-        this._stateAfterAttributeName(cp11);
+        this._stateAfterAttributeName(cp10);
         break;
       }
       case CODE_POINTS.EQUALS_SIGN: {
@@ -1452027,14 +1452027,14 @@ var Tokenizer = class {
       default: {
         this._createAttr("");
         this.state = State2.ATTRIBUTE_NAME;
-        this._stateAttributeName(cp11);
+        this._stateAttributeName(cp10);
       }
     }
   }
   // Attribute name state
   //------------------------------------------------------------------
-  _stateAttributeName(cp11) {
-    switch (cp11) {
+  _stateAttributeName(cp10) {
+    switch (cp10) {
       case CODE_POINTS.SPACE:
       case CODE_POINTS.LINE_FEED:
       case CODE_POINTS.TABULATION:
@@ -1452044,7 +1452044,7 @@ var Tokenizer = class {
       case CODE_POINTS.EOF: {
         this._leaveAttrName();
         this.state = State2.AFTER_ATTRIBUTE_NAME;
-        this._stateAfterAttributeName(cp11);
+        this._stateAfterAttributeName(cp10);
         break;
       }
       case CODE_POINTS.EQUALS_SIGN: {
@@ -1452056,7 +1452056,7 @@ var Tokenizer = class {
       case CODE_POINTS.APOSTROPHE:
       case CODE_POINTS.LESS_THAN_SIGN: {
         this._err(ERR.unexpectedCharacterInAttributeName);
-        this.currentAttr.name += String.fromCodePoint(cp11);
+        this.currentAttr.name += String.fromCodePoint(cp10);
         break;
       }
       case CODE_POINTS.NULL: {
@@ -1452065,14 +1452065,14 @@ var Tokenizer = class {
         break;
       }
       default: {
-        this.currentAttr.name += String.fromCodePoint(isAsciiUpper(cp11) ? toAsciiLower(cp11) : cp11);
+        this.currentAttr.name += String.fromCodePoint(isAsciiUpper(cp10) ? toAsciiLower(cp10) : cp10);
       }
     }
   }
   // After attribute name state
   //------------------------------------------------------------------
-  _stateAfterAttributeName(cp11) {
-    switch (cp11) {
+  _stateAfterAttributeName(cp10) {
+    switch (cp10) {
       case CODE_POINTS.SPACE:
       case CODE_POINTS.LINE_FEED:
       case CODE_POINTS.TABULATION:
@@ -1452100,14 +1452100,14 @@ var Tokenizer = class {
       default: {
         this._createAttr("");
         this.state = State2.ATTRIBUTE_NAME;
-        this._stateAttributeName(cp11);
+        this._stateAttributeName(cp10);
       }
     }
   }
   // Before attribute value state
   //------------------------------------------------------------------
-  _stateBeforeAttributeValue(cp11) {
-    switch (cp11) {
+  _stateBeforeAttributeValue(cp10) {
+    switch (cp10) {
       case CODE_POINTS.SPACE:
       case CODE_POINTS.LINE_FEED:
       case CODE_POINTS.TABULATION:
@@ -1452130,14 +1452130,14 @@ var Tokenizer = class {
       }
       default: {
         this.state = State2.ATTRIBUTE_VALUE_UNQUOTED;
-        this._stateAttributeValueUnquoted(cp11);
+        this._stateAttributeValueUnquoted(cp10);
       }
     }
   }
   // Attribute value (double-quoted) state
   //------------------------------------------------------------------
-  _stateAttributeValueDoubleQuoted(cp11) {
-    switch (cp11) {
+  _stateAttributeValueDoubleQuoted(cp10) {
+    switch (cp10) {
       case CODE_POINTS.QUOTATION_MARK: {
         this.state = State2.AFTER_ATTRIBUTE_VALUE_QUOTED;
         break;
@@ -1452157,14 +1452157,14 @@ var Tokenizer = class {
         break;
       }
       default: {
-        this.currentAttr.value += String.fromCodePoint(cp11);
+        this.currentAttr.value += String.fromCodePoint(cp10);
       }
     }
   }
   // Attribute value (single-quoted) state
   //------------------------------------------------------------------
-  _stateAttributeValueSingleQuoted(cp11) {
-    switch (cp11) {
+  _stateAttributeValueSingleQuoted(cp10) {
+    switch (cp10) {
       case CODE_POINTS.APOSTROPHE: {
         this.state = State2.AFTER_ATTRIBUTE_VALUE_QUOTED;
         break;
@@ -1452184,14 +1452184,14 @@ var Tokenizer = class {
         break;
       }
       default: {
-        this.currentAttr.value += String.fromCodePoint(cp11);
+        this.currentAttr.value += String.fromCodePoint(cp10);
       }
     }
   }
   // Attribute value (unquoted) state
   //------------------------------------------------------------------
-  _stateAttributeValueUnquoted(cp11) {
-    switch (cp11) {
+  _stateAttributeValueUnquoted(cp10) {
+    switch (cp10) {
       case CODE_POINTS.SPACE:
       case CODE_POINTS.LINE_FEED:
       case CODE_POINTS.TABULATION:
@@ -1452221,7 +1452221,7 @@ var Tokenizer = class {
       case CODE_POINTS.EQUALS_SIGN:
       case CODE_POINTS.GRAVE_ACCENT: {
         this._err(ERR.unexpectedCharacterInUnquotedAttributeValue);
-        this.currentAttr.value += String.fromCodePoint(cp11);
+        this.currentAttr.value += String.fromCodePoint(cp10);
         break;
       }
       case CODE_POINTS.EOF: {
@@ -1452230,14 +1452230,14 @@ var Tokenizer = class {
         break;
       }
       default: {
-        this.currentAttr.value += String.fromCodePoint(cp11);
+        this.currentAttr.value += String.fromCodePoint(cp10);
       }
     }
   }
   // After attribute value (quoted) state
   //------------------------------------------------------------------
-  _stateAfterAttributeValueQuoted(cp11) {
-    switch (cp11) {
+  _stateAfterAttributeValueQuoted(cp10) {
+    switch (cp10) {
       case CODE_POINTS.SPACE:
       case CODE_POINTS.LINE_FEED:
       case CODE_POINTS.TABULATION:
@@ -1452265,14 +1452265,14 @@ var Tokenizer = class {
       default: {
         this._err(ERR.missingWhitespaceBetweenAttributes);
         this.state = State2.BEFORE_ATTRIBUTE_NAME;
-        this._stateBeforeAttributeName(cp11);
+        this._stateBeforeAttributeName(cp10);
       }
     }
   }
   // Self-closing start tag state
   //------------------------------------------------------------------
-  _stateSelfClosingStartTag(cp11) {
-    switch (cp11) {
+  _stateSelfClosingStartTag(cp10) {
+    switch (cp10) {
       case CODE_POINTS.GREATER_THAN_SIGN: {
         const token = this.currentToken;
         token.selfClosing = true;
@@ -1452288,15 +1452288,15 @@ var Tokenizer = class {
       default: {
         this._err(ERR.unexpectedSolidusInTag);
         this.state = State2.BEFORE_ATTRIBUTE_NAME;
-        this._stateBeforeAttributeName(cp11);
+        this._stateBeforeAttributeName(cp10);
       }
     }
   }
   // Bogus comment state
   //------------------------------------------------------------------
-  _stateBogusComment(cp11) {
+  _stateBogusComment(cp10) {
     const token = this.currentToken;
-    switch (cp11) {
+    switch (cp10) {
       case CODE_POINTS.GREATER_THAN_SIGN: {
         this.state = State2.DATA;
         this.emitCurrentComment(token);
@@ -1452313,13 +1452313,13 @@ var Tokenizer = class {
         break;
       }
       default: {
-        token.data += String.fromCodePoint(cp11);
+        token.data += String.fromCodePoint(cp10);
       }
     }
   }
   // Markup declaration open state
   //------------------------------------------------------------------
-  _stateMarkupDeclarationOpen(cp11) {
+  _stateMarkupDeclarationOpen(cp10) {
     if (this._consumeSequenceIfMatch(SEQUENCES.DASH_DASH, true)) {
       this._createCommentToken(SEQUENCES.DASH_DASH.length + 1);
       this.state = State2.COMMENT_START;
@@ -1452339,13 +1452339,13 @@ var Tokenizer = class {
       this._err(ERR.incorrectlyOpenedComment);
       this._createCommentToken(2);
       this.state = State2.BOGUS_COMMENT;
-      this._stateBogusComment(cp11);
+      this._stateBogusComment(cp10);
     }
   }
   // Comment start state
   //------------------------------------------------------------------
-  _stateCommentStart(cp11) {
-    switch (cp11) {
+  _stateCommentStart(cp10) {
+    switch (cp10) {
       case CODE_POINTS.HYPHEN_MINUS: {
         this.state = State2.COMMENT_START_DASH;
         break;
@@ -1452359,15 +1452359,15 @@ var Tokenizer = class {
       }
       default: {
         this.state = State2.COMMENT;
-        this._stateComment(cp11);
+        this._stateComment(cp10);
       }
     }
   }
   // Comment start dash state
   //------------------------------------------------------------------
-  _stateCommentStartDash(cp11) {
+  _stateCommentStartDash(cp10) {
     const token = this.currentToken;
-    switch (cp11) {
+    switch (cp10) {
       case CODE_POINTS.HYPHEN_MINUS: {
         this.state = State2.COMMENT_END;
         break;
@@ -1452387,15 +1452387,15 @@ var Tokenizer = class {
       default: {
         token.data += "-";
         this.state = State2.COMMENT;
-        this._stateComment(cp11);
+        this._stateComment(cp10);
       }
     }
   }
   // Comment state
   //------------------------------------------------------------------
-  _stateComment(cp11) {
+  _stateComment(cp10) {
     const token = this.currentToken;
-    switch (cp11) {
+    switch (cp10) {
       case CODE_POINTS.HYPHEN_MINUS: {
         this.state = State2.COMMENT_END_DASH;
         break;
@@ -1452417,15 +1452417,15 @@ var Tokenizer = class {
         break;
       }
       default: {
-        token.data += String.fromCodePoint(cp11);
+        token.data += String.fromCodePoint(cp10);
       }
     }
   }
   // Comment less-than sign state
   //------------------------------------------------------------------
-  _stateCommentLessThanSign(cp11) {
+  _stateCommentLessThanSign(cp10) {
     const token = this.currentToken;
-    switch (cp11) {
+    switch (cp10) {
       case CODE_POINTS.EXCLAMATION_MARK: {
         token.data += "!";
         this.state = State2.COMMENT_LESS_THAN_SIGN_BANG;
@@ -1452437,44 +1452437,44 @@ var Tokenizer = class {
       }
       default: {
         this.state = State2.COMMENT;
-        this._stateComment(cp11);
+        this._stateComment(cp10);
       }
     }
   }
   // Comment less-than sign bang state
   //------------------------------------------------------------------
-  _stateCommentLessThanSignBang(cp11) {
-    if (cp11 === CODE_POINTS.HYPHEN_MINUS) {
+  _stateCommentLessThanSignBang(cp10) {
+    if (cp10 === CODE_POINTS.HYPHEN_MINUS) {
       this.state = State2.COMMENT_LESS_THAN_SIGN_BANG_DASH;
     } else {
       this.state = State2.COMMENT;
-      this._stateComment(cp11);
+      this._stateComment(cp10);
     }
   }
   // Comment less-than sign bang dash state
   //------------------------------------------------------------------
-  _stateCommentLessThanSignBangDash(cp11) {
-    if (cp11 === CODE_POINTS.HYPHEN_MINUS) {
+  _stateCommentLessThanSignBangDash(cp10) {
+    if (cp10 === CODE_POINTS.HYPHEN_MINUS) {
       this.state = State2.COMMENT_LESS_THAN_SIGN_BANG_DASH_DASH;
     } else {
       this.state = State2.COMMENT_END_DASH;
-      this._stateCommentEndDash(cp11);
+      this._stateCommentEndDash(cp10);
     }
   }
   // Comment less-than sign bang dash dash state
   //------------------------------------------------------------------
-  _stateCommentLessThanSignBangDashDash(cp11) {
-    if (cp11 !== CODE_POINTS.GREATER_THAN_SIGN && cp11 !== CODE_POINTS.EOF) {
+  _stateCommentLessThanSignBangDashDash(cp10) {
+    if (cp10 !== CODE_POINTS.GREATER_THAN_SIGN && cp10 !== CODE_POINTS.EOF) {
       this._err(ERR.nestedComment);
     }
     this.state = State2.COMMENT_END;
-    this._stateCommentEnd(cp11);
+    this._stateCommentEnd(cp10);
   }
   // Comment end dash state
   //------------------------------------------------------------------
-  _stateCommentEndDash(cp11) {
+  _stateCommentEndDash(cp10) {
     const token = this.currentToken;
-    switch (cp11) {
+    switch (cp10) {
       case CODE_POINTS.HYPHEN_MINUS: {
         this.state = State2.COMMENT_END;
         break;
@@ -1452488,15 +1452488,15 @@ var Tokenizer = class {
       default: {
         token.data += "-";
         this.state = State2.COMMENT;
-        this._stateComment(cp11);
+        this._stateComment(cp10);
       }
     }
   }
   // Comment end state
   //------------------------------------------------------------------
-  _stateCommentEnd(cp11) {
+  _stateCommentEnd(cp10) {
     const token = this.currentToken;
-    switch (cp11) {
+    switch (cp10) {
       case CODE_POINTS.GREATER_THAN_SIGN: {
         this.state = State2.DATA;
         this.emitCurrentComment(token);
@@ -1452519,15 +1452519,15 @@ var Tokenizer = class {
       default: {
         token.data += "--";
         this.state = State2.COMMENT;
-        this._stateComment(cp11);
+        this._stateComment(cp10);
       }
     }
   }
   // Comment end bang state
   //------------------------------------------------------------------
-  _stateCommentEndBang(cp11) {
+  _stateCommentEndBang(cp10) {
     const token = this.currentToken;
-    switch (cp11) {
+    switch (cp10) {
       case CODE_POINTS.HYPHEN_MINUS: {
         token.data += "--!";
         this.state = State2.COMMENT_END_DASH;
@@ -1452548,14 +1452548,14 @@ var Tokenizer = class {
       default: {
         token.data += "--!";
         this.state = State2.COMMENT;
-        this._stateComment(cp11);
+        this._stateComment(cp10);
       }
     }
   }
   // DOCTYPE state
   //------------------------------------------------------------------
-  _stateDoctype(cp11) {
-    switch (cp11) {
+  _stateDoctype(cp10) {
+    switch (cp10) {
       case CODE_POINTS.SPACE:
       case CODE_POINTS.LINE_FEED:
       case CODE_POINTS.TABULATION:
@@ -1452565,7 +1452565,7 @@ var Tokenizer = class {
       }
       case CODE_POINTS.GREATER_THAN_SIGN: {
         this.state = State2.BEFORE_DOCTYPE_NAME;
-        this._stateBeforeDoctypeName(cp11);
+        this._stateBeforeDoctypeName(cp10);
         break;
       }
       case CODE_POINTS.EOF: {
@@ -1452580,18 +1452580,18 @@ var Tokenizer = class {
       default: {
         this._err(ERR.missingWhitespaceBeforeDoctypeName);
         this.state = State2.BEFORE_DOCTYPE_NAME;
-        this._stateBeforeDoctypeName(cp11);
+        this._stateBeforeDoctypeName(cp10);
       }
     }
   }
   // Before DOCTYPE name state
   //------------------------------------------------------------------
-  _stateBeforeDoctypeName(cp11) {
-    if (isAsciiUpper(cp11)) {
-      this._createDoctypeToken(String.fromCharCode(toAsciiLower(cp11)));
+  _stateBeforeDoctypeName(cp10) {
+    if (isAsciiUpper(cp10)) {
+      this._createDoctypeToken(String.fromCharCode(toAsciiLower(cp10)));
       this.state = State2.DOCTYPE_NAME;
     } else
-      switch (cp11) {
+      switch (cp10) {
         case CODE_POINTS.SPACE:
         case CODE_POINTS.LINE_FEED:
         case CODE_POINTS.TABULATION:
@@ -1452623,16 +1452623,16 @@ var Tokenizer = class {
           break;
         }
         default: {
-          this._createDoctypeToken(String.fromCodePoint(cp11));
+          this._createDoctypeToken(String.fromCodePoint(cp10));
           this.state = State2.DOCTYPE_NAME;
         }
       }
   }
   // DOCTYPE name state
   //------------------------------------------------------------------
-  _stateDoctypeName(cp11) {
+  _stateDoctypeName(cp10) {
     const token = this.currentToken;
-    switch (cp11) {
+    switch (cp10) {
       case CODE_POINTS.SPACE:
       case CODE_POINTS.LINE_FEED:
       case CODE_POINTS.TABULATION:
@@ -1452658,15 +1452658,15 @@ var Tokenizer = class {
         break;
       }
       default: {
-        token.name += String.fromCodePoint(isAsciiUpper(cp11) ? toAsciiLower(cp11) : cp11);
+        token.name += String.fromCodePoint(isAsciiUpper(cp10) ? toAsciiLower(cp10) : cp10);
       }
     }
   }
   // After DOCTYPE name state
   //------------------------------------------------------------------
-  _stateAfterDoctypeName(cp11) {
+  _stateAfterDoctypeName(cp10) {
     const token = this.currentToken;
-    switch (cp11) {
+    switch (cp10) {
       case CODE_POINTS.SPACE:
       case CODE_POINTS.LINE_FEED:
       case CODE_POINTS.TABULATION:
@@ -1452694,16 +1452694,16 @@ var Tokenizer = class {
           this._err(ERR.invalidCharacterSequenceAfterDoctypeName);
           token.forceQuirks = true;
           this.state = State2.BOGUS_DOCTYPE;
-          this._stateBogusDoctype(cp11);
+          this._stateBogusDoctype(cp10);
         }
       }
     }
   }
   // After DOCTYPE public keyword state
   //------------------------------------------------------------------
-  _stateAfterDoctypePublicKeyword(cp11) {
+  _stateAfterDoctypePublicKeyword(cp10) {
     const token = this.currentToken;
-    switch (cp11) {
+    switch (cp10) {
       case CODE_POINTS.SPACE:
       case CODE_POINTS.LINE_FEED:
       case CODE_POINTS.TABULATION:
@@ -1452741,15 +1452741,15 @@ var Tokenizer = class {
         this._err(ERR.missingQuoteBeforeDoctypePublicIdentifier);
         token.forceQuirks = true;
         this.state = State2.BOGUS_DOCTYPE;
-        this._stateBogusDoctype(cp11);
+        this._stateBogusDoctype(cp10);
       }
     }
   }
   // Before DOCTYPE public identifier state
   //------------------------------------------------------------------
-  _stateBeforeDoctypePublicIdentifier(cp11) {
+  _stateBeforeDoctypePublicIdentifier(cp10) {
     const token = this.currentToken;
-    switch (cp11) {
+    switch (cp10) {
       case CODE_POINTS.SPACE:
       case CODE_POINTS.LINE_FEED:
       case CODE_POINTS.TABULATION:
@@ -1452784,15 +1452784,15 @@ var Tokenizer = class {
         this._err(ERR.missingQuoteBeforeDoctypePublicIdentifier);
         token.forceQuirks = true;
         this.state = State2.BOGUS_DOCTYPE;
-        this._stateBogusDoctype(cp11);
+        this._stateBogusDoctype(cp10);
       }
     }
   }
   // DOCTYPE public identifier (double-quoted) state
   //------------------------------------------------------------------
-  _stateDoctypePublicIdentifierDoubleQuoted(cp11) {
+  _stateDoctypePublicIdentifierDoubleQuoted(cp10) {
     const token = this.currentToken;
-    switch (cp11) {
+    switch (cp10) {
       case CODE_POINTS.QUOTATION_MARK: {
         this.state = State2.AFTER_DOCTYPE_PUBLIC_IDENTIFIER;
         break;
@@ -1452817,15 +1452817,15 @@ var Tokenizer = class {
         break;
       }
       default: {
-        token.publicId += String.fromCodePoint(cp11);
+        token.publicId += String.fromCodePoint(cp10);
       }
     }
   }
   // DOCTYPE public identifier (single-quoted) state
   //------------------------------------------------------------------
-  _stateDoctypePublicIdentifierSingleQuoted(cp11) {
+  _stateDoctypePublicIdentifierSingleQuoted(cp10) {
     const token = this.currentToken;
-    switch (cp11) {
+    switch (cp10) {
       case CODE_POINTS.APOSTROPHE: {
         this.state = State2.AFTER_DOCTYPE_PUBLIC_IDENTIFIER;
         break;
@@ -1452850,15 +1452850,15 @@ var Tokenizer = class {
         break;
       }
       default: {
-        token.publicId += String.fromCodePoint(cp11);
+        token.publicId += String.fromCodePoint(cp10);
       }
     }
   }
   // After DOCTYPE public identifier state
   //------------------------------------------------------------------
-  _stateAfterDoctypePublicIdentifier(cp11) {
+  _stateAfterDoctypePublicIdentifier(cp10) {
     const token = this.currentToken;
-    switch (cp11) {
+    switch (cp10) {
       case CODE_POINTS.SPACE:
       case CODE_POINTS.LINE_FEED:
       case CODE_POINTS.TABULATION:
@@ -1452894,15 +1452894,15 @@ var Tokenizer = class {
         this._err(ERR.missingQuoteBeforeDoctypeSystemIdentifier);
         token.forceQuirks = true;
         this.state = State2.BOGUS_DOCTYPE;
-        this._stateBogusDoctype(cp11);
+        this._stateBogusDoctype(cp10);
       }
     }
   }
   // Between DOCTYPE public and system identifiers state
   //------------------------------------------------------------------
-  _stateBetweenDoctypePublicAndSystemIdentifiers(cp11) {
+  _stateBetweenDoctypePublicAndSystemIdentifiers(cp10) {
     const token = this.currentToken;
-    switch (cp11) {
+    switch (cp10) {
       case CODE_POINTS.SPACE:
       case CODE_POINTS.LINE_FEED:
       case CODE_POINTS.TABULATION:
@@ -1452935,15 +1452935,15 @@ var Tokenizer = class {
         this._err(ERR.missingQuoteBeforeDoctypeSystemIdentifier);
         token.forceQuirks = true;
         this.state = State2.BOGUS_DOCTYPE;
-        this._stateBogusDoctype(cp11);
+        this._stateBogusDoctype(cp10);
       }
     }
   }
   // After DOCTYPE system keyword state
   //------------------------------------------------------------------
-  _stateAfterDoctypeSystemKeyword(cp11) {
+  _stateAfterDoctypeSystemKeyword(cp10) {
     const token = this.currentToken;
-    switch (cp11) {
+    switch (cp10) {
       case CODE_POINTS.SPACE:
       case CODE_POINTS.LINE_FEED:
       case CODE_POINTS.TABULATION:
@@ -1452981,15 +1452981,15 @@ var Tokenizer = class {
         this._err(ERR.missingQuoteBeforeDoctypeSystemIdentifier);
         token.forceQuirks = true;
         this.state = State2.BOGUS_DOCTYPE;
-        this._stateBogusDoctype(cp11);
+        this._stateBogusDoctype(cp10);
       }
     }
   }
   // Before DOCTYPE system identifier state
   //------------------------------------------------------------------
-  _stateBeforeDoctypeSystemIdentifier(cp11) {
+  _stateBeforeDoctypeSystemIdentifier(cp10) {
     const token = this.currentToken;
-    switch (cp11) {
+    switch (cp10) {
       case CODE_POINTS.SPACE:
       case CODE_POINTS.LINE_FEED:
       case CODE_POINTS.TABULATION:
@@ -1453024,15 +1453024,15 @@ var Tokenizer = class {
         this._err(ERR.missingQuoteBeforeDoctypeSystemIdentifier);
         token.forceQuirks = true;
         this.state = State2.BOGUS_DOCTYPE;
-        this._stateBogusDoctype(cp11);
+        this._stateBogusDoctype(cp10);
       }
     }
   }
   // DOCTYPE system identifier (double-quoted) state
   //------------------------------------------------------------------
-  _stateDoctypeSystemIdentifierDoubleQuoted(cp11) {
+  _stateDoctypeSystemIdentifierDoubleQuoted(cp10) {
     const token = this.currentToken;
-    switch (cp11) {
+    switch (cp10) {
       case CODE_POINTS.QUOTATION_MARK: {
         this.state = State2.AFTER_DOCTYPE_SYSTEM_IDENTIFIER;
         break;
@@ -1453057,15 +1453057,15 @@ var Tokenizer = class {
         break;
       }
       default: {
-        token.systemId += String.fromCodePoint(cp11);
+        token.systemId += String.fromCodePoint(cp10);
       }
     }
   }
   // DOCTYPE system identifier (single-quoted) state
   //------------------------------------------------------------------
-  _stateDoctypeSystemIdentifierSingleQuoted(cp11) {
+  _stateDoctypeSystemIdentifierSingleQuoted(cp10) {
     const token = this.currentToken;
-    switch (cp11) {
+    switch (cp10) {
       case CODE_POINTS.APOSTROPHE: {
         this.state = State2.AFTER_DOCTYPE_SYSTEM_IDENTIFIER;
         break;
@@ -1453090,15 +1453090,15 @@ var Tokenizer = class {
         break;
       }
       default: {
-        token.systemId += String.fromCodePoint(cp11);
+        token.systemId += String.fromCodePoint(cp10);
       }
     }
   }
   // After DOCTYPE system identifier state
   //------------------------------------------------------------------
-  _stateAfterDoctypeSystemIdentifier(cp11) {
+  _stateAfterDoctypeSystemIdentifier(cp10) {
     const token = this.currentToken;
-    switch (cp11) {
+    switch (cp10) {
       case CODE_POINTS.SPACE:
       case CODE_POINTS.LINE_FEED:
       case CODE_POINTS.TABULATION:
@@ -1453120,15 +1453120,15 @@ var Tokenizer = class {
       default: {
         this._err(ERR.unexpectedCharacterAfterDoctypeSystemIdentifier);
         this.state = State2.BOGUS_DOCTYPE;
-        this._stateBogusDoctype(cp11);
+        this._stateBogusDoctype(cp10);
       }
     }
   }
   // Bogus DOCTYPE state
   //------------------------------------------------------------------
-  _stateBogusDoctype(cp11) {
+  _stateBogusDoctype(cp10) {
     const token = this.currentToken;
-    switch (cp11) {
+    switch (cp10) {
       case CODE_POINTS.GREATER_THAN_SIGN: {
         this.emitCurrentDoctype(token);
         this.state = State2.DATA;
@@ -1453148,8 +1453148,8 @@ var Tokenizer = class {
   }
   // CDATA section state
   //------------------------------------------------------------------
-  _stateCdataSection(cp11) {
-    switch (cp11) {
+  _stateCdataSection(cp10) {
+    switch (cp10) {
       case CODE_POINTS.RIGHT_SQUARE_BRACKET: {
         this.state = State2.CDATA_SECTION_BRACKET;
         break;
@@ -1453160,25 +1453160,25 @@ var Tokenizer = class {
         break;
       }
       default: {
-        this._emitCodePoint(cp11);
+        this._emitCodePoint(cp10);
       }
     }
   }
   // CDATA section bracket state
   //------------------------------------------------------------------
-  _stateCdataSectionBracket(cp11) {
-    if (cp11 === CODE_POINTS.RIGHT_SQUARE_BRACKET) {
+  _stateCdataSectionBracket(cp10) {
+    if (cp10 === CODE_POINTS.RIGHT_SQUARE_BRACKET) {
       this.state = State2.CDATA_SECTION_END;
     } else {
       this._emitChars("]");
       this.state = State2.CDATA_SECTION;
-      this._stateCdataSection(cp11);
+      this._stateCdataSection(cp10);
     }
   }
   // CDATA section end state
   //------------------------------------------------------------------
-  _stateCdataSectionEnd(cp11) {
-    switch (cp11) {
+  _stateCdataSectionEnd(cp10) {
+    switch (cp10) {
       case CODE_POINTS.GREATER_THAN_SIGN: {
         this.state = State2.DATA;
         break;
@@ -1453190,7 +1453190,7 @@ var Tokenizer = class {
       default: {
         this._emitChars("]]");
         this.state = State2.CDATA_SECTION;
-        this._stateCdataSection(cp11);
+        this._stateCdataSection(cp10);
       }
     }
   }
@@ -1453219,15 +1453219,15 @@ var Tokenizer = class {
   }
   // Ambiguos ampersand state
   //------------------------------------------------------------------
-  _stateAmbiguousAmpersand(cp11) {
-    if (isAsciiAlphaNumeric2(cp11)) {
-      this._flushCodePointConsumedAsCharacterReference(cp11);
+  _stateAmbiguousAmpersand(cp10) {
+    if (isAsciiAlphaNumeric2(cp10)) {
+      this._flushCodePointConsumedAsCharacterReference(cp10);
     } else {
-      if (cp11 === CODE_POINTS.SEMICOLON) {
+      if (cp10 === CODE_POINTS.SEMICOLON) {
         this._err(ERR.unknownNamedCharacterReference);
       }
       this.state = this.returnState;
-      this._callState(cp11);
+      this._callState(cp10);
     }
   }
 };
@@ -1499477,7 +1499477,7 @@ var CliContext = class {
     if (false) {
       this.logger.error("CLI_VERSION is not defined");
     }
-    return "3.44.0";
+    return "3.44.1";
   }
   getCliName() {
     if (false) {
@@ -1543972,7 +1543972,7 @@ var OpenRPCConverterContext3_1 = class extends AbstractConverterContext {
 };
 
 // ../workspace/lazy-fern-workspace/lib/OSSWorkspace.js
-var import_promises49 = require("fs/promises");
+var import_promises48 = require("fs/promises");
 
 // ../../commons/casings-generator/src/reserved.ts
 var RESERVED_KEYWORDS2 = {
@@ -1544788,60 +1544788,45 @@ function createLoggingExecutable(executable, { logger, ...loggingExecaOptions }
 }
 
 // ../workspace/lazy-fern-workspace/lib/protobuf/ProtobufIRGenerator.js
-var import_promises47 = require("fs/promises");
+var import_promises46 = require("fs/promises");
 var import_path32 = __toESM(require("path"), 1);
 var import_tmp_promise7 = __toESM(require_tmp_promise(), 1);
 
 // ../workspace/lazy-fern-workspace/lib/protobuf/utils.js
-var import_promises46 = require("fs/promises");
 var import_tmp_promise6 = __toESM(require_tmp_promise(), 1);
 function isNetworkError(errorMessage) {
-  return errorMessage.includes("server hosted at that remote is unavailable") || errorMessage.includes("failed to connect") || errorMessage.includes("network") || errorMessage.includes("ENOTFOUND") || errorMessage.includes("ETIMEDOUT") || errorMessage.includes("TIMEDOUT") || errorMessage.includes("timed out");
+  return errorMessage.includes("server hosted at that remote is unavailable") || errorMessage.includes("fetch failed") || errorMessage.includes("failed to connect") || errorMessage.includes("network") || errorMessage.includes("ENOTFOUND") || errorMessage.includes("ETIMEDOUT") || errorMessage.includes("TIMEDOUT") || errorMessage.includes("timed out") || errorMessage.includes("ECONNREFUSED") || errorMessage.includes("ECONNRESET") || errorMessage.includes("socket hang up");
 }
-async function detectAirGappedMode(absoluteFilepathToProtobufRoot, logger) {
-  const bufLockPath = join2(absoluteFilepathToProtobufRoot, RelativeFilePath2.of("buf.lock"));
-  let bufLockExists = false;
-  try {
-    await (0, import_promises46.access)(bufLockPath);
-    bufLockExists = true;
-    logger.debug(`Found buf.lock at: ${bufLockPath}`);
-  } catch {
-    logger.debug(`No buf.lock found at: ${bufLockPath}`);
+var airGapDetectionResult;
+var airGapDetectionPromise;
+async function detectAirGappedMode(url2, logger, timeoutMs = 5e3) {
+  if (airGapDetectionResult !== void 0) {
+    return airGapDetectionResult;
   }
-  if (!bufLockExists) {
-    return false;
+  if (airGapDetectionPromise == null) {
+    airGapDetectionPromise = performAirGapDetection(url2, logger, timeoutMs);
   }
-  const tmpDir = AbsoluteFilePath2.of((await import_tmp_promise6.default.dir()).path);
+  return airGapDetectionPromise;
+}
+async function performAirGapDetection(url2, logger, timeoutMs) {
+  logger.debug(`Detecting air-gapped mode by checking connectivity to ${url2}`);
   try {
-    const bufYamlPath = join2(absoluteFilepathToProtobufRoot, RelativeFilePath2.of("buf.yaml"));
-    try {
-      await (0, import_promises46.cp)(bufYamlPath, join2(tmpDir, RelativeFilePath2.of("buf.yaml")));
-      await (0, import_promises46.cp)(bufLockPath, join2(tmpDir, RelativeFilePath2.of("buf.lock")));
-    } catch {
-      return false;
-    }
-    try {
-      await runExeca(logger, "buf", ["dep", "update"], {
-        cwd: tmpDir,
-        stdio: "pipe",
-        timeout: 3e4
-        // 30 second timeout for detection
-      });
-      logger.debug("Network check succeeded - not in air-gapped mode");
-      return false;
-    } catch (error2) {
-      const errorMessage = error2 instanceof Error ? error2.message : String(error2);
-      if (isNetworkError(errorMessage)) {
-        logger.debug(`Network check failed - entering air-gapped mode: ${errorMessage.substring(0, 100)}`);
-        return true;
-      }
-      return false;
-    }
-  } finally {
-    try {
-      await (0, import_promises46.rm)(tmpDir, { recursive: true, force: true });
-    } catch {
+    await fetch(url2, {
+      method: "GET",
+      signal: AbortSignal.timeout(timeoutMs)
+    });
+    airGapDetectionResult = false;
+    logger.debug("Network check succeeded - not in air-gapped mode");
+    return false;
+  } catch (error2) {
+    const errorMessage = error2 instanceof Error ? error2.message : String(error2);
+    if (isNetworkError(errorMessage)) {
+      airGapDetectionResult = true;
+      logger.debug(`Network check failed - entering air-gapped mode: ${errorMessage}`);
+      return true;
     }
+    airGapDetectionResult = false;
+    return false;
   }
 }
 var PROTOBUF_GENERATOR_CONFIG_FILENAME = "buf.gen.yaml";
@@ -1544959,7 +1544944,7 @@ var ProtobufIRGenerator = class {
       this.context.logger.info(`Using buf export with version: ${version6}`);
       const tmpBufConfigFile = await import_tmp_promise7.default.file({ postfix: ".yaml" });
       const configContent = version6 === "v1" ? PROTOBUF_EXPORT_CONFIG_V1 : PROTOBUF_EXPORT_CONFIG_V2;
-      await (0, import_promises47.writeFile)(tmpBufConfigFile.path, configContent, "utf8");
+      await (0, import_promises46.writeFile)(tmpBufConfigFile.path, configContent, "utf8");
       try {
         const result = await runExeca(this.context.logger, "buf", [
           "export",
@@ -1544988,7 +1544973,7 @@ var ProtobufIRGenerator = class {
     }
   }
   async copyProtobufFilesFromRoot({ protobufGeneratorConfigPath, absoluteFilepathToProtobufRoot }) {
-    await (0, import_promises47.cp)(absoluteFilepathToProtobufRoot, protobufGeneratorConfigPath, {
+    await (0, import_promises46.cp)(absoluteFilepathToProtobufRoot, protobufGeneratorConfigPath, {
       recursive: true,
       filter: (src) => {
         const basename5 = import_path32.default.basename(src);
@@ -1544997,7 +1544982,7 @@ var ProtobufIRGenerator = class {
     });
   }
   async setupRemainingProtobufConfig({ protobufGeneratorConfigPath }) {
-    await (0, import_promises47.writeFile)(join2(protobufGeneratorConfigPath, RelativeFilePath2.of("package.json")), PROTOBUF_MODULE_PACKAGE_JSON);
+    await (0, import_promises46.writeFile)(join2(protobufGeneratorConfigPath, RelativeFilePath2.of("package.json")), PROTOBUF_MODULE_PACKAGE_JSON);
     await runExeca(void 0, "npm", ["install"], {
       cwd: protobufGeneratorConfigPath,
       stdout: "ignore",
@@ -1545008,10 +1544993,10 @@ var ProtobufIRGenerator = class {
       stdout: "ignore",
       stderr: "pipe"
     });
-    await (0, import_promises47.writeFile)(join2(protobufGeneratorConfigPath, RelativeFilePath2.of(PROTOBUF_GENERATOR_CONFIG_FILENAME)), PROTOBUF_GEN_CONFIG);
+    await (0, import_promises46.writeFile)(join2(protobufGeneratorConfigPath, RelativeFilePath2.of(PROTOBUF_GENERATOR_CONFIG_FILENAME)), PROTOBUF_GEN_CONFIG);
     const shellProxyPath = join2(protobufGeneratorConfigPath, RelativeFilePath2.of(PROTOBUF_SHELL_PROXY_FILENAME));
-    await (0, import_promises47.writeFile)(shellProxyPath, PROTOBUF_SHELL_PROXY);
-    await (0, import_promises47.chmod)(shellProxyPath, 493);
+    await (0, import_promises46.writeFile)(shellProxyPath, PROTOBUF_SHELL_PROXY);
+    await (0, import_promises46.chmod)(shellProxyPath, 493);
   }
   async doGenerateLocal({ cwd: cwd2, deps }) {
     const which = createLoggingExecutable("which", {
@@ -1545033,13 +1545018,13 @@ var ProtobufIRGenerator = class {
       stderr: "pipe"
     });
     try {
-      await (0, import_promises47.writeFile)(bufYamlPath, configContent);
+      await (0, import_promises46.writeFile)(bufYamlPath, configContent);
       if (deps.length > 0) {
         if (this.isAirGapped) {
           this.context.logger.debug("Air-gapped mode: skipping buf dep update");
           const bufLockPath = join2(cwd2, RelativeFilePath2.of("buf.lock"));
           try {
-            await (0, import_promises47.access)(bufLockPath);
+            await (0, import_promises46.access)(bufLockPath);
           } catch {
             this.context.failAndThrow("Air-gapped mode requires a pre-cached buf.lock file. Please run 'buf dep update' at build time to cache dependencies.");
           }
@@ -1545051,9 +1545036,9 @@ var ProtobufIRGenerator = class {
       if (bufGenerateResult.exitCode !== 0) {
         this.context.failAndThrow(bufGenerateResult.stderr);
       }
-      await (0, import_promises47.unlink)(bufYamlPath);
+      await (0, import_promises46.unlink)(bufYamlPath);
     } catch (error2) {
-      await (0, import_promises47.unlink)(bufYamlPath);
+      await (0, import_promises46.unlink)(bufYamlPath);
       throw error2;
     }
     return join2(cwd2, RelativeFilePath2.of(PROTOBUF_GENERATOR_OUTPUT_FILEPATH));
@@ -1545064,7 +1545049,7 @@ var ProtobufIRGenerator = class {
 };
 
 // ../workspace/lazy-fern-workspace/lib/protobuf/ProtobufOpenAPIGenerator.js
-var import_promises48 = require("fs/promises");
+var import_promises47 = require("fs/promises");
 var import_tmp_promise8 = __toESM(require_tmp_promise(), 1);
 var PROTOBUF_GENERATOR_CONFIG_FILENAME2 = "buf.gen.yaml";
 var PROTOBUF_GENERATOR_OUTPUT_PATH2 = "output";
@@ -1545105,8 +1545090,8 @@ var ProtobufOpenAPIGenerator = class {
   }
   async setupProtobufGeneratorConfig({ absoluteFilepathToProtobufRoot, relativeFilepathToProtobufRoot }) {
     const protobufGeneratorConfigPath = AbsoluteFilePath2.of((await import_tmp_promise8.default.dir()).path);
-    await (0, import_promises48.cp)(absoluteFilepathToProtobufRoot, protobufGeneratorConfigPath, { recursive: true });
-    await (0, import_promises48.writeFile)(join2(protobufGeneratorConfigPath, RelativeFilePath2.of(PROTOBUF_GENERATOR_CONFIG_FILENAME2)), getProtobufGeneratorConfig({ relativeFilepathToProtobufRoot }));
+    await (0, import_promises47.cp)(absoluteFilepathToProtobufRoot, protobufGeneratorConfigPath, { recursive: true });
+    await (0, import_promises47.writeFile)(join2(protobufGeneratorConfigPath, RelativeFilePath2.of(PROTOBUF_GENERATOR_CONFIG_FILENAME2)), getProtobufGeneratorConfig({ relativeFilepathToProtobufRoot }));
     return protobufGeneratorConfigPath;
   }
   async doGenerateLocal({ cwd: cwd2, target, deps, existingBufLockContents }) {
@@ -1545137,15 +1545122,15 @@ var ProtobufOpenAPIGenerator = class {
       stderr: "pipe"
     });
     try {
-      await (0, import_promises48.writeFile)(bufYamlPath, configContent);
+      await (0, import_promises47.writeFile)(bufYamlPath, configContent);
       if (existingBufLockContents != null) {
-        await (0, import_promises48.writeFile)(bufLockPath, existingBufLockContents);
+        await (0, import_promises47.writeFile)(bufLockPath, existingBufLockContents);
         cleanupBufLock = true;
       } else if (deps.length > 0) {
         if (this.isAirGapped) {
           this.context.logger.debug("Air-gapped mode: skipping buf dep update");
           try {
-            await (0, import_promises48.access)(bufLockPath);
+            await (0, import_promises47.access)(bufLockPath);
           } catch {
             this.context.failAndThrow("Air-gapped mode requires a pre-cached buf.lock file. Please run 'buf dep update' at build time to cache dependencies.");
           }
@@ -1545153,7 +1545138,7 @@ var ProtobufOpenAPIGenerator = class {
           await buf(["dep", "update"]);
         }
         try {
-          bufLockContents = await (0, import_promises48.readFile)(bufLockPath, "utf-8");
+          bufLockContents = await (0, import_promises47.readFile)(bufLockPath, "utf-8");
         } catch {
           bufLockContents = void 0;
         }
@@ -1545163,14 +1545148,14 @@ var ProtobufOpenAPIGenerator = class {
         this.context.failAndThrow(bufGenerateResult.stderr);
       }
       if (cleanupBufLock) {
-        await (0, import_promises48.unlink)(bufLockPath);
+        await (0, import_promises47.unlink)(bufLockPath);
       }
-      await (0, import_promises48.unlink)(bufYamlPath);
+      await (0, import_promises47.unlink)(bufYamlPath);
     } catch (error2) {
       if (cleanupBufLock) {
-        await (0, import_promises48.unlink)(bufLockPath);
+        await (0, import_promises47.unlink)(bufLockPath);
       }
-      await (0, import_promises48.unlink)(bufYamlPath);
+      await (0, import_promises47.unlink)(bufYamlPath);
       throw error2;
     }
     return {
@@ -1545470,7 +1545455,7 @@ var OSSWorkspace = class _OSSWorkspace extends BaseOpenAPIWorkspace {
             local: true,
             deps: spec.dependencies
           });
-          const result = await (0, import_promises49.readFile)(protobufIRFilepath, "utf-8");
+          const result = await (0, import_promises48.readFile)(protobufIRFilepath, "utf-8");
           const casingsGenerator = constructCasingsGenerator2({
             generationLanguage: "typescript",
             keywords: void 0,
@@ -1545727,7 +1545712,7 @@ function parseIssue(issue) {
 }
 
 // ../workspace/loader/lib/listFernFiles.js
-var import_promises50 = require("fs/promises");
+var import_promises49 = require("fs/promises");
 async function listFernFiles2(root6, extensionGlob) {
   const files = [];
   for (const absoluteFilepath of await listFiles(root6, extensionGlob)) {
@@ -1545742,7 +1545727,7 @@ async function createFernFile2({ relativeFilepath, absoluteFilepath }) {
   return {
     relativeFilepath,
     absoluteFilepath,
-    fileContents: (await (0, import_promises50.readFile)(absoluteFilepath)).toString()
+    fileContents: (await (0, import_promises49.readFile)(absoluteFilepath)).toString()
   };
 }
 
@@ -1545994,7 +1545979,7 @@ async function loadAPIWorkspace({ absolutePathToWorkspace, context: context2, cl
 }
 
 // ../workspace/loader/lib/loadDocsWorkspace.js
-var import_promises51 = require("fs/promises");
+var import_promises50 = require("fs/promises");
 
 // ../workspace/loader/lib/docs-yml.schema.json
 var docs_yml_schema_exports = {};
@@ -1551155,7 +1551140,7 @@ async function loadDocsConfiguration({ absolutePathToDocsDefinition, context: co
   });
 }
 async function loadRawDocsConfiguration({ absolutePathOfConfiguration, context: context2 }) {
-  const contentsStr = await (0, import_promises51.readFile)(absolutePathOfConfiguration);
+  const contentsStr = await (0, import_promises50.readFile)(absolutePathOfConfiguration);
   const contentsJson = jsYaml.load(contentsStr.toString());
   const result = validateAgainstJsonSchema(contentsJson, docs_yml_schema_exports, {
     filePath: absolutePathOfConfiguration
@@ -1551184,7 +1551169,7 @@ ${result.error?.message ?? "Unknown error"}`);
 }
 
 // ../project-loader/lib/loadProject.js
-var import_promises52 = require("fs/promises");
+var import_promises51 = require("fs/promises");
 async function loadProject({ context: context2, nameOverride, ...args }) {
   const fernDirectory = await getFernDirectory(nameOverride);
   if (fernDirectory == null) {
@@ -1551239,7 +1551224,7 @@ async function loadApis({ cliName, fernDirectory, context: context2, cliVersion,
   const apisDirectory = join2(fernDirectory, RelativeFilePath2.of(APIS_DIRECTORY));
   const apisDirectoryExists = await doesPathExist(apisDirectory);
   if (apisDirectoryExists) {
-    const apiDirectoryContents = await (0, import_promises52.readdir)(apisDirectory, { withFileTypes: true });
+    const apiDirectoryContents = await (0, import_promises51.readdir)(apisDirectory, { withFileTypes: true });
     const apiWorkspaceDirectoryNames = apiDirectoryContents.reduce((all9, item) => {
       if (item.isDirectory()) {
         all9.push(item.name);
@@ -1551316,10 +1551301,10 @@ async function loadProjectAndRegisterWorkspacesWithContext(cliContext, args, reg
 
 // src/cliV2.ts
 var import_generators_sdk4 = __toESM(require_generators_sdk(), 1);
-var import_promises57 = require("fs/promises");
+var import_promises56 = require("fs/promises");
 
 // src/commands/generator-list/getGeneratorList.ts
-var import_promises53 = require("fs/promises");
+var import_promises52 = require("fs/promises");
 var GenerationModeFilter = {
   GitHub: "github",
   Local: "local-file-system",
@@ -1551379,7 +1551364,7 @@ async function getGeneratorList({
     return;
   }
   try {
-    await (0, import_promises53.writeFile)(outputLocation, generatorsListYaml);
+    await (0, import_promises52.writeFile)(outputLocation, generatorsListYaml);
   } catch (error2) {
     cliContext.failAndThrow(`Could not write file to the specified location: ${outputLocation}`, error2);
   }
@@ -1551445,7 +1551430,7 @@ async function getGeneratorMetadata({
 }
 
 // src/commands/organization/getOrganization.ts
-var import_promises54 = require("fs/promises");
+var import_promises53 = require("fs/promises");
 async function getOrganization({
   project,
   outputLocation,
@@ -1551457,20 +1551442,20 @@ async function getOrganization({
     return;
   }
   try {
-    await (0, import_promises54.writeFile)(outputLocation, org);
+    await (0, import_promises53.writeFile)(outputLocation, org);
   } catch (error2) {
     context2.failAndThrow(`Could not write file to the specified location: ${outputLocation}`, error2);
   }
 }
 
 // src/commands/upgrade/upgradeGenerator.ts
-var import_promises56 = require("fs/promises");
+var import_promises55 = require("fs/promises");
 var import_path34 = __toESM(require("path"), 1);
 var import_semver8 = __toESM(require_semver2(), 1);
 var import_yaml = __toESM(require_dist4(), 1);
 
 // src/commands/upgrade/migrations/loader.ts
-var import_promises55 = require("fs/promises");
+var import_promises54 = require("fs/promises");
 var import_os4 = require("os");
 var import_path33 = require("path");
 var import_semver7 = __toESM(require_semver2(), 1);
@@ -1551481,7 +1551466,7 @@ function getMigrationCacheDir() {
 async function loadMigrationModule(params2) {
   const { generatorName, logger } = params2;
   const cacheDir = getMigrationCacheDir();
-  await (0, import_promises55.mkdir)(cacheDir, { recursive: true });
+  await (0, import_promises54.mkdir)(cacheDir, { recursive: true });
   try {
     await loggingExeca(logger, "npm", [
       "install",
@@ -1551494,7 +1551479,7 @@ async function loadMigrationModule(params2) {
     ]);
     const packageDir = (0, import_path33.join)(cacheDir, "node_modules", MIGRATION_PACKAGE_NAME);
     const packageJsonPath = (0, import_path33.join)(packageDir, "package.json");
-    const packageJsonContent = await (0, import_promises55.readFile)(packageJsonPath, "utf-8");
+    const packageJsonContent = await (0, import_promises54.readFile)(packageJsonPath, "utf-8");
     const packageJson2 = JSON.parse(packageJsonContent);
     if (packageJson2.main == null) {
       throw new Error(`No main field found in package.json for ${MIGRATION_PACKAGE_NAME}`);
@@ -1551645,7 +1551630,7 @@ async function loadAndUpdateGenerators({
     context2.logger.debug("Generators configuration file was not found, no generators to upgrade.");
     return { updatedConfiguration: void 0, skippedMajorUpgrades: [], appliedUpgrades: [], alreadyUpToDate: [] };
   }
-  const contents = await (0, import_promises56.readFile)(filepath);
+  const contents = await (0, import_promises55.readFile)(filepath);
   context2.logger.debug(`Found generators: ${contents.toString()}`);
   const parsedDocument = import_yaml.default.parseDocument(contents.toString());
   const generatorGroups = parsedDocument.get("groups");
@@ -1551826,7 +1551811,7 @@ async function upgradeGenerator({
           absolutePathToWorkspace: workspace.absoluteFilePath
         });
         if (absolutePathToGeneratorsConfiguration != null && result.updatedConfiguration != null) {
-          await (0, import_promises56.writeFile)(absolutePathToGeneratorsConfiguration, result.updatedConfiguration);
+          await (0, import_promises55.writeFile)(absolutePathToGeneratorsConfiguration, result.updatedConfiguration);
         }
         allSkippedMajorUpgrades.push(...result.skippedMajorUpgrades);
         if (result.appliedUpgrades.length > 0) {
@@ -1552180,7 +1552165,7 @@ function addGeneratorCommands(cli, cliContext) {
         }
         if (argv.output) {
           try {
-            await (0, import_promises57.writeFile)(argv.output, JSON.stringify(generatorMetadata, null, 2));
+            await (0, import_promises56.writeFile)(argv.output, JSON.stringify(generatorMetadata, null, 2));
           } catch (error2) {
             cliContext.failAndThrow(
               `Could not write file to the specified location: ${argv.output}`,
@@ -1552194,7 +1552179,7 @@ function addGeneratorCommands(cli, cliContext) {
 }
 
 // src/commands/add-generator/addGeneratorToWorkspaces.ts
-var import_promises58 = require("fs/promises");
+var import_promises57 = require("fs/promises");
 async function addGeneratorToWorkspaces({
   project: { apiWorkspaces },
   generatorName,
@@ -1552221,7 +1552206,7 @@ async function addGeneratorToWorkspaces({
         if (absolutePathToGeneratorsConfiguration == null) {
           return;
         }
-        await (0, import_promises58.writeFile)(
+        await (0, import_promises57.writeFile)(
           absolutePathToGeneratorsConfiguration,
           "# yaml-language-server: $schema=https://schema.buildwithfern.dev/generators-yml.json\n" + jsYaml.dump(newConfiguration)
         );
@@ -1552232,7 +1552217,7 @@ async function addGeneratorToWorkspaces({
 }
 
 // src/commands/diff/diff.ts
-var import_promises59 = require("fs/promises");
+var import_promises58 = require("fs/promises");
 var import_semver9 = __toESM(require_semver2(), 1);
 async function diff({
   context: context2,
@@ -1552275,7 +1552260,7 @@ async function readIr({
     context2.failWithoutThrowing(`File not found: ${absoluteFilepath}`);
     throw new FernCliError();
   }
-  const ir14 = await (0, import_promises59.readFile)(absoluteFilepath, "utf-8");
+  const ir14 = await (0, import_promises58.readFile)(absoluteFilepath, "utf-8");
   const parsed = serialization_exports4.IntermediateRepresentation.parse(JSON.parse(ir14));
   if (!parsed.ok) {
     context2.failWithoutThrowing(`Invalid --${flagName}; expected a filepath containing a valid IR`);
@@ -1570028,9 +1570013,9 @@ function replaceFrontmatterImagesforLogo(data2, mapImage) {
 }
 
 // ../docs-markdown-utils/lib/replaceReferencedCode.js
-var import_promises60 = require("fs/promises");
+var import_promises59 = require("fs/promises");
 async function defaultFileLoader(filepath) {
-  const file = await (0, import_promises60.readFile)(filepath);
+  const file = await (0, import_promises59.readFile)(filepath);
   return file.toString();
 }
 function isUrl2(src) {
@@ -1570197,10 +1570182,10 @@ ${replacement}
 }
 
 // ../docs-markdown-utils/lib/replaceReferencedMarkdown.js
-var import_promises61 = require("fs/promises");
+var import_promises60 = require("fs/promises");
 var import_gray_matter5 = __toESM(require_gray_matter(), 1);
 async function defaultMarkdownLoader(filepath) {
-  const { content: content5 } = (0, import_gray_matter5.default)(await (0, import_promises61.readFile)(filepath));
+  const { content: content5 } = (0, import_gray_matter5.default)(await (0, import_promises60.readFile)(filepath));
   return content5;
 }
 function extractAttributes(markdownTag) {
@@ -1577951,7 +1577936,7 @@ function computeServiceTypeReferenceInfo(irGraph) {
 // ../docs-resolver/lib/DocsDefinitionResolver.js
 var import_dayjs3 = __toESM(require_dayjs_min(), 1);
 var import_utc3 = __toESM(require_utc(), 1);
-var import_promises65 = require("fs/promises");
+var import_promises64 = require("fs/promises");
 var import_gray_matter6 = __toESM(require_gray_matter(), 1);
 
 // ../../../node_modules/.pnpm/@fern-api+ui-core-utils@0.129.4-b6c699ad2/node_modules/@fern-api/ui-core-utils/dist/assertNever.js
@@ -1579676,10 +1579661,10 @@ var HeapAsync = (
     };
     HeapAsync2.prototype._applyLimit = function() {
       if (this._limit && this._limit < this.heapArray.length) {
-        var rm16 = this.heapArray.length - this._limit;
-        while (rm16) {
+        var rm15 = this.heapArray.length - this._limit;
+        while (rm15) {
           this.heapArray.pop();
-          --rm16;
+          --rm15;
         }
       }
     };
@@ -1580508,10 +1580493,10 @@ var Heap = (
     };
     Heap2.prototype._applyLimit = function() {
       if (this._limit > 0 && this._limit < this.heapArray.length) {
-        var rm16 = this.heapArray.length - this._limit;
-        while (rm16) {
+        var rm15 = this.heapArray.length - this._limit;
+        while (rm15) {
           this.heapArray.pop();
-          --rm16;
+          --rm15;
         }
       }
     };
@@ -1582065,7 +1582050,7 @@ var OpenAPIPruner = class {
 };
 
 // ../register/lib/ai-example-enhancer/enhanceExamplesWithAI.js
-var import_promises64 = require("fs/promises");
+var import_promises63 = require("fs/promises");
 
 // ../register/lib/ai-example-enhancer/lambdaClient.js
 var DEFAULT_AI_ENHANCEMENT_MAX_RETRIES = 0;
@@ -1582142,6 +1582127,14 @@ var LambdaExampleEnhancer = class {
         enhancedResponseExample: request6.originalResponseExample
       };
     }
+    const isAirGapped = await detectAirGappedMode(`${this.venusOrigin}/health`, this.context.logger);
+    if (isAirGapped) {
+      this.context.logger.debug("Skipping AI example enhancement in air-gapped environment");
+      return {
+        enhancedRequestExample: request6.originalRequestExample,
+        enhancedResponseExample: request6.originalResponseExample
+      };
+    }
     let jwt3;
     try {
       jwt3 = await this.getJwt();
@@ -1582274,12 +1582267,12 @@ var SpinnerStatusCoordinator = class _SpinnerStatusCoordinator {
 };
 
 // ../register/lib/ai-example-enhancer/validateAiExamples.js
-var import_promises62 = require("fs/promises");
+var import_promises61 = require("fs/promises");
 async function parseAiExamplesOverride(sourceFilePath, context2) {
   const overrideFilePath = AbsoluteFilePath2.of(`${dirname4(sourceFilePath)}/ai_examples_override.yml`);
   const aiExamples = [];
   try {
-    const existingContent = await (0, import_promises62.readFile)(overrideFilePath, "utf-8");
+    const existingContent = await (0, import_promises61.readFile)(overrideFilePath, "utf-8");
     const parsed = jsYaml.load(existingContent);
     if (parsed && typeof parsed === "object" && "paths" in parsed) {
       const paths = parsed.paths;
@@ -1582328,7 +1582321,7 @@ async function validateAiExamplesFromFile({ sourceFilePath, context: context2 })
   }
   let spec;
   try {
-    const specContent = await (0, import_promises62.readFile)(sourceFilePath, "utf-8");
+    const specContent = await (0, import_promises61.readFile)(sourceFilePath, "utf-8");
     try {
       spec = JSON.parse(specContent);
     } catch {
@@ -1582387,7 +1582380,7 @@ async function removeInvalidAiExamples({ sourceFilePath, context: context2 }) {
   }
   const overrideFilePath = AbsoluteFilePath2.of(`${dirname4(sourceFilePath)}/ai_examples_override.yml`);
   try {
-    const existingContent = await (0, import_promises62.readFile)(overrideFilePath, "utf-8");
+    const existingContent = await (0, import_promises61.readFile)(overrideFilePath, "utf-8");
     const parsed = jsYaml.load(existingContent);
     if (!parsed || !parsed.paths) {
       return {
@@ -1582431,12 +1582424,12 @@ async function removeInvalidAiExamples({ sourceFilePath, context: context2 }) {
 }
 
 // ../register/lib/ai-example-enhancer/writeAiExamplesOverride.js
-var import_promises63 = require("fs/promises");
+var import_promises62 = require("fs/promises");
 async function loadExistingOverrideCoverage(sourceFilePath, context2) {
   const overrideFilePath = AbsoluteFilePath2.of(`${dirname4(sourceFilePath)}/ai_examples_override.yml`);
   const coveredEndpoints = /* @__PURE__ */ new Set();
   try {
-    const existingContent = await (0, import_promises63.readFile)(overrideFilePath, "utf-8");
+    const existingContent = await (0, import_promises62.readFile)(overrideFilePath, "utf-8");
     const parsed = jsYaml.load(existingContent);
     if (parsed && typeof parsed === "object" && "paths" in parsed) {
       const paths = parsed.paths;
@@ -1582515,7 +1582508,7 @@ async function writeAiExamplesOverride({ enhancedExamples, sourceFilePath, conte
   try {
     let existingOverride = {};
     try {
-      const existingContent = await (0, import_promises63.readFile)(overrideFilePath, "utf-8");
+      const existingContent = await (0, import_promises62.readFile)(overrideFilePath, "utf-8");
       const parsed = jsYaml.load(existingContent);
       if (parsed && typeof parsed === "object") {
         existingOverride = parsed;
@@ -1582558,7 +1582551,7 @@ async function writeAiExamplesOverride({ enhancedExamples, sourceFilePath, conte
       lineWidth: -1,
       noRefs: true
     });
-    await (0, import_promises63.writeFile)(overrideFilePath, yamlContent, "utf-8");
+    await (0, import_promises62.writeFile)(overrideFilePath, yamlContent, "utf-8");
     context2.logger.debug(`AI enhanced examples written to: ${overrideFilePath}`);
   } catch (error2) {
     context2.logger.warn(`Failed to write AI examples override file: ${error2}`);
@@ -1582761,7 +1582754,7 @@ async function performAIEnhancement(apiDefinition, config2, context2, token, org
   let endpointsNeedingRegeneration = /* @__PURE__ */ new Set();
   if (sourceFilePath != null) {
     try {
-      const specContent = await (0, import_promises64.readFile)(sourceFilePath, "utf-8");
+      const specContent = await (0, import_promises63.readFile)(sourceFilePath, "utf-8");
       if (!isOpenApiSpec(specContent)) {
         context2.logger.debug("Non-OpenAPI spec detected, skipping AI example enhancement");
         return apiDefinition;
@@ -1585567,7 +1585560,7 @@ var DocsDefinitionResolver = class {
       const jsFilePaths = /* @__PURE__ */ new Set();
       await Promise.all(this._parsedDocsConfig.experimental.mdxComponents.map(async (filepath) => {
         const absoluteFilePath = resolve5(this.docsWorkspace.absoluteFilePath, filepath);
-        const stats = await (0, import_promises65.stat)(absoluteFilePath);
+        const stats = await (0, import_promises64.stat)(absoluteFilePath);
         if (stats.isDirectory()) {
           const files = await listFiles(absoluteFilePath, "{js,ts,jsx,tsx,md,mdx}");
           files.forEach((file) => {
@@ -1585579,7 +1585572,7 @@ var DocsDefinitionResolver = class {
       }));
       jsFiles = Object.fromEntries(await Promise.all([...jsFilePaths].map(async (filePath) => {
         const relativeFilePath = this.toRelativeFilepath(filePath);
-        const contents = (await (0, import_promises65.readFile)(filePath)).toString();
+        const contents = (await (0, import_promises64.readFile)(filePath)).toString();
         return [relativeFilePath, contents];
       })));
       const mdxTime = performance.now() - mdxStart;
@@ -1593616,7 +1593609,7 @@ async function generateFdrFromOpenApiWorkspace(workspace, context2) {
 // ../docs-preview/lib/runAppPreviewServer.js
 var import_cors = __toESM(require_lib16(), 1);
 var import_express = __toESM(require_express3(), 1);
-var import_promises71 = require("fs/promises");
+var import_promises70 = require("fs/promises");
 var import_http6 = __toESM(require("http"), 1);
 var import_path39 = __toESM(require("path"), 1);
 
@@ -1595288,13 +1595281,13 @@ var watcher_default = Watcher;
 init_wrapper();
 
 // ../docs-preview/lib/DebugLogger.js
-var import_promises66 = require("fs/promises");
+var import_promises65 = require("fs/promises");
 var import_os5 = require("os");
 var import_path37 = __toESM(require("path"), 1);
 var LOCAL_STORAGE_FOLDER4 = ".fern-dev";
 var LOGS_FOLDER_NAME = "logs";
 function getCliSource() {
-  const version6 = "3.44.0";
+  const version6 = "3.44.1";
   return `cli@${version6}`;
 }
 var DebugLogger = class {
@@ -1595314,7 +1595307,7 @@ var DebugLogger = class {
     const localStorageFolder = join2(AbsoluteFilePath2.of((0, import_os5.homedir)()), RelativeFilePath2.of(LOCAL_STORAGE_FOLDER4));
     const logsDir = join2(localStorageFolder, RelativeFilePath2.of(LOGS_FOLDER_NAME));
     if (!await doesPathExist(logsDir)) {
-      await (0, import_promises66.mkdir)(logsDir, { recursive: true });
+      await (0, import_promises65.mkdir)(logsDir, { recursive: true });
     }
     const timestamp2 = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
     const logFileName = `${timestamp2}.debug.log`;
@@ -1595327,7 +1595320,7 @@ var DebugLogger = class {
       "================================================================================",
       ""
     ].join("\n");
-    await (0, import_promises66.writeFile)(this.logFilePath, header, "utf-8");
+    await (0, import_promises65.writeFile)(this.logFilePath, header, "utf-8");
     this.initialized = true;
   }
   /**
@@ -1595345,7 +1595338,7 @@ var DebugLogger = class {
     }
     const line = JSON.stringify(entry) + "\n";
     try {
-      await (0, import_promises66.appendFile)(this.logFilePath, line, "utf-8");
+      await (0, import_promises65.appendFile)(this.logFilePath, line, "utf-8");
     } catch (error2) {
     }
   }
@@ -1595469,7 +1595462,7 @@ var DebugLogger = class {
 // ../docs-preview/lib/downloadLocalDocsBundle.js
 var import_cli_progress = __toESM(require_cli_progress(), 1);
 var import_decompress = __toESM(require_decompress(), 1);
-var import_promises67 = require("fs/promises");
+var import_promises66 = require("fs/promises");
 var import_os6 = require("os");
 var import_tmp_promise9 = __toESM(require_tmp_promise(), 1);
 var import_xml2js = __toESM(require_xml2js(), 1);
@@ -1595557,7 +1595550,7 @@ async function downloadBundle({ bucketUrl, logger, preferCached, app = false, tr
     let currentETag = void 0;
     if (currentETagExists) {
       logger.debug("Reading existing ETag");
-      currentETag = (await (0, import_promises67.readFile)(eTagFilepath)).toString();
+      currentETag = (await (0, import_promises66.readFile)(eTagFilepath)).toString();
     }
     if (currentETag != null && currentETag === eTag) {
       logger.debug("ETag matches. Using already downloaded bundle");
@@ -1595621,16 +1595614,16 @@ async function downloadBundle({ bucketUrl, logger, preferCached, app = false, tr
       }
     }
     const nodeBuffer = Buffer.concat(chunks);
-    await (0, import_promises67.writeFile)(outputZipPath, new Uint8Array(nodeBuffer));
+    await (0, import_promises66.writeFile)(outputZipPath, new Uint8Array(nodeBuffer));
     logger.debug(`Wrote ${tryTar ? "output.tar.gz" : "output.zip"} to ${outputZipPath}`);
     const absolutePathToPreviewFolder = getPathToPreviewFolder({ app });
     if (await doesPathExist(absolutePathToPreviewFolder)) {
       logger.debug(`Removing previously cached bundle at: ${absolutePathToPreviewFolder}`);
-      await (0, import_promises67.rm)(absolutePathToPreviewFolder, { recursive: true });
+      await (0, import_promises66.rm)(absolutePathToPreviewFolder, { recursive: true });
     }
-    await (0, import_promises67.mkdir)(absolutePathToPreviewFolder, { recursive: true });
+    await (0, import_promises66.mkdir)(absolutePathToPreviewFolder, { recursive: true });
     const absolutePathToBundleFolder = getPathToBundleFolder({ app });
-    await (0, import_promises67.mkdir)(absolutePathToBundleFolder, { recursive: true });
+    await (0, import_promises66.mkdir)(absolutePathToBundleFolder, { recursive: true });
     logger.debug(`Decompressing bundle from ${outputZipPath} to ${absolutePathToBundleFolder}`);
     let unzipProgressBar;
     let unzipInterval;
@@ -1595665,7 +1595658,7 @@ async function downloadBundle({ bucketUrl, logger, preferCached, app = false, tr
         unzipProgressBar.stop();
       }
     }
-    await (0, import_promises67.writeFile)(eTagFilepath, eTag);
+    await (0, import_promises66.writeFile)(eTagFilepath, eTag);
     logger.debug(`Downloaded bundle to ${absolutePathToBundleFolder}`);
     if (app) {
       logger.debug("Checking if pnpm is installed");
@@ -1595747,15 +1595740,15 @@ async function downloadBundle({ bucketUrl, logger, preferCached, app = false, tr
         }
         if (!pnpmfileExists) {
           logger.debug(`Writing pnpmfile.cjs at ${pnpmfilePath}`);
-          await (0, import_promises67.writeFile)(pnpmfilePath, PNPMFILE_CJS_CONTENTS);
+          await (0, import_promises66.writeFile)(pnpmfilePath, PNPMFILE_CJS_CONTENTS);
         }
         if (!npmrcExists) {
           logger.debug(`Writing .npmrc at ${npmrcPath}`);
-          await (0, import_promises67.writeFile)(npmrcPath, NPMRC_CONTENTS);
+          await (0, import_promises66.writeFile)(npmrcPath, NPMRC_CONTENTS);
         }
         if (instrumentationJsExists) {
           logger.debug(`Removing instrumentation.js at ${absPathToInstrumentationJs}`);
-          await (0, import_promises67.rm)(absPathToInstrumentationJs);
+          await (0, import_promises66.rm)(absPathToInstrumentationJs);
         }
         try {
           logger.debug("Running pnpm install within standalone");
@@ -1595775,7 +1595768,7 @@ async function downloadBundle({ bucketUrl, logger, preferCached, app = false, tr
     logger.error(`Error: ${error2}`);
     const absolutePathToPreviewFolder = getPathToPreviewFolder({ app });
     if (await doesPathExist(absolutePathToPreviewFolder)) {
-      await (0, import_promises67.rm)(absolutePathToPreviewFolder, { recursive: true });
+      await (0, import_promises66.rm)(absolutePathToPreviewFolder, { recursive: true });
     }
     logger.debug(`Removing incomplete bundle: rm -rf ${absolutePathToPreviewFolder}`);
     return {
@@ -1595785,7 +1595778,7 @@ async function downloadBundle({ bucketUrl, logger, preferCached, app = false, tr
 }
 
 // ../docs-preview/lib/previewDocs.js
-var import_promises70 = require("fs/promises");
+var import_promises69 = require("fs/promises");
 var import_gray_matter10 = __toESM(require_gray_matter(), 1);
 
 // ../docs-markdown-utils/src/extract-literals.ts
@@ -1596628,9 +1596621,9 @@ function replaceFrontmatterImagesforLogo2(data2, mapImage) {
 }
 
 // ../docs-markdown-utils/src/replaceReferencedCode.ts
-var import_promises68 = require("fs/promises");
+var import_promises67 = require("fs/promises");
 async function defaultFileLoader2(filepath) {
-  const file = await (0, import_promises68.readFile)(filepath);
+  const file = await (0, import_promises67.readFile)(filepath);
   return file.toString();
 }
 function isUrl3(src) {
@@ -1596804,10 +1596797,10 @@ ${replacement}
 }
 
 // ../docs-markdown-utils/src/replaceReferencedMarkdown.ts
-var import_promises69 = require("fs/promises");
+var import_promises68 = require("fs/promises");
 var import_gray_matter9 = __toESM(require_gray_matter(), 1);
 async function defaultMarkdownLoader2(filepath) {
-  const { content: content5 } = (0, import_gray_matter9.default)(await (0, import_promises69.readFile)(filepath));
+  const { content: content5 } = (0, import_gray_matter9.default)(await (0, import_promises68.readFile)(filepath));
   return content5;
 }
 function extractAttributes2(markdownTag) {
@@ -1597006,7 +1596999,7 @@ async function getPreviewDocsDefinition({ domain: domain2, project, context: con
         navAffectingChange = true;
         continue;
       }
-      const markdown = (await (0, import_promises70.readFile)(absoluteFilePath)).toString();
+      const markdown = (await (0, import_promises69.readFile)(absoluteFilePath)).toString();
       const isNewFile = previousValue == null;
       if (isNewFile) {
         navAffectingChange = true;
@@ -1597394,7 +1597387,7 @@ var SnippetDependencyTracker = class {
       const markdownFiles = await this.findMarkdownFiles(docsWorkspace.absoluteFilePath);
       for (const markdownFile of markdownFiles) {
         try {
-          const content5 = await (0, import_promises71.readFile)(markdownFile, "utf-8");
+          const content5 = await (0, import_promises70.readFile)(markdownFile, "utf-8");
           const referencedFiles = this.extractReferences(content5, markdownFile, docsWorkspace.absoluteFilePath);
           this.pageToSnippets.set(markdownFile, referencedFiles);
           for (const referencedFile of referencedFiles) {
@@ -1597476,7 +1597469,7 @@ async function runAppPreviewServer({ initialProject, reloadProject, validateProj
     const appPreviewFolder = getPathToPreviewFolder({ app: true });
     if (await doesPathExist(appPreviewFolder)) {
       context2.logger.info("Force download requested. Deleting cached bundle...");
-      await (0, import_promises71.rm)(appPreviewFolder, { recursive: true });
+      await (0, import_promises70.rm)(appPreviewFolder, { recursive: true });
     }
   }
   if (bundlePath != null) {
@@ -1599969,7 +1599962,7 @@ async function validateVersionConfigFileSchema({ value }) {
 }
 
 // ../yaml/docs-validator/lib/docsAst/visitDocsConfigFileYamlAst.js
-var import_promises73 = require("fs/promises");
+var import_promises72 = require("fs/promises");
 
 // ../yaml/docs-validator/lib/docsAst/products-yml.schema.json
 var products_yml_schema_exports = {};
@@ -1601820,7 +1601813,7 @@ async function visitFilepath({ absoluteFilepathToConfiguration, rawUnresolvedFil
 }
 
 // ../yaml/docs-validator/lib/docsAst/visitNavigationAst.js
-var import_promises72 = require("fs/promises");
+var import_promises71 = require("fs/promises");
 
 // ../yaml/docs-validator/lib/utils/asyncPool.js
 async function asyncPool(limit, items, fn4) {
@@ -1601971,13 +1601964,13 @@ async function visitNavigationItem2({ absolutePathToFernFolder, navigationItem,
   if (navigationItemIsPage(navigationItem)) {
     const absoluteFilepath = resolve5(dirname4(absoluteFilepathToConfiguration), navigationItem.path);
     if (await doesPathExist(absoluteFilepath)) {
-      const fileStats = await (0, import_promises72.stat)(absoluteFilepath);
+      const fileStats = await (0, import_promises71.stat)(absoluteFilepath);
       const fileSizeMB = fileStats.size / (1024 * 1024);
       if (fileSizeMB > 1) {
         context2.logger.trace(`Processing large markdown file: ${navigationItem.path} (${fileSizeMB.toFixed(2)} MB)`);
       }
       const startTime = performance.now();
-      const content5 = (await (0, import_promises72.readFile)(absoluteFilepath, "utf8")).toString();
+      const content5 = (await (0, import_promises71.readFile)(absoluteFilepath, "utf8")).toString();
       const readTime = performance.now() - startTime;
       if (readTime > 2e3) {
         context2.logger.debug(`Slow file read: ${navigationItem.path} took ${readTime.toFixed(0)}ms`);
@@ -1602024,12 +1602017,12 @@ async function visitNavigationItem2({ absolutePathToFernFolder, navigationItem,
     context2.logger.trace(`Starting changelog processing for directory: ${changelogDir}`);
     if (await doesPathExist(changelogDir)) {
       const startTime = performance.now();
-      const files = await (0, import_promises72.readdir)(changelogDir);
+      const files = await (0, import_promises71.readdir)(changelogDir);
       const markdownFiles = files.filter((file) => file.endsWith(".md") || file.endsWith(".mdx"));
       context2.logger.debug(`Processing ${markdownFiles.length} changelog files in ${changelogDir}`);
       await asyncPool(VALIDATION_CONCURRENCY, markdownFiles, async (file) => {
         const absoluteFilepath = resolve5(changelogDir, file);
-        const content5 = (await (0, import_promises72.readFile)(absoluteFilepath, "utf8")).toString();
+        const content5 = (await (0, import_promises71.readFile)(absoluteFilepath, "utf8")).toString();
         context2.logger.trace(`Validating changelog file: ${file}`);
         await visitor.markdownPage?.({
           title: file,
@@ -1602219,7 +1602212,7 @@ async function visitDocsConfigFileYamlAst({ contents, visitor, absoluteFilepathT
             willBeUploaded: false
           });
           const absoluteFilepath = resolve5(dirname4(absoluteFilepathToConfiguration), product.path);
-          const content5 = jsYaml.load((await (0, import_promises73.readFile)(absoluteFilepath)).toString());
+          const content5 = jsYaml.load((await (0, import_promises72.readFile)(absoluteFilepath)).toString());
           if (await doesPathExist(absoluteFilepath)) {
             await visitor.productFile?.({
               path: product.path,
@@ -1602297,7 +1602290,7 @@ async function visitDocsConfigFileYamlAst({ contents, visitor, absoluteFilepathT
           willBeUploaded: false
         });
         const absoluteFilepath = resolve5(dirname4(absoluteFilepathToConfiguration), version6.path);
-        const content5 = jsYaml.load((await (0, import_promises73.readFile)(absoluteFilepath)).toString());
+        const content5 = jsYaml.load((await (0, import_promises72.readFile)(absoluteFilepath)).toString());
         if (await doesPathExist(absoluteFilepath)) {
           await visitor.versionFile?.({
             path: version6.path,
@@ -1602731,7 +1602724,7 @@ var import_web = require("stream/web");
 var import_node_stream5 = require("stream");
 
 // ../../../node_modules/.pnpm/strtok3@9.1.1/node_modules/strtok3/lib/index.js
-var import_promises75 = require("fs/promises");
+var import_promises74 = require("fs/promises");
 
 // ../../../node_modules/.pnpm/peek-readable@5.4.2/node_modules/peek-readable/lib/EndOfStreamError.js
 var defaultMessages = "End-Of-Stream";
@@ -1603102,14 +1603095,14 @@ function fromBuffer(uint8Array, options2) {
 }
 
 // ../../../node_modules/.pnpm/strtok3@9.1.1/node_modules/strtok3/lib/FileTokenizer.js
-var import_promises74 = require("fs/promises");
+var import_promises73 = require("fs/promises");
 var FileTokenizer = class _FileTokenizer extends AbstractTokenizer {
   /**
    * Create tokenizer from provided file path
    * @param sourceFilePath File path
    */
   static async fromFile(sourceFilePath) {
-    const fileHandle = await (0, import_promises74.open)(sourceFilePath, "r");
+    const fileHandle = await (0, import_promises73.open)(sourceFilePath, "r");
     const stat3 = await fileHandle.stat();
     return new _FileTokenizer(fileHandle, { fileInfo: { path: sourceFilePath, size: stat3.size } });
   }
@@ -1603241,9 +1603234,9 @@ function decodeUTF8(bytes) {
       const b23 = bytes[i11++] & 63;
       const b32 = bytes[i11++] & 63;
       const b42 = bytes[i11++] & 63;
-      let cp11 = (b1 & 7) << 18 | b23 << 12 | b32 << 6 | b42;
-      cp11 -= 65536;
-      out += String.fromCharCode(55296 + (cp11 >> 10 & 1023), 56320 + (cp11 & 1023));
+      let cp10 = (b1 & 7) << 18 | b23 << 12 | b32 << 6 | b42;
+      cp10 -= 65536;
+      out += String.fromCharCode(55296 + (cp10 >> 10 & 1023), 56320 + (cp10 & 1023));
     }
   }
   return out;
@@ -1605071,7 +1605064,7 @@ var supportedExtensions = new Set(extensions);
 var supportedMimeTypes = new Set(mimeTypes);
 
 // ../yaml/docs-validator/lib/rules/valid-file-types/valid-file-types.js
-var import_promises76 = require("fs/promises");
+var import_promises75 = require("fs/promises");
 var import_path41 = __toESM(require("path"), 1);
 var ALLOWED_FILE_TYPES = /* @__PURE__ */ new Set([
   // image files
@@ -1605192,7 +1605185,7 @@ var ValidFileTypes = {
   }
 };
 var getViolationsForFile = async (absoluteFilepath) => {
-  const file = new Uint8Array(await (0, import_promises76.readFile)(absoluteFilepath));
+  const file = new Uint8Array(await (0, import_promises75.readFile)(absoluteFilepath));
   const fileType = await fileTypeFromBuffer(file);
   if (fileType != null) {
     if (ALLOWED_FILE_TYPES.has(fileType.mime)) {
@@ -1605231,7 +1605224,7 @@ var getViolationsForFile = async (absoluteFilepath) => {
 };
 
 // ../yaml/docs-validator/lib/rules/valid-frontmatter/valid-frontmatter.js
-var import_promises77 = require("fs/promises");
+var import_promises76 = require("fs/promises");
 var import_gray_matter11 = __toESM(require_gray_matter(), 1);
 var ValidFrontmatter = {
   name: "valid-frontmatter",
@@ -1605242,7 +1605235,7 @@ var ValidFrontmatter = {
           return [];
         }
         try {
-          const fileContents = await (0, import_promises77.readFile)(absoluteFilepath, "utf-8");
+          const fileContents = await (0, import_promises76.readFile)(absoluteFilepath, "utf-8");
           (0, import_gray_matter11.default)(fileContents);
           return [];
         } catch (error2) {
@@ -1610118,7 +1610111,7 @@ async function parseMarkdown({ markdown, absoluteFilepath, absolutePathToFernFol
 }
 
 // ../yaml/docs-validator/lib/rules/valid-markdown-file-reference/valid-markdown-file-reference.js
-var import_promises78 = require("fs/promises");
+var import_promises77 = require("fs/promises");
 var import_gray_matter12 = __toESM(require_gray_matter(), 1);
 var ValidMarkdownFileReferences = {
   name: "valid-markdown-file-references",
@@ -1610129,7 +1610122,7 @@ var ValidMarkdownFileReferences = {
           return [];
         }
         try {
-          const fileContents = await (0, import_promises78.readFile)(absoluteFilepath, "utf-8");
+          const fileContents = await (0, import_promises77.readFile)(absoluteFilepath, "utf-8");
           const { content: content5 } = (0, import_gray_matter12.default)(fileContents, {});
           const tree = parseMarkdownToTree(content5);
           const errors4 = [];
@@ -1611271,7 +1611264,7 @@ function createDocsConfigFileAstVisitorForRules({ relativeFilepath, allRuleVisit
 }
 
 // ../yaml/docs-validator/lib/rules/no-non-component-refs/no-non-component-refs.js
-var import_promises79 = require("fs/promises");
+var import_promises78 = require("fs/promises");
 var NoNonComponentRefsRule = {
   name: "no-non-component-refs",
   create: ({ ossWorkspaces, logger, workspace: docsWorkspace }) => {
@@ -1611285,7 +1611278,7 @@ var NoNonComponentRefsRule = {
               if (!processedFiles.has(spec.absoluteFilepath)) {
                 processedFiles.add(spec.absoluteFilepath);
                 try {
-                  const contents = (await (0, import_promises79.readFile)(spec.absoluteFilepath)).toString();
+                  const contents = (await (0, import_promises78.readFile)(spec.absoluteFilepath)).toString();
                   const relativePath = relative3(docsWorkspace.absoluteFilePath, spec.absoluteFilepath);
                   const isOpenApiV2 = contents.includes("swagger:") && (contents.includes('swagger: "2.0"') || contents.includes("swagger: '2.0'") || contents.includes("swagger: 2.0"));
                   if (isOpenApiV2) {
@@ -1611325,7 +1611318,7 @@ var NoNonComponentRefsRule = {
 };
 
 // ../yaml/docs-validator/lib/rules/no-openapi-v2-in-docs/no-openapi-v2-in-docs.js
-var import_promises80 = require("fs/promises");
+var import_promises79 = require("fs/promises");
 var NoOpenApiV2InDocsRule = {
   name: "no-openapi-v2-in-docs",
   create: ({ ossWorkspaces, logger, workspace: docsWorkspace }) => {
@@ -1611338,7 +1611331,7 @@ var NoOpenApiV2InDocsRule = {
             if (spec.type === "openapi" && !processedFiles.has(spec.absoluteFilepath)) {
               processedFiles.add(spec.absoluteFilepath);
               try {
-                const contents = (await (0, import_promises80.readFile)(spec.absoluteFilepath)).toString();
+                const contents = (await (0, import_promises79.readFile)(spec.absoluteFilepath)).toString();
                 const relativePath = relative3(docsWorkspace.absoluteFilePath, spec.absoluteFilepath);
                 if (contents.includes("swagger:") && (contents.includes('swagger: "2.0"') || contents.includes("swagger: '2.0'") || contents.includes("swagger: 2.0"))) {
                   violations.push({
@@ -1611461,7 +1611454,7 @@ var ValidInstanceUrlRule = {
 };
 
 // ../yaml/docs-validator/lib/rules/valid-local-references/valid-local-references.js
-var import_promises81 = require("fs/promises");
+var import_promises80 = require("fs/promises");
 function validateReference(ref2, spec) {
   const pathParts = ref2.replace(/^#\//, "").split("/").map((part) => (
     // Decode JSON Pointer escapes: ~1 -> /, ~0 -> ~
@@ -1611528,7 +1611521,7 @@ var ValidLocalReferencesRule = {
             if (spec.type === "openapi" && !processedFiles.has(spec.absoluteFilepath)) {
               processedFiles.add(spec.absoluteFilepath);
               try {
-                const contents = (await (0, import_promises81.readFile)(spec.absoluteFilepath)).toString();
+                const contents = (await (0, import_promises80.readFile)(spec.absoluteFilepath)).toString();
                 const relativePath = relative3(docsWorkspace.absoluteFilePath, spec.absoluteFilepath);
                 const isOpenApiV2 = contents.includes("swagger:") && (contents.includes('swagger: "2.0"') || contents.includes("swagger: '2.0'") || contents.includes("swagger: 2.0"));
                 if (isOpenApiV2) {
@@ -1611581,7 +1611574,7 @@ var ValidLocalReferencesRule = {
 };
 
 // ../yaml/docs-validator/lib/rules/valid-openapi-examples/valid-openapi-examples.js
-var import_promises82 = require("fs/promises");
+var import_promises81 = require("fs/promises");
 var ValidOpenApiExamples = {
   name: "valid-openapi-examples",
   create: ({ ossWorkspaces, logger, workspace: docsWorkspace }) => {
@@ -1611679,7 +1611672,7 @@ var ValidOpenApiExamples = {
 };
 async function validateOpenApiExamples({ specPath, logger }) {
   try {
-    const specContent = await (0, import_promises82.readFile)(specPath, "utf-8");
+    const specContent = await (0, import_promises81.readFile)(specPath, "utf-8");
     let spec;
     try {
       spec = JSON.parse(specContent);
@@ -1612373,7 +1612366,7 @@ Found ${previewDeployments.length} preview deployment(s):
 }
 
 // src/commands/downgrade/downgrade.ts
-var import_promises83 = require("fs/promises");
+var import_promises82 = require("fs/promises");
 
 // ../../../node_modules/.pnpm/immer@10.1.3/node_modules/immer/dist/immer.mjs
 var NOTHING = Symbol.for("immer-nothing");
@@ -1613062,12 +1613055,12 @@ async function downgrade({
   const newProjectConfig = produce(projectConfig.rawConfig, (draft) => {
     draft.version = targetVersion;
   });
-  await (0, import_promises83.writeFile)(projectConfig._absolutePath, ensureFinalNewline(JSON.stringify(newProjectConfig, void 0, 2)));
+  await (0, import_promises82.writeFile)(projectConfig._absolutePath, ensureFinalNewline(JSON.stringify(newProjectConfig, void 0, 2)));
   cliContext.logger.info(`Updated ${PROJECT_CONFIG_FILENAME} to version ${targetVersion}`);
 }
 
 // src/commands/export/generateOpenAPIForWorkspaces.ts
-var import_promises84 = require("fs/promises");
+var import_promises83 = require("fs/promises");
 
 // src/commands/export/converters/servicesConverter.ts
 var import_openapi_types3 = __toESM(require_dist20(), 1);
@@ -1614320,8 +1614313,8 @@ async function generateOpenAPIForWorkspaces({
           ir: ir14,
           mode: "openapi"
         });
-        await (0, import_promises84.mkdir)(dirname4(outputPath), { recursive: true });
-        await (0, import_promises84.writeFile)(
+        await (0, import_promises83.mkdir)(dirname4(outputPath), { recursive: true });
+        await (0, import_promises83.writeFile)(
           outputPath,
           outputPath.endsWith(".json") ? JSON.stringify(openapi, void 0, indent3) : jsYaml.dump(openapi, { indent: indent3 })
         );
@@ -1614360,10 +1614353,10 @@ var APPROVED_DIRECTORIES_FILENAME = "approved-output-directories";
 var LOCAL_STORAGE_FOLDER6 = ".fern-dev";
 
 // src/commands/generate/checkOutputDirectory.ts
-var import_promises87 = require("fs/promises");
+var import_promises86 = require("fs/promises");
 
 // src/persistence/output-directories/getOutputDirectories.ts
-var import_promises85 = require("fs/promises");
+var import_promises84 = require("fs/promises");
 
 // src/persistence/output-directories/getPathToOutputDirectoriesFile.ts
 var import_os7 = require("os");
@@ -1614382,17 +1614375,17 @@ async function getOutputDirectories() {
   if (!doesOutputDirectoriesFileExist) {
     return [];
   }
-  const outputDirectoriesFileContents = await (0, import_promises85.readFile)(pathToOutputDirectoriesFile, { encoding: "utf-8" });
+  const outputDirectoriesFileContents = await (0, import_promises84.readFile)(pathToOutputDirectoriesFile, { encoding: "utf-8" });
   const outputDirectories = JSON.parse(outputDirectoriesFileContents);
   return outputDirectories;
 }
 
 // src/persistence/output-directories/storeOutputDirectories.ts
-var import_promises86 = require("fs/promises");
+var import_promises85 = require("fs/promises");
 var import_path43 = __toESM(require("path"), 1);
 async function storeOutputDirectories(outputDirectories) {
-  await (0, import_promises86.mkdir)(import_path43.default.dirname(getPathToOutputDirectoriesFile()), { recursive: true });
-  await (0, import_promises86.writeFile)(getPathToOutputDirectoriesFile(), JSON.stringify(outputDirectories, null, 2));
+  await (0, import_promises85.mkdir)(import_path43.default.dirname(getPathToOutputDirectoriesFile()), { recursive: true });
+  await (0, import_promises85.writeFile)(getPathToOutputDirectoriesFile(), JSON.stringify(outputDirectories, null, 2));
 }
 
 // src/commands/generate/checkOutputDirectory.ts
@@ -1614414,7 +1614407,7 @@ async function checkOutputDirectory(outputPath, cliContext, force) {
       shouldProceed: true
     };
   }
-  const files = await (0, import_promises87.readdir)(outputPath);
+  const files = await (0, import_promises86.readdir)(outputPath);
   if (files.length === 0) {
     return {
       shouldProceed: true
@@ -1614776,7 +1614769,7 @@ var AutoVersioningService = class {
 };
 
 // ../generation/local-generation/docker-utils/lib/runDocker.js
-var import_promises88 = require("fs/promises");
+var import_promises87 = require("fs/promises");
 var import_tmp_promise10 = __toESM(require_tmp_promise(), 1);
 async function runContainer({ logger, imageName, args = [], binds = [], envVars = {}, ports = {}, writeLogsToFile = true, removeAfterCompletion = false, runner }) {
   const tryRun = () => tryRunContainer({
@@ -1614825,7 +1614818,7 @@ async function tryRunContainer({ logger, imageName, args, binds, envVars = {}, p
   const logs = stdout + stderr;
   if (writeLogsToFile) {
     const tmpFile = await import_tmp_promise10.default.file();
-    await (0, import_promises88.writeFile)(tmpFile.path, logs);
+    await (0, import_promises87.writeFile)(tmpFile.path, logs);
     logger.info(`Generator logs here: ${tmpFile.path}`);
   }
   if (exitCode == null) {
@@ -1614918,7 +1614911,7 @@ var ContainerExecutionEnvironment = class {
 
 // ../generation/local-generation/local-workspace-runner/lib/runGenerator.js
 var import_serialization = __toESM(require_serialization3(), 1);
-var import_promises90 = require("fs/promises");
+var import_promises89 = require("fs/promises");
 var path54 = __toESM(require("path"), 1);
 var import_path46 = require("path");
 var import_tmp_promise12 = __toESM(require_tmp_promise(), 1);
@@ -1628744,7 +1628737,7 @@ function configureBamlClient(config2) {
 
 // ../generation/local-generation/local-workspace-runner/lib/LocalTaskHandler.js
 var import_decompress2 = __toESM(require_decompress(), 1);
-var import_promises89 = require("fs/promises");
+var import_promises88 = require("fs/promises");
 var import_os8 = require("os");
 var import_path45 = require("path");
 var import_semver10 = __toESM(require_semver2(), 1);
@@ -1628827,7 +1628820,7 @@ var LocalTaskHandler = class {
     try {
       this.context.logger.info("Analyzing SDK changes for automatic semantic versioning");
       diffFile = await this.generateDiffFile();
-      const diffContent = await (0, import_promises89.readFile)(diffFile, "utf-8");
+      const diffContent = await (0, import_promises88.readFile)(diffFile, "utf-8");
       if (diffContent.trim().length === 0) {
         this.context.logger.info("No changes detected in generated SDK");
         return null;
@@ -1628874,7 +1628867,7 @@ var LocalTaskHandler = class {
     } finally {
       if (diffFile) {
         try {
-          await (0, import_promises89.rm)(diffFile);
+          await (0, import_promises88.rm)(diffFile);
         } catch (cleanupError) {
           this.context.logger.warn(`Failed to delete temp diff file: ${diffFile}`, String(cleanupError));
         }
@@ -1628953,7 +1628946,7 @@ var LocalTaskHandler = class {
     const tmpOutputResolutionDir = AbsoluteFilePath2.of((await import_tmp_promise11.default.dir({})).path);
     const absolutePathToFernignore = AbsoluteFilePath2.of(join2(this.absolutePathToLocalOutput, RelativeFilePath2.of(FERNIGNORE_FILENAME)));
     const fernIgnorePaths = await getFernIgnorePaths({ absolutePathToFernignore });
-    await (0, import_promises89.cp)(this.absolutePathToLocalOutput, tmpOutputResolutionDir, { recursive: true });
+    await (0, import_promises88.cp)(this.absolutePathToLocalOutput, tmpOutputResolutionDir, { recursive: true });
     await this.runGitCommand(["init"], tmpOutputResolutionDir);
     await this.runGitCommand(["add", "."], tmpOutputResolutionDir);
     const response = await this.runGitCommand(["config", "--list"], tmpOutputResolutionDir);
@@ -1628967,13 +1628960,13 @@ var LocalTaskHandler = class {
     await this.runGitCommand(["add", "."], tmpOutputResolutionDir);
     await this.runGitCommand(["reset", "--", ...fernIgnorePaths], tmpOutputResolutionDir);
     await this.runGitCommand(["restore", "."], tmpOutputResolutionDir);
-    await (0, import_promises89.rm)(join2(tmpOutputResolutionDir, RelativeFilePath2.of(".git")), { recursive: true });
-    await (0, import_promises89.rm)(this.absolutePathToLocalOutput, { recursive: true });
-    await (0, import_promises89.cp)(tmpOutputResolutionDir, this.absolutePathToLocalOutput, { recursive: true });
+    await (0, import_promises88.rm)(join2(tmpOutputResolutionDir, RelativeFilePath2.of(".git")), { recursive: true });
+    await (0, import_promises88.rm)(this.absolutePathToLocalOutput, { recursive: true });
+    await (0, import_promises88.cp)(tmpOutputResolutionDir, this.absolutePathToLocalOutput, { recursive: true });
   }
   async copyGeneratedFilesNoFernIgnorePreservingGit() {
-    const contents = await (0, import_promises89.readdir)(this.absolutePathToLocalOutput);
-    await Promise.all(contents.filter((item) => item !== ".git").map((item) => (0, import_promises89.rm)(join2(this.absolutePathToLocalOutput, RelativeFilePath2.of(item)), {
+    const contents = await (0, import_promises88.readdir)(this.absolutePathToLocalOutput);
+    await Promise.all(contents.filter((item) => item !== ".git").map((item) => (0, import_promises88.rm)(join2(this.absolutePathToLocalOutput, RelativeFilePath2.of(item)), {
       force: true,
       recursive: true
     })));
@@ -1628981,11 +1628974,11 @@ var LocalTaskHandler = class {
   }
   async copyGeneratedFilesNoFernIgnoreDeleteAll() {
     this.context.logger.debug(`rm -rf ${this.absolutePathToLocalOutput}`);
-    await (0, import_promises89.rm)(this.absolutePathToLocalOutput, { force: true, recursive: true });
+    await (0, import_promises88.rm)(this.absolutePathToLocalOutput, { force: true, recursive: true });
     await this.copyGeneratedFilesToDirectory(this.absolutePathToLocalOutput);
   }
   async copyGeneratedFilesToDirectory(outputPath) {
-    const [firstLocalOutputItem, ...remaininglocalOutputItems] = await (0, import_promises89.readdir)(this.absolutePathToTmpOutputDirectory);
+    const [firstLocalOutputItem, ...remaininglocalOutputItems] = await (0, import_promises88.readdir)(this.absolutePathToTmpOutputDirectory);
     if (firstLocalOutputItem == null) {
       return;
     }
@@ -1628993,15 +1628986,15 @@ var LocalTaskHandler = class {
     if (firstLocalOutputItem.endsWith(".zip")) {
       await (0, import_decompress2.default)(join2(this.absolutePathToTmpOutputDirectory, RelativeFilePath2.of(firstLocalOutputItem)), outputPath);
       for (const localOutputItem of remaininglocalOutputItems) {
-        await (0, import_promises89.cp)(join2(this.absolutePathToTmpOutputDirectory, RelativeFilePath2.of(localOutputItem)), join2(outputPath, RelativeFilePath2.of(localOutputItem)), { recursive: true });
+        await (0, import_promises88.cp)(join2(this.absolutePathToTmpOutputDirectory, RelativeFilePath2.of(localOutputItem)), join2(outputPath, RelativeFilePath2.of(localOutputItem)), { recursive: true });
       }
     } else {
-      await (0, import_promises89.cp)(this.absolutePathToTmpOutputDirectory, outputPath, { recursive: true });
+      await (0, import_promises88.cp)(this.absolutePathToTmpOutputDirectory, outputPath, { recursive: true });
     }
   }
   async copySnippetJSON({ absolutePathToTmpSnippetJSON, absolutePathToLocalSnippetJSON }) {
     this.context.logger.debug(`Copying generated snippets to ${absolutePathToLocalSnippetJSON}`);
-    await (0, import_promises89.cp)(absolutePathToTmpSnippetJSON, absolutePathToLocalSnippetJSON);
+    await (0, import_promises88.cp)(absolutePathToTmpSnippetJSON, absolutePathToLocalSnippetJSON);
   }
   async runGitCommand(options2, cwd2) {
     const response = await loggingExeca(this.context.logger, "git", options2, {
@@ -1629056,24 +1629049,24 @@ async function writeFilesToDiskAndRunGenerator({ organization, absolutePathToFer
   context2.logger.debug("Wrote IR to: " + absolutePathToIr);
   const configJsonFile = (0, import_path46.join)(workspaceTempDir.path, GENERATOR_CONFIG_FILENAME);
   const absolutePathToWriteConfigJson = AbsoluteFilePath2.of(configJsonFile);
-  await (0, import_promises90.writeFile)(configJsonFile, "");
+  await (0, import_promises89.writeFile)(configJsonFile, "");
   context2.logger.debug("Will write config.json to: " + absolutePathToWriteConfigJson);
   const tmpOutputDirectory = (0, import_path46.join)(workspaceTempDir.path, CODEGEN_OUTPUT_DIRECTORY_NAME);
   const absolutePathToTmpOutputDirectory = AbsoluteFilePath2.of(tmpOutputDirectory);
-  await (0, import_promises90.mkdir)(tmpOutputDirectory, { recursive: true });
+  await (0, import_promises89.mkdir)(tmpOutputDirectory, { recursive: true });
   context2.logger.debug("Will write output to: " + absolutePathToTmpOutputDirectory);
   let absolutePathToTmpSnippetJSON = void 0;
   if (absolutePathToLocalSnippetJSON != null) {
     const snippetJsonFile = (0, import_path46.join)(workspaceTempDir.path, "snippet.json");
     absolutePathToTmpSnippetJSON = AbsoluteFilePath2.of(snippetJsonFile);
-    await (0, import_promises90.writeFile)(snippetJsonFile, "");
+    await (0, import_promises89.writeFile)(snippetJsonFile, "");
     context2.logger.debug("Will write snippet.json to: " + absolutePathToTmpSnippetJSON);
   }
   let absolutePathToTmpSnippetTemplatesJSON = void 0;
   if (absolutePathToLocalSnippetTemplateJSON != null) {
     const snippetTemplatesJsonFile = (0, import_path46.join)(workspaceTempDir.path, SNIPPET_TEMPLATES_JSON_FILENAME);
     absolutePathToTmpSnippetTemplatesJSON = AbsoluteFilePath2.of(snippetTemplatesJsonFile);
-    await (0, import_promises90.writeFile)(snippetTemplatesJsonFile, "");
+    await (0, import_promises89.writeFile)(snippetTemplatesJsonFile, "");
     context2.logger.debug("Will write snippet-templates.json to: " + absolutePathToTmpSnippetTemplatesJSON);
   }
   const environment2 = executionEnvironment ?? new ContainerExecutionEnvironment({
@@ -1629109,7 +1629102,7 @@ async function writeFilesToDiskAndRunGenerator({ organization, absolutePathToFer
     whiteLabel,
     paths
   });
-  await (0, import_promises90.writeFile)(absolutePathToWriteConfigJson, JSON.stringify(await import_serialization.GeneratorConfig.jsonOrThrow(config2), void 0, 4));
+  await (0, import_promises89.writeFile)(absolutePathToWriteConfigJson, JSON.stringify(await import_serialization.GeneratorConfig.jsonOrThrow(config2), void 0, 4));
   const absolutePathToLicenseFile = extractLicenseFilePath(generatorInvocation, absolutePathToFernConfig);
   await environment2.execute({
     generatorName: generatorInvocation.name,
@@ -1629351,8 +1629344,8 @@ var import_fiddle_sdk5 = __toESM(require_fiddle_sdk(), 1);
 
 // ../generation/remote-generation/remote-workspace-runner/lib/downloadSnippetsForTask.js
 var import_fs17 = require("fs");
-var import_promises91 = require("fs/promises");
-var import_promises92 = require("stream/promises");
+var import_promises90 = require("fs/promises");
+var import_promises91 = require("stream/promises");
 async function downloadSnippetsForTask({ snippetsS3PreSignedReadUrl, absolutePathToLocalSnippetJSON, context: context2 }) {
   try {
     await downloadFileForTask({
@@ -1629369,22 +1629362,22 @@ async function downloadFileForTask({ s3PreSignedReadUrl, absolutePathToLocalOutp
     responseType: "stream"
   });
   if (await doesPathExist(absolutePathToLocalOutput)) {
-    await (0, import_promises91.rm)(absolutePathToLocalOutput, { recursive: true });
+    await (0, import_promises90.rm)(absolutePathToLocalOutput, { recursive: true });
   }
-  await (0, import_promises91.mkdir)(dirname4(absolutePathToLocalOutput), { recursive: true });
-  await (0, import_promises92.pipeline)(request6.data, (0, import_fs17.createWriteStream)(absolutePathToLocalOutput));
+  await (0, import_promises90.mkdir)(dirname4(absolutePathToLocalOutput), { recursive: true });
+  await (0, import_promises91.pipeline)(request6.data, (0, import_fs17.createWriteStream)(absolutePathToLocalOutput));
 }
 
 // ../generation/remote-generation/remote-workspace-runner/lib/createAndStartJob.js
 var import_fiddle_sdk4 = __toESM(require_fiddle_sdk(), 1);
 var import_form_data4 = __toESM(require_form_data(), 1);
-var import_promises93 = require("fs/promises");
+var import_promises92 = require("fs/promises");
 var import_url_join23 = __toESM(require_url_join(), 1);
 async function createAndStartJob({ projectConfig, workspace, organization, intermediateRepresentation, generatorInvocation, version: version6, context: context2, shouldLogS3Url, token, whitelabel, irVersionOverride, absolutePathToPreview, fernignorePath }) {
   let fernignoreContents;
   if (fernignorePath != null) {
     try {
-      fernignoreContents = await (0, import_promises93.readFile)(fernignorePath, "utf-8");
+      fernignoreContents = await (0, import_promises92.readFile)(fernignorePath, "utf-8");
     } catch (error2) {
       context2.failAndThrow(`Failed to read fernignore file at ${fernignorePath}: ${error2}`);
     }
@@ -1629576,9 +1629569,9 @@ function pollJobAndReportStatus({ job, taskId, taskHandler, context: context2 })
 // ../generation/remote-generation/remote-workspace-runner/lib/RemoteTaskHandler.js
 var import_decompress3 = __toESM(require_decompress(), 1);
 var import_fs18 = require("fs");
-var import_promises94 = require("fs/promises");
+var import_promises93 = require("fs/promises");
 var import_path47 = __toESM(require("path"), 1);
-var import_promises95 = require("stream/promises");
+var import_promises94 = require("stream/promises");
 
 // ../../../node_modules/.pnpm/terminal-link@3.0.0/node_modules/terminal-link/index.js
 var import_supports_hyperlinks = __toESM(require_supports_hyperlinks(), 1);
@@ -1629746,9 +1629739,9 @@ async function downloadZipForTask({ s3PreSignedReadUrl, absolutePathToLocalOutpu
   });
   const tmpDir = await import_tmp_promise13.default.dir({ prefix: "fern", unsafeCleanup: true });
   const outputZipPath = import_path47.default.join(tmpDir.path, "output.zip");
-  await (0, import_promises95.pipeline)(request6.data, (0, import_fs18.createWriteStream)(outputZipPath));
+  await (0, import_promises94.pipeline)(request6.data, (0, import_fs18.createWriteStream)(outputZipPath));
   await forceRemoveDirectory(absolutePathToLocalOutput);
-  await (0, import_promises94.mkdir)(absolutePathToLocalOutput, { recursive: true });
+  await (0, import_promises93.mkdir)(absolutePathToLocalOutput, { recursive: true });
   await (0, import_decompress3.default)(outputZipPath, absolutePathToLocalOutput);
 }
 async function forceRemoveDirectory(dirPath) {
@@ -1629756,22 +1629749,22 @@ async function forceRemoveDirectory(dirPath) {
     return;
   }
   await makeWritableRecursive(dirPath);
-  await (0, import_promises94.rm)(dirPath, { recursive: true, force: true });
+  await (0, import_promises93.rm)(dirPath, { recursive: true, force: true });
 }
 async function makeWritableRecursive(dirPath) {
   try {
-    const entries10 = await (0, import_promises94.readdir)(dirPath, { withFileTypes: true });
+    const entries10 = await (0, import_promises93.readdir)(dirPath, { withFileTypes: true });
     for (const entry of entries10) {
       const fullPath = AbsoluteFilePath2.of(import_path47.default.join(dirPath, entry.name));
       if (entry.isDirectory()) {
         await makeWritableRecursive(fullPath);
       }
       try {
-        await (0, import_promises94.chmod)(fullPath, 493);
+        await (0, import_promises93.chmod)(fullPath, 493);
       } catch {
       }
     }
-    await (0, import_promises94.chmod)(dirPath, 493);
+    await (0, import_promises93.chmod)(dirPath, 493);
   } catch {
   }
 }
@@ -1629822,7 +1629815,7 @@ async function downloadFilesWithFernIgnoreInTempRepo({ s3PreSignedReadUrl, absol
   const tmpOutputResolutionDir = AbsoluteFilePath2.of((await import_tmp_promise13.default.dir({})).path);
   const absolutePathToFernignore = join2(absolutePathToLocalOutput, RelativeFilePath2.of(FERNIGNORE_FILENAME));
   const fernIgnorePaths = await getFernIgnorePaths({ absolutePathToFernignore });
-  await (0, import_promises94.cp)(absolutePathToLocalOutput, tmpOutputResolutionDir, { recursive: true });
+  await (0, import_promises93.cp)(absolutePathToLocalOutput, tmpOutputResolutionDir, { recursive: true });
   await runGitCommand(["init"], tmpOutputResolutionDir, context2);
   await runGitCommand(["add", "."], tmpOutputResolutionDir, context2);
   const gitConfigResponse = await runGitCommand(["config", "--list"], tmpOutputResolutionDir, context2);
@@ -1629838,7 +1629831,7 @@ async function downloadFilesWithFernIgnoreInTempRepo({ s3PreSignedReadUrl, absol
   await runGitCommand(["restore", "."], tmpOutputResolutionDir, context2);
   await forceRemoveDirectory(join2(tmpOutputResolutionDir, RelativeFilePath2.of(".git")));
   await forceRemoveDirectory(absolutePathToLocalOutput);
-  await (0, import_promises94.cp)(tmpOutputResolutionDir, absolutePathToLocalOutput, { recursive: true });
+  await (0, import_promises93.cp)(tmpOutputResolutionDir, absolutePathToLocalOutput, { recursive: true });
 }
 async function downloadAndExtractZipToDirectory({ s3PreSignedReadUrl, outputPath }) {
   const request6 = await axios_default.get(s3PreSignedReadUrl, {
@@ -1629846,12 +1629839,12 @@ async function downloadAndExtractZipToDirectory({ s3PreSignedReadUrl, outputPath
   });
   const tmpDir = await import_tmp_promise13.default.dir({ prefix: "fern", unsafeCleanup: true });
   const outputZipPath = import_path47.default.join(tmpDir.path, "output.zip");
-  await (0, import_promises95.pipeline)(request6.data, (0, import_fs18.createWriteStream)(outputZipPath));
+  await (0, import_promises94.pipeline)(request6.data, (0, import_fs18.createWriteStream)(outputZipPath));
   await (0, import_decompress3.default)(outputZipPath, outputPath);
 }
 
 // ../generation/remote-generation/remote-workspace-runner/lib/SourceUploader.js
-var import_promises96 = require("fs/promises");
+var import_promises95 = require("fs/promises");
 var import_tmp_promise14 = __toESM(require_tmp_promise(), 1);
 var PROTOBUF_ZIP_FILENAME = "proto.zip";
 var SourceUploader = class {
@@ -1629872,7 +1629865,7 @@ var SourceUploader = class {
   }
   async uploadSource(source2, uploadURL) {
     const uploadCommand = await this.getUploadCommand(source2);
-    const fileData = await (0, import_promises96.readFile)(uploadCommand.absoluteFilePath);
+    const fileData = await (0, import_promises95.readFile)(uploadCommand.absoluteFilePath);
     const response = await fetch(uploadURL, {
       method: "PUT",
       body: fileData,
@@ -1629892,7 +1629885,7 @@ var SourceUploader = class {
         absoluteFilePath,
         cleanup: async () => {
           this.context.logger.debug(`Removing ${absoluteFilePath}`);
-          await (0, import_promises96.unlink)(absoluteFilePath);
+          await (0, import_promises95.unlink)(absoluteFilePath);
         }
       };
     }
@@ -1630334,7 +1630327,7 @@ async function runRemoteGenerationForAPIWorkspace({ projectConfig, organization,
 
 // ../generation/remote-generation/remote-workspace-runner/lib/publishDocs.js
 var import_crypto9 = require("crypto");
-var import_promises97 = require("fs/promises");
+var import_promises96 = require("fs/promises");
 var mime = __toESM(require_mime_types(), 1);
 
 // ../generation/remote-generation/remote-workspace-runner/lib/measureImageSizes.js
@@ -1630391,7 +1630384,7 @@ var MEASURE_IMAGE_BATCH_SIZE = 10;
 var UPLOAD_FILE_BATCH_SIZE = 10;
 var HASH_CONCURRENCY = parseInt(process.env.FERN_DOCS_ASSET_HASH_CONCURRENCY ?? "32", 10);
 async function calculateFileHash(absoluteFilePath) {
-  const fileBuffer = await (0, import_promises97.readFile)(absoluteFilePath);
+  const fileBuffer = await (0, import_promises96.readFile)(absoluteFilePath);
   return (0, import_crypto9.createHash)("sha256").update(new Uint8Array(fileBuffer)).digest("hex");
 }
 async function publishDocs({ token, organization, docsWorkspace, domain: domain2, customDomains, apiWorkspaces, ossWorkspaces, context: context2, preview, editThisPage, isPrivate = false, disableTemplates = false, skipUpload = false, withAiExamples = true, excludeApis = false, targetAudiences }) {
@@ -1630708,7 +1630701,7 @@ async function uploadFiles(filesToUpload, docsWorkspacePath, context2, batchSize
       const absoluteFilePath = resolve5(docsWorkspacePath, relativeFilePath);
       try {
         const mimeType = mime.lookup(absoluteFilePath);
-        await axios_default.put(uploadUrl, await (0, import_promises97.readFile)(absoluteFilePath), {
+        await axios_default.put(uploadUrl, await (0, import_promises96.readFile)(absoluteFilePath), {
           headers: {
             "Content-Type": mimeType === false ? "application/octet-stream" : mimeType,
             // Set max cache control for S3 uploads
@@ -1640682,14 +1640675,14 @@ async function validateGeneratorsYmlFile({ contents, allRuleVisitors, cliVersion
 }
 
 // ../workspace/oss-validator/lib/rules/no-duplicate-overrides/no-duplicate-overrides.js
-var import_promises98 = require("fs/promises");
+var import_promises97 = require("fs/promises");
 var NoDuplicateOverridesRule = {
   name: "no-duplicate-overrides",
   run: async ({ workspace, specs, context: context2 }) => {
     const violations = [];
     const seenMethodsByAudience = /* @__PURE__ */ new Map();
     for (const spec of specs) {
-      const contents = (await (0, import_promises98.readFile)(spec.absoluteFilepath)).toString();
+      const contents = (await (0, import_promises97.readFile)(spec.absoluteFilepath)).toString();
       if (contents.includes("openapi") || contents.includes("swagger")) {
         const openAPI = await loadOpenAPI({
           absolutePathToOpenAPI: spec.absoluteFilepath,
@@ -1641515,7 +1641508,7 @@ async function generateOpenAPIIrForWorkspaces({
 }
 
 // src/commands/generate-overrides/compareOpenAPISpecs.ts
-var import_promises99 = require("fs/promises");
+var import_promises98 = require("fs/promises");
 async function compareOpenAPISpecs({
   originalPath,
   modifiedPath,
@@ -1641552,12 +1641545,12 @@ async function compareOpenAPISpecs({
       }
       outputPath = join2(dirname4(originalPath), RelativeFilePath2.of(overridesFilename));
     }
-    await (0, import_promises99.writeFile)(outputPath, jsYaml.dump(overrides, { lineWidth: -1, noRefs: true }));
+    await (0, import_promises98.writeFile)(outputPath, jsYaml.dump(overrides, { lineWidth: -1, noRefs: true }));
     context2.logger.info(`Overrides written to ${outputPath}`);
   });
 }
 async function loadSpec(filepath, context2) {
-  const contents = await (0, import_promises99.readFile)(filepath, "utf8");
+  const contents = await (0, import_promises98.readFile)(filepath, "utf8");
   try {
     return JSON.parse(contents);
   } catch {
@@ -1641658,7 +1641651,7 @@ function deepEqual(a10, b18) {
 }
 
 // src/commands/generate-overrides/writeOverridesForWorkspaces.ts
-var import_promises100 = require("fs/promises");
+var import_promises99 = require("fs/promises");
 async function writeOverridesForWorkspaces({
   project,
   includeModels,
@@ -1641683,7 +1641676,7 @@ async function writeOverridesForWorkspaces({
 async function readExistingOverrides(overridesFilepath, context2) {
   let parsedOverrides = null;
   try {
-    const contents = (await (0, import_promises100.readFile)(overridesFilepath, "utf8")).toString();
+    const contents = (await (0, import_promises99.readFile)(overridesFilepath, "utf8")).toString();
     try {
       parsedOverrides = JSON.parse(contents);
     } catch (err) {
@@ -1641747,7 +1641740,7 @@ async function writeDefinitionForOpenAPIWorkspace({
         overridesFilename = `${nameWithoutExt}-overrides${extension2}`;
       }
     }
-    await (0, import_promises100.writeFile)(
+    await (0, import_promises99.writeFile)(
       join2(dirname4(spec.absoluteFilepath), RelativeFilePath2.of(overridesFilename)),
       jsYaml.dump({ paths, components })
     );
@@ -1642112,7 +1642105,7 @@ function convertIRtoJsonSchema(args) {
 }
 
 // src/commands/jsonschema/generateJsonschemaForWorkspace.ts
-var import_promises101 = require("fs/promises");
+var import_promises100 = require("fs/promises");
 async function generateJsonschemaForWorkspaces({
   typeLocator,
   project,
@@ -1642160,9 +1642153,9 @@ async function generateJsonschemaForWorkspaces({
           context: context2
         });
         if (!await doesPathExist(dirname4(jsonschemaFilepath))) {
-          await (0, import_promises101.mkdir)(dirname4(jsonschemaFilepath), { recursive: true });
+          await (0, import_promises100.mkdir)(dirname4(jsonschemaFilepath), { recursive: true });
         }
-        await (0, import_promises101.writeFile)(jsonschemaFilepath, JSON.stringify(jsonSchema, null, 2));
+        await (0, import_promises100.writeFile)(jsonschemaFilepath, JSON.stringify(jsonSchema, null, 2));
         context2.logger.info(source_default.green(`Wrote JSON Schema to ${jsonschemaFilepath}`));
       });
     })
@@ -1642519,7 +1642512,7 @@ async function mockServer({
 
 // src/commands/register/registerWorkspacesV1.ts
 var import_fiddle_sdk7 = __toESM(require_fiddle_sdk(), 1);
-var import_promises102 = require("fs/promises");
+var import_promises101 = require("fs/promises");
 var import_path56 = __toESM(require("path"), 1);
 var import_tar2 = __toESM(require_tar(), 1);
 var import_tmp_promise16 = __toESM(require_tmp_promise(), 1);
@@ -1642569,7 +1642562,7 @@ async function registerWorkspacesV1({
         context2.logger.debug(`Compressing definition at ${tmpDir.path}`);
         await (0, import_tar2.create)({ file: tarPath, cwd: resolvedWorkspace.absoluteFilePath }, ["."]);
         context2.logger.info("Uploading definition...");
-        await axios_default.put(registerApiResponse.body.definitionS3UploadUrl, await (0, import_promises102.readFile)(tarPath));
+        await axios_default.put(registerApiResponse.body.definitionS3UploadUrl, await (0, import_promises101.readFile)(tarPath));
         context2.logger.info(
           `Registered @${project.config.organization}/${resolvedWorkspace.definition.rootApiFile.contents.name}:${registerApiResponse.body.version}`
         );
@@ -1642707,7 +1642700,7 @@ async function generateDiff({
 }
 
 // src/commands/self-update/selfUpdate.ts
-var import_promises103 = require("fs/promises");
+var import_promises102 = require("fs/promises");
 var import_path57 = require("path");
 async function getPackageManagerBinDir(logger, pm) {
   let command2;
@@ -1642753,7 +1642746,7 @@ async function detectInstallationMethod(logger) {
   logger.debug(`Found fern at: ${fernPath}`);
   let resolvedPath;
   try {
-    resolvedPath = await (0, import_promises103.realpath)(fernPath);
+    resolvedPath = await (0, import_promises102.realpath)(fernPath);
     logger.debug(`Resolved to: ${resolvedPath}`);
   } catch (error2) {
     logger.debug(`Failed to resolve symlink: ${error2}`);
@@ -1643034,20 +1643027,20 @@ async function generateToken({
 
 // src/commands/upgrade/updateApiSpec.ts
 var fs22 = __toESM(require("fs"), 1);
-var import_promises104 = require("fs/promises");
+var import_promises103 = require("fs/promises");
 var import_stream9 = require("stream");
-var import_promises105 = require("stream/promises");
+var import_promises104 = require("stream/promises");
 async function fetchAndWriteFile(url2, path69, logger, indent3) {
   const resp = await fetch(url2);
   if (resp.ok && resp.body) {
     logger.debug("Origin successfully fetched, writing to file");
     const fileStream = fs22.createWriteStream(path69);
-    await (0, import_promises105.finished)(import_stream9.Readable.fromWeb(resp.body).pipe(fileStream));
-    const fileContents = await (0, import_promises104.readFile)(path69, "utf8");
+    await (0, import_promises104.finished)(import_stream9.Readable.fromWeb(resp.body).pipe(fileStream));
+    const fileContents = await (0, import_promises103.readFile)(path69, "utf8");
     try {
-      await (0, import_promises104.writeFile)(path69, JSON.stringify(JSON.parse(fileContents), void 0, indent3), "utf8");
+      await (0, import_promises103.writeFile)(path69, JSON.stringify(JSON.parse(fileContents), void 0, indent3), "utf8");
     } catch (e6) {
-      await (0, import_promises104.writeFile)(path69, jsYaml.dump(jsYaml.load(fileContents), { indent: indent3 }), "utf8");
+      await (0, import_promises103.writeFile)(path69, jsYaml.dump(jsYaml.load(fileContents), { indent: indent3 }), "utf8");
     }
     logger.debug("File written successfully");
   }
@@ -1643143,7 +1643136,7 @@ async function processDefinitions({
 }
 
 // ../cli-migrations/lib/migrations/0.0.191/discriminant/migration.js
-var import_promises106 = require("fs/promises");
+var import_promises105 = require("fs/promises");
 
 // ../cli-migrations/lib/migrations/0.0.191/discriminant/getAllYamlFiles.js
 var FERN_DIRECTORY2 = "fern";
@@ -1643177,7 +1643170,7 @@ var migration = {
       try {
         const fileContents = await getFileContents(yamlFilepath);
         const newContents = addDiscriminantToFile(fileContents);
-        await (0, import_promises106.writeFile)(yamlFilepath, newContents);
+        await (0, import_promises105.writeFile)(yamlFilepath, newContents);
       } catch (error2) {
         context2.failAndThrow("Failed to migrate " + yamlFilepath, error2);
       }
@@ -1643185,7 +1643178,7 @@ var migration = {
   }
 };
 async function getFileContents(filepath) {
-  const buffer = await (0, import_promises106.readFile)(filepath);
+  const buffer = await (0, import_promises105.readFile)(filepath);
   return buffer.toString();
 }
 var UNION_REGEX = /^(\s{2,})union:\s*$/gm;
@@ -1643214,7 +1643207,7 @@ var versionMigrations = {
 var __default = versionMigrations;
 
 // ../cli-migrations/lib/migrations/0.0.203/union-single-property-key/migration.js
-var import_promises107 = require("fs/promises");
+var import_promises106 = require("fs/promises");
 var import_yaml3 = __toESM(require_dist4(), 1);
 
 // ../cli-migrations/lib/migrations/0.0.203/union-single-property-key/getAllYamlFiles.js
@@ -1643255,7 +1643248,7 @@ var migration2 = {
   }
 };
 async function migrateFile(filepath, context2) {
-  const contents = await (0, import_promises107.readFile)(filepath);
+  const contents = await (0, import_promises106.readFile)(filepath);
   const parsedDocument = import_yaml3.default.parseDocument(contents.toString());
   const types4 = parsedDocument.get("types");
   if (types4 == null) {
@@ -1643287,7 +1643280,7 @@ async function migrateFile(filepath, context2) {
       }
     }
   }
-  await (0, import_promises107.writeFile)(filepath, parsedDocument.toString());
+  await (0, import_promises106.writeFile)(filepath, parsedDocument.toString());
 }
 
 // ../cli-migrations/lib/migrations/0.0.203/index.js
@@ -1643298,7 +1643291,7 @@ var versionMigrations2 = {
 var __default2 = versionMigrations2;
 
 // ../cli-migrations/lib/migrations/0.0.207/add-mode-to-draft-generators/migration.js
-var import_promises108 = require("fs/promises");
+var import_promises107 = require("fs/promises");
 var import_yaml4 = __toESM(require_dist4(), 1);
 
 // ../cli-migrations/lib/migrations/0.0.207/add-mode-to-draft-generators/getAllGeneratorYamlFiles.js
@@ -1643339,7 +1643332,7 @@ var migration3 = {
   }
 };
 async function migrateGeneratorsYml(filepath, context2) {
-  const contents = await (0, import_promises108.readFile)(filepath);
+  const contents = await (0, import_promises107.readFile)(filepath);
   const parsedDocument = import_yaml4.default.parseDocument(contents.toString());
   const draftGenerators = parsedDocument.get("draft");
   if (draftGenerators == null) {
@@ -1643366,7 +1643359,7 @@ async function migrateGeneratorsYml(filepath, context2) {
       draftGenerator.set("output-path", name2.value.includes("openapi") ? "./generated-openapi" : name2.value.includes("postman") ? "./generated-postman" : localOutput);
     }
   });
-  await (0, import_promises108.writeFile)(filepath, parsedDocument.toString());
+  await (0, import_promises107.writeFile)(filepath, parsedDocument.toString());
 }
 
 // ../cli-migrations/lib/migrations/0.0.207/index.js
@@ -1643377,7 +1643370,7 @@ var versionMigrations3 = {
 var __default3 = versionMigrations3;
 
 // ../cli-migrations/lib/migrations/0.0.210/remove-inline-error-declarations/migration.js
-var import_promises109 = require("fs/promises");
+var import_promises108 = require("fs/promises");
 var import_yaml5 = __toESM(require_dist4(), 1);
 
 // ../cli-migrations/lib/migrations/0.0.210/remove-inline-error-declarations/getAllYamlFiles.js
@@ -1643418,7 +1643411,7 @@ var migration4 = {
   }
 };
 async function migrateFile2(filepath, context2) {
-  const contents = await (0, import_promises109.readFile)(filepath);
+  const contents = await (0, import_promises108.readFile)(filepath);
   const parsedDocument = import_yaml5.default.parseDocument(contents.toString());
   const addType = (typeName, typeDeclaration) => {
     const types4 = parsedDocument.get("types");
@@ -1643462,7 +1643455,7 @@ async function migrateFile2(filepath, context2) {
       }
     }
   }
-  await (0, import_promises109.writeFile)(filepath, parsedDocument.toString());
+  await (0, import_promises108.writeFile)(filepath, parsedDocument.toString());
 }
 
 // ../cli-migrations/lib/migrations/0.0.210/index.js
@@ -1643473,7 +1643466,7 @@ var versionMigrations4 = {
 var __default4 = versionMigrations4;
 
 // ../cli-migrations/lib/migrations/0.0.212/add-publishing-to-release-generators/migration.js
-var import_promises110 = require("fs/promises");
+var import_promises109 = require("fs/promises");
 var import_yaml6 = __toESM(require_dist4(), 1);
 
 // ../cli-migrations/lib/migrations/0.0.212/add-publishing-to-release-generators/getAllGeneratorYamlFiles.js
@@ -1643514,7 +1643507,7 @@ var migration5 = {
   }
 };
 async function migrateGeneratorsYml2(filepath, context2) {
-  const contents = await (0, import_promises110.readFile)(filepath);
+  const contents = await (0, import_promises109.readFile)(filepath);
   const parsedDocument = import_yaml6.default.parseDocument(contents.toString());
   const releaseGenerators = parsedDocument.get("release");
   if (releaseGenerators == null) {
@@ -1643552,7 +1643545,7 @@ async function migrateGeneratorsYml2(filepath, context2) {
     }
     releaseGenerator.delete("outputs");
   });
-  await (0, import_promises110.writeFile)(filepath, parsedDocument.toString());
+  await (0, import_promises109.writeFile)(filepath, parsedDocument.toString());
 }
 
 // ../cli-migrations/lib/migrations/0.0.212/index.js
@@ -1643563,7 +1643556,7 @@ var versionMigrations5 = {
 var __default5 = versionMigrations5;
 
 // ../cli-migrations/lib/migrations/0.0.220/rename-alias-key-to-type/migration.js
-var import_promises111 = require("fs/promises");
+var import_promises110 = require("fs/promises");
 
 // ../cli-migrations/lib/migrations/0.0.220/rename-alias-key-to-type/getAllYamlFiles.js
 var FERN_DIRECTORY7 = "fern";
@@ -1643594,9 +1643587,9 @@ var migration6 = {
   run: async ({ context: context2 }) => {
     const yamlFiles = await getAllYamlFiles4(context2);
     for (const filepath of yamlFiles) {
-      const contents = await (0, import_promises111.readFile)(filepath);
+      const contents = await (0, import_promises110.readFile)(filepath);
       const newContents = contents.toString().replaceAll(" alias:", " type:");
-      await (0, import_promises111.writeFile)(filepath, newContents);
+      await (0, import_promises110.writeFile)(filepath, newContents);
     }
   }
 };
@@ -1643609,7 +1643602,7 @@ var versionMigrations6 = {
 var __default6 = versionMigrations6;
 
 // ../cli-migrations/lib/migrations/0.0.221/add-error-discriminant/migration.js
-var import_promises112 = require("fs/promises");
+var import_promises111 = require("fs/promises");
 
 // ../cli-migrations/lib/migrations/0.0.221/add-error-discriminant/getAllRootApiYamlFiles.js
 var FERN_DIRECTORY8 = "fern";
@@ -1643640,9 +1643633,9 @@ var migration7 = {
   run: async ({ context: context2 }) => {
     const yamlFiles = await getAllRootApiYamlFiles(context2);
     for (const filepath of yamlFiles) {
-      const contents = await (0, import_promises112.readFile)(filepath);
+      const contents = await (0, import_promises111.readFile)(filepath);
       const newContents = contents.toString() + "\nerror-discriminant: error";
-      await (0, import_promises112.writeFile)(filepath, newContents);
+      await (0, import_promises111.writeFile)(filepath, newContents);
     }
   }
 };
@@ -1643655,7 +1643648,7 @@ var versionMigrations7 = {
 var __default7 = versionMigrations7;
 
 // ../cli-migrations/lib/migrations/0.0.241/add-generator-groups/migration.js
-var import_promises113 = require("fs/promises");
+var import_promises112 = require("fs/promises");
 
 // ../cli-migrations/lib/migrations/0.0.241/add-generator-groups/getAllGeneratorYamlFiles.js
 var FERN_DIRECTORY9 = "fern";
@@ -1643762,7 +1643755,7 @@ var migration8 = {
   }
 };
 async function migrateGeneratorsYml3(filepath) {
-  const contentsStr = await (0, import_promises113.readFile)(filepath);
+  const contentsStr = await (0, import_promises112.readFile)(filepath);
   const contents = jsYaml.load(contentsStr.toString());
   const oldGeneratorsConfiguration = GeneratorsConfigurationSchema2.parse(contents);
   let newGeneratorsConfiguration = {};
@@ -1643780,7 +1643773,7 @@ async function migrateGeneratorsYml3(filepath) {
       generators: oldGeneratorsConfiguration.release.map((releaseGeneratorInvocation) => convertReleaseGeneratorInvocation(releaseGeneratorInvocation))
     };
   }
-  await (0, import_promises113.writeFile)(filepath, jsYaml.dump(newGeneratorsConfiguration));
+  await (0, import_promises112.writeFile)(filepath, jsYaml.dump(newGeneratorsConfiguration));
 }
 function convertDraftGeneratorInvocation(draftGeneratorInvocation) {
   const newSchema = {
@@ -1643855,7 +1643848,7 @@ var versionMigrations8 = {
 var __default8 = versionMigrations8;
 
 // ../cli-migrations/lib/migrations/0.0.248/add-error-discrimination-config/migration.js
-var import_promises114 = require("fs/promises");
+var import_promises113 = require("fs/promises");
 var import_yaml7 = __toESM(require_dist4(), 1);
 
 // ../cli-migrations/lib/migrations/0.0.248/add-error-discrimination-config/getAllRootApiYamlFiles.js
@@ -1643896,7 +1643889,7 @@ var migration9 = {
   }
 };
 async function migrateRootApiFile(filepath) {
-  const contents = await (0, import_promises114.readFile)(filepath);
+  const contents = await (0, import_promises113.readFile)(filepath);
   const parsedDocument = import_yaml7.default.parseDocument(contents.toString());
   const errorDiscriminant = parsedDocument.get("error-discriminant", true);
   if (errorDiscriminant == null || !import_yaml7.default.isScalar(errorDiscriminant) || typeof errorDiscriminant.value !== "string") {
@@ -1643907,7 +1643900,7 @@ async function migrateRootApiFile(filepath) {
     "property-name": errorDiscriminant.value
   });
   parsedDocument.delete("error-discriminant");
-  await (0, import_promises114.writeFile)(filepath, parsedDocument.toString());
+  await (0, import_promises113.writeFile)(filepath, parsedDocument.toString());
 }
 
 // ../cli-migrations/lib/migrations/0.0.248/index.js
@@ -1643918,7 +1643911,7 @@ var versionMigrations9 = {
 var __default9 = versionMigrations9;
 
 // ../cli-migrations/lib/migrations/0.1.3-rc3/add-inline-requests/migration.js
-var import_promises115 = require("fs/promises");
+var import_promises114 = require("fs/promises");
 var import_yaml8 = __toESM(require_dist4(), 1);
 
 // ../cli-migrations/lib/migrations/0.1.3-rc3/add-inline-requests/getAllYamlFiles.js
@@ -1643959,7 +1643952,7 @@ var migration10 = {
   }
 };
 async function migrateYamlFile(filepath, context2) {
-  const contents = await (0, import_promises115.readFile)(filepath);
+  const contents = await (0, import_promises114.readFile)(filepath);
   const parsedDocument = import_yaml8.default.parseDocument(contents.toString());
   const services = parsedDocument.get("services");
   if (services == null) {
@@ -1643999,7 +1643992,7 @@ async function migrateYamlFile(filepath, context2) {
         context2.failWithoutThrowing("Failed to convert endpoint", e6);
       }
     }
-    await (0, import_promises115.writeFile)(filepath, parsedDocument.toString());
+    await (0, import_promises114.writeFile)(filepath, parsedDocument.toString());
   }
 }
 function convertEndpoint20({ document: document4, endpoint: endpoint3 }) {
@@ -1644078,7 +1644071,7 @@ var versionMigrations10 = {
 var __default10 = versionMigrations10;
 
 // ../cli-migrations/lib/migrations/0.3.0-rc12/add-value-key-to-type-examples/migration.js
-var import_promises116 = require("fs/promises");
+var import_promises115 = require("fs/promises");
 var import_yaml9 = __toESM(require_dist4(), 1);
 
 // ../cli-migrations/lib/migrations/0.3.0-rc12/add-value-key-to-type-examples/getAllYamlFiles.js
@@ -1644119,7 +1644112,7 @@ var migration11 = {
   }
 };
 async function migrateYamlFile2(filepath, context2) {
-  const contents = await (0, import_promises116.readFile)(filepath);
+  const contents = await (0, import_promises115.readFile)(filepath);
   const parsedDocument = import_yaml9.default.parseDocument(contents.toString());
   const types4 = parsedDocument.get("types");
   if (types4 == null) {
@@ -1644145,7 +1644138,7 @@ async function migrateYamlFile2(filepath, context2) {
       examples.set(i11, { value });
     }
   }
-  await (0, import_promises116.writeFile)(filepath, parsedDocument.toString());
+  await (0, import_promises115.writeFile)(filepath, parsedDocument.toString());
 }
 
 // ../cli-migrations/lib/migrations/0.3.0-rc12/index.js
@@ -1644156,7 +1644149,7 @@ var versionMigrations11 = {
 var __default11 = versionMigrations11;
 
 // ../cli-migrations/lib/migrations/0.3.23/change-services-key-to-service/migration.js
-var import_promises117 = require("fs/promises");
+var import_promises116 = require("fs/promises");
 var import_yaml10 = __toESM(require_dist4(), 1);
 
 // ../cli-migrations/lib/migrations/0.3.23/change-services-key-to-service/getAllYamlFiles.js
@@ -1644197,7 +1644190,7 @@ var migration12 = {
   }
 };
 async function migrateYamlFile3(filepath, context2) {
-  const contents = await (0, import_promises117.readFile)(filepath);
+  const contents = await (0, import_promises116.readFile)(filepath);
   const parsedDocument = import_yaml10.default.parseDocument(contents.toString());
   if (!import_yaml10.default.isMap(parsedDocument.contents)) {
     return context2.failAndThrow("File is not a map");
@@ -1644227,7 +1644220,7 @@ async function migrateYamlFile3(filepath, context2) {
       pair.value = firstService.value;
     }
   }
-  await (0, import_promises117.writeFile)(filepath, parsedDocument.toString());
+  await (0, import_promises116.writeFile)(filepath, parsedDocument.toString());
 }
 
 // ../cli-migrations/lib/migrations/0.3.23/index.js
@@ -1644238,7 +1644231,7 @@ var versionMigrations12 = {
 var __default12 = versionMigrations12;
 
 // ../cli-migrations/lib/migrations/0.5.4/move-service-docs-to-top-level/migration.js
-var import_promises118 = require("fs/promises");
+var import_promises117 = require("fs/promises");
 var import_yaml11 = __toESM(require_dist4(), 1);
 
 // ../cli-migrations/lib/migrations/0.5.4/move-service-docs-to-top-level/getAllYamlFiles.js
@@ -1644279,7 +1644272,7 @@ var migration13 = {
   }
 };
 async function migrateYamlFile4(filepath, context2) {
-  const contents = await (0, import_promises118.readFile)(filepath);
+  const contents = await (0, import_promises117.readFile)(filepath);
   const parsedDocument = import_yaml11.default.parseDocument(contents.toString());
   if (!import_yaml11.default.isMap(parsedDocument.contents)) {
     return context2.failAndThrow("File is not a map");
@@ -1644298,7 +1644291,7 @@ async function migrateYamlFile4(filepath, context2) {
   }
   service.items.splice(indexOfServiceDocsPair, 1);
   parsedDocument.contents.items.unshift(docsPair);
-  await (0, import_promises118.writeFile)(filepath, parsedDocument.toString());
+  await (0, import_promises117.writeFile)(filepath, parsedDocument.toString());
 }
 
 // ../cli-migrations/lib/migrations/0.5.4/index.js
@@ -1644309,7 +1644302,7 @@ var versionMigrations13 = {
 var __default13 = versionMigrations13;
 
 // ../cli-migrations/lib/migrations/0.9.10/add-suffix-to-docs-domain/migration.js
-var import_promises119 = require("fs/promises");
+var import_promises118 = require("fs/promises");
 
 // ../cli-migrations/lib/migrations/0.9.10/add-suffix-to-docs-domain/getAllGeneratorYamlFiles.js
 var FERN_DIRECTORY15 = "fern";
@@ -1644349,14 +1644342,14 @@ var migration14 = {
   }
 };
 async function migrateYamlFile5(filepath) {
-  const contents = await (0, import_promises119.readFile)(filepath);
+  const contents = await (0, import_promises118.readFile)(filepath);
   const domainSuffix = process.env.DOMAIN_SUFFIX ?? "docs.buildwithfern.com";
   const regex5 = /(docs:\s*domain:\s*)"([^"]*)"/g;
   const updatedSnapshot = contents.toString().replace(regex5, (_match, _prefix, domain2) => {
     return `docs:
       domain: "${domain2}.${domainSuffix}"`;
   });
-  await (0, import_promises119.writeFile)(filepath, updatedSnapshot.toString());
+  await (0, import_promises118.writeFile)(filepath, updatedSnapshot.toString());
 }
 
 // ../cli-migrations/lib/migrations/0.9.10/index.js
@@ -1644372,10 +1644365,10 @@ var import_legacy_docs_config = __toESM(require_legacy_docs_config(), 1);
 var LegacyDocsSerializers = __toESM(require_serialization44(), 1);
 
 // ../cli-migrations/lib/migrations/0.15.0-rc0/update-directory-structure/docs-config/loadRawDocsConfiguration.js
-var import_promises120 = require("fs/promises");
+var import_promises119 = require("fs/promises");
 async function loadRawDocsConfiguration2({ absolutePathToWorkspace }) {
   const filepath = getAbsolutePathToDocsYaml({ absolutePathToWorkspace });
-  const contentsStr = await (0, import_promises120.readFile)(filepath);
+  const contentsStr = await (0, import_promises119.readFile)(filepath);
   const contentsParsed = jsYaml.load(contentsStr.toString());
   const result = await LegacyDocsSerializers.DocsConfiguration.parse(contentsParsed);
   if (result.ok) {
@@ -1644393,7 +1644386,7 @@ function getAbsolutePathToDocsFolder({ absolutePathToWorkspace }) {
 }
 
 // ../cli-migrations/lib/migrations/0.15.0-rc0/update-directory-structure/migrateDocsAndMultipleAPIs.js
-var import_promises122 = require("fs/promises");
+var import_promises121 = require("fs/promises");
 
 // ../cli-migrations/lib/migrations/0.15.0-rc0/update-directory-structure/docs-config/convertLegacyDocsConfig.js
 function convertLegacyDocsConfig({ docsConfiguration, docsURLs, apiName }) {
@@ -1644571,10 +1644564,10 @@ __export(legacy_exports, {
 });
 
 // ../cli-migrations/lib/migrations/0.15.0-rc0/update-directory-structure/generators-configuration/loadRawGeneratorsConfiguration.js
-var import_promises121 = require("fs/promises");
+var import_promises120 = require("fs/promises");
 async function loadRawGeneratorsConfiguration2({ absolutePathToWorkspace }) {
   const filepath = getAbsolutePathToGeneratorsConfiguration({ absolutePathToWorkspace });
-  const contentsStr = await (0, import_promises121.readFile)(filepath);
+  const contentsStr = await (0, import_promises120.readFile)(filepath);
   const contentsParsed = jsYaml.load(contentsStr.toString());
   const result = await legacy_exports.GeneratorsConfigurationSchema.safeParseAsync(contentsParsed);
   if (result.success) {
@@ -1644604,7 +1644597,7 @@ function migrateDocsInstances(docsURLs) {
 var APIS_DIRECTORY2 = "apis";
 async function migrateDocsAndMultipleAPIs({ absolutePathToFernDirectory, workspaces, workspaceContainingDocs }) {
   const absolutePathToApisDirectory = join2(absolutePathToFernDirectory, RelativeFilePath2.of(APIS_DIRECTORY2));
-  await (0, import_promises122.mkdir)(absolutePathToApisDirectory);
+  await (0, import_promises121.mkdir)(absolutePathToApisDirectory);
   for (const workspace of workspaces) {
     const absolutePathToWorkspace = join2(absolutePathToFernDirectory, RelativeFilePath2.of(workspace));
     const docsURLs = await migrateAndWriteGeneratorsYml({ absolutePathToWorkspace });
@@ -1644612,11 +1644605,11 @@ async function migrateDocsAndMultipleAPIs({ absolutePathToFernDirectory, workspa
       await migrateAndWriteDocsYml({ absolutePathToWorkspace, docsURLs, apiName: workspaceContainingDocs });
       const absolutePathToDocsFolder = getAbsolutePathToDocsFolder({ absolutePathToWorkspace });
       await moveFolder({ src: absolutePathToDocsFolder, dest: absolutePathToFernDirectory });
-      await (0, import_promises122.rm)(absolutePathToDocsFolder, { recursive: true });
+      await (0, import_promises121.rm)(absolutePathToDocsFolder, { recursive: true });
     }
     const absolutePathToNestedWorkspace = join2(absolutePathToApisDirectory, RelativeFilePath2.of(workspace));
     await moveFolder({ src: absolutePathToWorkspace, dest: absolutePathToNestedWorkspace });
-    await (0, import_promises122.rm)(absolutePathToWorkspace, { recursive: true });
+    await (0, import_promises121.rm)(absolutePathToWorkspace, { recursive: true });
   }
 }
 async function migrateAndWriteGeneratorsYml({ absolutePathToWorkspace }) {
@@ -1644629,7 +1644622,7 @@ async function migrateAndWriteGeneratorsYml({ absolutePathToWorkspace }) {
     generatorsConfiguration,
     pathModificationStrategy: PathModificationStrategy.Nest
   });
-  await (0, import_promises122.writeFile)(absolutePathToGeneratorsConfiguration, jsYaml.dump(convertedResponse.value));
+  await (0, import_promises121.writeFile)(absolutePathToGeneratorsConfiguration, jsYaml.dump(convertedResponse.value));
   return convertedResponse.docsURLs;
 }
 async function migrateAndWriteDocsYml({ absolutePathToWorkspace, docsURLs, apiName }) {
@@ -1644643,19 +1644636,19 @@ async function migrateAndWriteDocsYml({ absolutePathToWorkspace, docsURLs, apiNa
     apiName
   });
   const absolutePathToDocsConfig = getAbsolutePathToDocsYaml({ absolutePathToWorkspace });
-  await (0, import_promises122.writeFile)(absolutePathToDocsConfig, jsYaml.dump(convertedDocsConfig));
+  await (0, import_promises121.writeFile)(absolutePathToDocsConfig, jsYaml.dump(convertedDocsConfig));
 }
 
 // ../cli-migrations/lib/migrations/0.15.0-rc0/update-directory-structure/migrateDocsAndSingleAPI.js
-var import_promises123 = require("fs/promises");
+var import_promises122 = require("fs/promises");
 async function migrateDocsAndSingleAPI({ absolutePathToFernDirectory, absolutePathToWorkspace }) {
   const docsURLs = await migrateAndWriteGeneratorsYml2({ absolutePathToWorkspace });
   await migrateAndWriteDocsYml2({ absolutePathToWorkspace, docsURLs });
   const absolutePathToDocsFolder = getAbsolutePathToDocsFolder({ absolutePathToWorkspace });
   await moveFolder({ src: absolutePathToDocsFolder, dest: absolutePathToFernDirectory });
   await moveFolder({ src: absolutePathToWorkspace, dest: absolutePathToFernDirectory });
-  await (0, import_promises123.rm)(absolutePathToDocsFolder, { recursive: true });
-  await (0, import_promises123.rm)(absolutePathToWorkspace, { recursive: true });
+  await (0, import_promises122.rm)(absolutePathToDocsFolder, { recursive: true });
+  await (0, import_promises122.rm)(absolutePathToWorkspace, { recursive: true });
 }
 async function migrateAndWriteDocsYml2({ absolutePathToWorkspace, docsURLs }) {
   const docsConfiguration = await loadRawDocsConfiguration2({ absolutePathToWorkspace });
@@ -1644668,7 +1644661,7 @@ async function migrateAndWriteDocsYml2({ absolutePathToWorkspace, docsURLs }) {
     apiName: void 0
   });
   const absolutePathToDocsConfig = getAbsolutePathToDocsYaml({ absolutePathToWorkspace });
-  await (0, import_promises123.writeFile)(absolutePathToDocsConfig, jsYaml.dump(convertedDocsConfig));
+  await (0, import_promises122.writeFile)(absolutePathToDocsConfig, jsYaml.dump(convertedDocsConfig));
 }
 async function migrateAndWriteGeneratorsYml2({ absolutePathToWorkspace }) {
   const generatorsConfiguration = await loadRawGeneratorsConfiguration2({ absolutePathToWorkspace });
@@ -1644680,22 +1644673,22 @@ async function migrateAndWriteGeneratorsYml2({ absolutePathToWorkspace }) {
     generatorsConfiguration,
     pathModificationStrategy: "MoveUp"
   });
-  await (0, import_promises123.writeFile)(absolutePathToGeneratorsConfiguration, jsYaml.dump(convertedResponse.value));
+  await (0, import_promises122.writeFile)(absolutePathToGeneratorsConfiguration, jsYaml.dump(convertedResponse.value));
   return convertedResponse.docsURLs;
 }
 
 // ../cli-migrations/lib/migrations/0.15.0-rc0/update-directory-structure/migrateOnlyMultipleAPIs.js
-var import_promises124 = require("fs/promises");
+var import_promises123 = require("fs/promises");
 var APIS_DIRECTORY3 = "apis";
 async function migrateOnlyMultipleAPIs({ absolutePathToFernDirectory, workspaces }) {
   const absolutePathToApisDirectory = join2(absolutePathToFernDirectory, RelativeFilePath2.of(APIS_DIRECTORY3));
-  await (0, import_promises124.mkdir)(absolutePathToApisDirectory);
+  await (0, import_promises123.mkdir)(absolutePathToApisDirectory);
   for (const workspace of workspaces) {
     const absolutePathToWorkspace = join2(absolutePathToFernDirectory, RelativeFilePath2.of(workspace));
     await migrateAndWriteGeneratorsYml3({ absolutePathToWorkspace });
     const absolutePathToNestedWorkspace = join2(absolutePathToApisDirectory, RelativeFilePath2.of(workspace));
     await moveFolder({ src: absolutePathToWorkspace, dest: absolutePathToNestedWorkspace });
-    await (0, import_promises124.rm)(absolutePathToWorkspace, { recursive: true });
+    await (0, import_promises123.rm)(absolutePathToWorkspace, { recursive: true });
   }
 }
 async function migrateAndWriteGeneratorsYml3({ absolutePathToWorkspace }) {
@@ -1644708,15 +1644701,15 @@ async function migrateAndWriteGeneratorsYml3({ absolutePathToWorkspace }) {
     generatorsConfiguration,
     pathModificationStrategy: PathModificationStrategy.Nest
   });
-  await (0, import_promises124.writeFile)(absolutePathToGeneratorsConfiguration, jsYaml.dump(convertedResponse.value));
+  await (0, import_promises123.writeFile)(absolutePathToGeneratorsConfiguration, jsYaml.dump(convertedResponse.value));
 }
 
 // ../cli-migrations/lib/migrations/0.15.0-rc0/update-directory-structure/migrateOnlySingleAPI.js
-var import_promises125 = require("fs/promises");
+var import_promises124 = require("fs/promises");
 async function migrateOnlySingleAPI({ absolutePathToFernDirectory, absolutePathToWorkspace }) {
   await migrateAndWriteGeneratorsYml4({ absolutePathToWorkspace });
   await moveFolder({ src: absolutePathToWorkspace, dest: absolutePathToFernDirectory });
-  await (0, import_promises125.rm)(absolutePathToWorkspace, { recursive: true });
+  await (0, import_promises124.rm)(absolutePathToWorkspace, { recursive: true });
 }
 async function migrateAndWriteGeneratorsYml4({ absolutePathToWorkspace }) {
   const generatorsConfiguration = await loadRawGeneratorsConfiguration2({ absolutePathToWorkspace });
@@ -1644728,7 +1644721,7 @@ async function migrateAndWriteGeneratorsYml4({ absolutePathToWorkspace }) {
     generatorsConfiguration,
     pathModificationStrategy: "MoveUp"
   });
-  await (0, import_promises125.writeFile)(absolutePathToGeneratorsConfiguration, jsYaml.dump(convertedResponse.value));
+  await (0, import_promises124.writeFile)(absolutePathToGeneratorsConfiguration, jsYaml.dump(convertedResponse.value));
 }
 
 // ../cli-migrations/lib/migrations/0.15.0-rc0/update-directory-structure/migration.js
@@ -1644805,7 +1644798,7 @@ var versionMigrations15 = {
 var __default15 = versionMigrations15;
 
 // ../cli-migrations/lib/migrations/0.41.0-rc0/require-generators-yml/migration.js
-var import_promises126 = require("fs/promises");
+var import_promises125 = require("fs/promises");
 var import_yaml12 = __toESM(require_dist4(), 1);
 var migration16 = {
   name: "require-generators-yml",
@@ -1644848,7 +1644841,7 @@ async function addApiConfigurationToSingleWorkspace({ absolutePathToFernDirector
   if (existingGeneratorsYml == null) {
     if (openapiDirectory != null && openapiDirectory.contents[0] != null) {
       const absolutePathToGeneratorsYml = join2(absoluteFilepathToWorkspace, RelativeFilePath2.of("generators.yml"));
-      await (0, import_promises126.writeFile)(absolutePathToGeneratorsYml, jsYaml.dump({
+      await (0, import_promises125.writeFile)(absolutePathToGeneratorsYml, jsYaml.dump({
         api: {
           path: join2(relativize(absolutePathToFernDirectory, absoluteFilepathToWorkspace), RelativeFilePath2.of(openapiDirectory.name), RelativeFilePath2.of(openapiDirectory.contents[0]?.name))
         }
@@ -1644863,7 +1644856,7 @@ async function addApiConfigurationToSingleWorkspace({ absolutePathToFernDirector
       parsedDocument.set("api", {
         path: join2(relativize(absolutePathToFernDirectory, absoluteFilepathToWorkspace), RelativeFilePath2.of(openapiDirectory.name), RelativeFilePath2.of(openapiDirectory.contents[0]?.name))
       });
-      await (0, import_promises126.writeFile)(existingGeneratorsYml.absolutePath, parsedDocument.toString());
+      await (0, import_promises125.writeFile)(existingGeneratorsYml.absolutePath, parsedDocument.toString());
       context2.logger.info(source_default.green(`Updated ${existingGeneratorsYml.absolutePath}`));
     }
   }
@@ -1644890,7 +1644883,7 @@ var versionMigrations16 = {
 var __default16 = versionMigrations16;
 
 // ../cli-migrations/lib/migrations/0.54.0-rc0/use-generators-yml-specs/migration.js
-var import_promises127 = require("fs/promises");
+var import_promises126 = require("fs/promises");
 var import_yaml13 = __toESM(require_dist4(), 1);
 var migration17 = {
   name: "generators-yml-use-api-specs",
@@ -1645070,7 +1645063,7 @@ async function addApiConfigurationToSingleWorkspace2({ absoluteFilepathToWorkspa
   if (schemaComment && documentToWrite.indexOf(schemaComment) === -1) {
     documentToWrite = `${schemaComment}${documentToWrite}`;
   }
-  await (0, import_promises127.writeFile)(generatorsYmlFile.absolutePath, documentToWrite);
+  await (0, import_promises126.writeFile)(generatorsYmlFile.absolutePath, documentToWrite);
   context2.logger.info(source_default.green(`Updated ${generatorsYmlFile.absolutePath}`));
 }
 async function parseApiSpec({ oldSpec, absoluteFilepathToWorkspace, files, directories, context: context2, namespace }) {
@@ -1645117,7 +1645110,7 @@ async function parseApiSpec({ oldSpec, absoluteFilepathToWorkspace, files, direc
   }
   let specContent;
   try {
-    const fileContents = await (0, import_promises127.readFile)(absoluteSpecPath, { encoding: "utf-8" });
+    const fileContents = await (0, import_promises126.readFile)(absoluteSpecPath, { encoding: "utf-8" });
     specContent = jsYaml.load(fileContents);
   } catch (e6) {
     context2.logger.warn(`Failed to read API spec file ${spec.path}. Error: ${e6}. Skipping...`);
@@ -1645220,7 +1645213,7 @@ var versionMigrations17 = {
 var __default17 = versionMigrations17;
 
 // ../cli-migrations/lib/migrations/0.82.1/add-path-parameter-order-setting/migration.js
-var import_promises128 = require("fs/promises");
+var import_promises127 = require("fs/promises");
 var migration18 = {
   name: "add-path-parameter-order-setting",
   summary: `Adds the 'path-parameter-order' setting to existing API configurations to maintain backwards compatibility.
@@ -1645308,7 +1645301,7 @@ async function updateGeneratorsYml({ context: context2, files }) {
     documentToWrite = `${schemaComment}
 ${documentToWrite}`;
   }
-  await (0, import_promises128.writeFile)(generatorsYmlFile.absolutePath, documentToWrite);
+  await (0, import_promises127.writeFile)(generatorsYmlFile.absolutePath, documentToWrite);
   context2.logger.info(source_default.green(`Updated ${generatorsYmlFile.absolutePath}`));
 }
 async function getFilesAndDirectories3(absoluteFilepath) {
@@ -1645344,7 +1645337,7 @@ var versionMigrations18 = {
 var __default18 = versionMigrations18;
 
 // ../cli-migrations/lib/migrations/1.0.0/update-settings-defaults/migration.js
-var import_promises129 = require("fs/promises");
+var import_promises128 = require("fs/promises");
 var migration19 = {
   name: "update-1_0_0-defaults",
   summary: `The defaults of the API spec settings have changed. 
@@ -1645519,7 +1645512,7 @@ async function updateGeneratorsYml2({ context: context2, files }) {
     documentToWrite = `${schemaComment}
 ${documentToWrite}`;
   }
-  await (0, import_promises129.writeFile)(generatorsYmlFile.absolutePath, documentToWrite);
+  await (0, import_promises128.writeFile)(generatorsYmlFile.absolutePath, documentToWrite);
   context2.logger.info(source_default.green(`Updated ${generatorsYmlFile.absolutePath}`));
 }
 async function getFilesAndDirectories4(absoluteFilepath) {
@@ -1645588,7 +1645581,7 @@ var versionMigrations19 = {
 var __default19 = versionMigrations19;
 
 // ../cli-migrations/lib/migrations/2.0.0-rc0/update-settings-defaults/migration.js
-var import_promises130 = require("fs/promises");
+var import_promises129 = require("fs/promises");
 var migration20 = {
   name: "update-2_0_0-defaults",
   summary: `The default of 'coerce-enums-to-literals' has changed from true to false. 
@@ -1645763,7 +1645756,7 @@ async function updateGeneratorsYml3({ context: context2, files }) {
     documentToWrite = `${schemaComment}
 ${documentToWrite}`;
   }
-  await (0, import_promises130.writeFile)(generatorsYmlFile.absolutePath, documentToWrite);
+  await (0, import_promises129.writeFile)(generatorsYmlFile.absolutePath, documentToWrite);
   context2.logger.info(source_default.green(`Updated ${generatorsYmlFile.absolutePath}`));
 }
 async function getFilesAndDirectories5(absoluteFilepath) {
@@ -1645809,7 +1645802,7 @@ var versionMigrations20 = {
 var __default20 = versionMigrations20;
 
 // ../cli-migrations/lib/migrations/2.13.0/migrate-deprecated-generator-api-settings/migration.js
-var import_promises131 = require("fs/promises");
+var import_promises130 = require("fs/promises");
 var migration21 = {
   name: "migrate-deprecated-generator-api-settings",
   summary: `Migrates deprecated generator-level API settings keys to their new equivalents:
@@ -1645900,7 +1645893,7 @@ async function updateGeneratorsYml4({ context: context2, files }) {
     documentToWrite = `${schemaComment}
 ${documentToWrite}`;
   }
-  await (0, import_promises131.writeFile)(generatorsYmlFile.absolutePath, documentToWrite);
+  await (0, import_promises130.writeFile)(generatorsYmlFile.absolutePath, documentToWrite);
   context2.logger.info(source_default.green(`Updated ${generatorsYmlFile.absolutePath}`));
 }
 function migrateDeprecatedSettings(settings, context2) {
@@ -1645946,7 +1645939,7 @@ var versionMigrations21 = {
 var __default21 = versionMigrations21;
 
 // ../cli-migrations/lib/migrations/3.0.0/enable-smart-casing/migration.js
-var import_promises132 = require("fs/promises");
+var import_promises131 = require("fs/promises");
 var migration22 = {
   name: "enable-smart-casing",
   summary: `Sets 'smart-casing: false' for existing generators to preserve backwards compatibility.
@@ -1646030,7 +1646023,7 @@ async function updateGeneratorsYml5({ context: context2, files }) {
     documentToWrite = `${schemaComment}
 ${documentToWrite}`;
   }
-  await (0, import_promises132.writeFile)(generatorsYmlFile.absolutePath, documentToWrite);
+  await (0, import_promises131.writeFile)(generatorsYmlFile.absolutePath, documentToWrite);
   context2.logger.info(source_default.green(`Updated ${generatorsYmlFile.absolutePath}`));
 }
 function setSmartCasingFalseIfNotConfigured(generator, context2) {
@@ -1646171,7 +1646164,7 @@ ${source_default.dim(migration23.summary)}`
 }
 
 // src/commands/upgrade/upgrade.ts
-var import_promises133 = require("fs/promises");
+var import_promises132 = require("fs/promises");
 
 // src/cwd.ts
 var FERN_CWD_ENV_VAR = "FERN_CWD";
@@ -1646488,7 +1646481,7 @@ async function upgrade({
     const newProjectConfig = produce(projectConfig2.rawConfig, (draft) => {
       draft.version = resolvedTargetVersion;
     });
-    await (0, import_promises133.writeFile)(
+    await (0, import_promises132.writeFile)(
       projectConfig2._absolutePath,
       ensureFinalNewline2(JSON.stringify(newProjectConfig, void 0, 2))
     );
@@ -1646913,7 +1646906,7 @@ async function validateWorkspaces({
 }
 
 // src/commands/write-definition/writeDefinitionForWorkspaces.ts
-var import_promises134 = require("fs/promises");
+var import_promises133 = require("fs/promises");
 var import_path58 = __toESM(require("path"), 1);
 async function writeDefinitionForWorkspaces({
   project,
@@ -1646994,27 +1646987,27 @@ async function writeFernDefinition({
     return a10.localeCompare(b18);
   };
   if (await doesPathExist(absolutePathToOutputDirectory)) {
-    await (0, import_promises134.rm)(absolutePathToOutputDirectory, { recursive: true });
+    await (0, import_promises133.rm)(absolutePathToOutputDirectory, { recursive: true });
   }
-  await (0, import_promises134.mkdir)(absolutePathToOutputDirectory, { recursive: true });
-  await (0, import_promises134.writeFile)(
+  await (0, import_promises133.mkdir)(absolutePathToOutputDirectory, { recursive: true });
+  await (0, import_promises133.writeFile)(
     join2(absolutePathToOutputDirectory, RelativeFilePath2.of(ROOT_API_FILENAME)),
     jsYaml.dump(definition3.rootApiFile.contents, { sortKeys })
   );
   for (const [relativePath, packageMarker] of Object.entries(definition3.packageMarkers)) {
     const absoluteFilepath = join2(absolutePathToOutputDirectory, RelativeFilePath2.of(relativePath));
-    await (0, import_promises134.mkdir)(dirname4(absoluteFilepath), { recursive: true });
-    await (0, import_promises134.writeFile)(absoluteFilepath, jsYaml.dump(packageMarker.contents, { sortKeys }));
+    await (0, import_promises133.mkdir)(dirname4(absoluteFilepath), { recursive: true });
+    await (0, import_promises133.writeFile)(absoluteFilepath, jsYaml.dump(packageMarker.contents, { sortKeys }));
   }
   for (const [relativePath, definitionFile] of Object.entries(definition3.namedDefinitionFiles)) {
     const absoluteFilepath = join2(absolutePathToOutputDirectory, RelativeFilePath2.of(relativePath));
-    await (0, import_promises134.mkdir)(dirname4(absoluteFilepath), { recursive: true });
-    await (0, import_promises134.writeFile)(absoluteFilepath, jsYaml.dump(definitionFile.contents, { sortKeys }));
+    await (0, import_promises133.mkdir)(dirname4(absoluteFilepath), { recursive: true });
+    await (0, import_promises133.writeFile)(absoluteFilepath, jsYaml.dump(definitionFile.contents, { sortKeys }));
   }
 }
 
 // src/commands/write-docs-definition/writeDocsDefinitionForProject.ts
-var import_promises135 = require("fs/promises");
+var import_promises134 = require("fs/promises");
 async function writeDocsDefinitionForProject({
   project,
   outputPath,
@@ -1647046,7 +1647039,7 @@ async function writeDocsDefinitionForProject({
       targetAudiences: docsWorkspace.config.instances[0]?.audiences ? Array.isArray(docsWorkspace.config.instances[0].audiences) ? docsWorkspace.config.instances[0].audiences : [docsWorkspace.config.instances[0].audiences] : void 0
     });
     const docsDefinition = await docsResolver.resolve();
-    await (0, import_promises135.writeFile)(AbsoluteFilePath2.of(outputPath), JSON.stringify(docsDefinition, null, 2));
+    await (0, import_promises134.writeFile)(AbsoluteFilePath2.of(outputPath), JSON.stringify(docsDefinition, null, 2));
     context2.logger.info(source_default.green(`Docs definition written to ${outputPath}`));
   });
 }
@@ -1647054,7 +1647047,7 @@ async function writeDocsDefinitionForProject({
 // src/commands/write-translation/writeTranslationForProject.ts
 var import_cli_progress2 = __toESM(require_cli_progress(), 1);
 var import_fs21 = require("fs");
-var import_promises139 = require("fs/promises");
+var import_promises138 = require("fs/promises");
 var import_is_ci2 = __toESM(require_is_ci(), 1);
 var import_path61 = __toESM(require("path"), 1);
 
@@ -1647539,7 +1647532,7 @@ function shouldProcessFile(filePath, stub) {
 }
 
 // src/commands/write-translation/docs-config-utils.ts
-var import_promises136 = require("fs/promises");
+var import_promises135 = require("fs/promises");
 
 // src/commands/write-translation/url-utils.ts
 function addLanguageSuffixToUrl(url2, language) {
@@ -1647696,7 +1647689,7 @@ async function createLanguageSpecificDocsConfig({
   stub = false
 }) {
   try {
-    const originalConfigContent = await (0, import_promises136.readFile)(originalDocsConfigPath, "utf-8");
+    const originalConfigContent = await (0, import_promises135.readFile)(originalDocsConfigPath, "utf-8");
     const transformation = {
       filePath: DOCS_CONFIGURATION_FILENAME,
       language,
@@ -1647710,7 +1647703,7 @@ async function createLanguageSpecificDocsConfig({
     const modifiedConfigContent = jsYaml.dump(modifiedConfig, {
       sortKeys: false
     });
-    await (0, import_promises136.writeFile)(modifiedConfigPath, modifiedConfigContent, "utf-8");
+    await (0, import_promises135.writeFile)(modifiedConfigPath, modifiedConfigContent, "utf-8");
     context2.logger.debug(`Created language-specific docs config: ${modifiedConfigPath}`);
   } catch (error2) {
     if (error2 instanceof Error && error2.message.includes("403")) {
@@ -1647722,11 +1647715,11 @@ async function createLanguageSpecificDocsConfig({
 
 // src/commands/write-translation/file-collection-utils.ts
 var import_fs19 = require("fs");
-var import_promises137 = require("fs/promises");
+var import_promises136 = require("fs/promises");
 var import_path59 = __toESM(require("path"), 1);
 async function collectFiles(baseDirectory, relativeBase) {
   const discoveredFiles = {};
-  const entries10 = await (0, import_promises137.readdir)(baseDirectory);
+  const entries10 = await (0, import_promises136.readdir)(baseDirectory);
   for (const entry of entries10) {
     if (entry === "translations") {
       continue;
@@ -1647749,7 +1647742,7 @@ async function collectFiles(baseDirectory, relativeBase) {
 // src/commands/write-translation/hash-utils.ts
 var import_crypto10 = require("crypto");
 var import_fs20 = require("fs");
-var import_promises138 = require("fs/promises");
+var import_promises137 = require("fs/promises");
 var import_path60 = __toESM(require("path"), 1);
 function calculateContentHash(content5) {
   return (0, import_crypto10.createHash)("sha256").update(content5, "utf-8").digest("hex");
@@ -1647760,7 +1647753,7 @@ async function loadHashMappings(translationsDirectory) {
     return {};
   }
   try {
-    const hashesContent = await (0, import_promises138.readFile)(hashesFilePath, "utf-8");
+    const hashesContent = await (0, import_promises137.readFile)(hashesFilePath, "utf-8");
     const parsed = JSON.parse(hashesContent);
     const { _comment, ...hashMappings } = parsed;
     return hashMappings;
@@ -1647781,11 +1647774,11 @@ async function saveHashMappings(translationsDirectory, hashMappings) {
     _comment: "This file is auto-generated by Fern to track source file changes for translation purposes. Do not edit manually - it will be overwritten on the next translation update.",
     ...sortedMappings
   };
-  await (0, import_promises138.writeFile)(hashesFilePath, JSON.stringify(fileContent, null, 2), "utf-8");
+  await (0, import_promises137.writeFile)(hashesFilePath, JSON.stringify(fileContent, null, 2), "utf-8");
 }
 async function hasFileChanged(filePath, relativePath, previousHashes) {
   try {
-    const content5 = await (0, import_promises138.readFile)(filePath, "utf-8");
+    const content5 = await (0, import_promises137.readFile)(filePath, "utf-8");
     const currentHash = calculateContentHash(content5);
     const previousHash = previousHashes[relativePath];
     return currentHash !== previousHash;
@@ -1647838,7 +1647831,7 @@ async function writeTranslationForProject({
     }
     if (!(0, import_fs21.existsSync)(translationsDirectory)) {
       context2.logger.debug(`Creating translations directory at: ${translationsDirectory}`);
-      await (0, import_promises139.mkdir)(translationsDirectory, { recursive: true });
+      await (0, import_promises138.mkdir)(translationsDirectory, { recursive: true });
     }
     const languageStats = {};
     const targetLanguages = languages.filter((lang) => lang !== sourceLanguage);
@@ -1647851,7 +1647844,7 @@ async function writeTranslationForProject({
         RelativeFilePath2.of("fern")
       );
       if (!(0, import_fs21.existsSync)(languageDirectory)) {
-        await (0, import_promises139.mkdir)(languageDirectory, { recursive: true });
+        await (0, import_promises138.mkdir)(languageDirectory, { recursive: true });
       }
       languageStats[language] = {
         filesProcessed: 0,
@@ -1647953,7 +1647946,7 @@ async function writeTranslationForProject({
                 `[COMPLETED] ${DOCS_CONFIGURATION_FILENAME} -> ${language}/${DOCS_CONFIGURATION_FILENAME}`
               );
             }
-            const originalConfigContent = await (0, import_promises139.readFile)(originalDocsConfigPath, "utf-8");
+            const originalConfigContent = await (0, import_promises138.readFile)(originalDocsConfigPath, "utf-8");
             await updateAndSaveHashForFile(
               translationsDirectory,
               hashMappings,
@@ -1647998,7 +1647991,7 @@ async function writeTranslationForProject({
             continue;
           }
           cliContext.logger.debug(`[PROCESSING] ${relativePath} (detected changes)`);
-          const originalContent = await (0, import_promises139.readFile)(filePath, "utf-8");
+          const originalContent = await (0, import_promises138.readFile)(filePath, "utf-8");
           await updateAndSaveHashForFile(translationsDirectory, hashMappings, relativePath, originalContent);
           const sourceStats = languageStats[sourceLanguage];
           if (sourceStats) {
@@ -1648023,7 +1648016,7 @@ async function writeTranslationForProject({
             const destPath = join2(languageDirectory, relativePath);
             const destDir = import_path61.default.dirname(destPath);
             if (!(0, import_fs21.existsSync)(destDir)) {
-              await (0, import_promises139.mkdir)(destDir, { recursive: true });
+              await (0, import_promises138.mkdir)(destDir, { recursive: true });
             }
             const transformation = {
               filePath: relativePath,
@@ -1648036,7 +1648029,7 @@ async function writeTranslationForProject({
               cliContext,
               stub
             });
-            await (0, import_promises139.writeFile)(destPath, transformedContent, "utf-8");
+            await (0, import_promises138.writeFile)(destPath, transformedContent, "utf-8");
             const languageStatsForLang = languageStats[language];
             if (languageStatsForLang) {
               languageStatsForLang.filesProcessed++;
@@ -1648067,9 +1648060,9 @@ async function writeTranslationForProject({
             const destPath = join2(languageDirectory, relativePath);
             const destDir = import_path61.default.dirname(destPath);
             if (!(0, import_fs21.existsSync)(destDir)) {
-              await (0, import_promises139.mkdir)(destDir, { recursive: true });
+              await (0, import_promises138.mkdir)(destDir, { recursive: true });
             }
-            await (0, import_promises139.copyFile)(filePath, destPath);
+            await (0, import_promises138.copyFile)(filePath, destPath);
             assetsCopied++;
             cliContext.logger.debug(`[ASSET COPIED] ${relativePath} -> ${language}/${relativePath}`);
           }