@fern-api/fern-api-dev 3.54.0 → 3.55.0-1-g14779898708

package/cli.cjs

@@ -81013,8 +81013,8 @@ var require_graceful_fs = __commonJS({
       fs34.createReadStream = createReadStream3;
       fs34.createWriteStream = createWriteStream7;
       var fs$readFile = fs34.readFile;
-      fs34.readFile = readFile88;
-      function readFile88(path86, options2, cb2) {
+      fs34.readFile = readFile89;
+      function readFile89(path86, options2, cb2) {
         if (typeof options2 === "function")
           cb2 = options2, options2 = null;
         return go$readFile(path86, options2, cb2);
@@ -81030,8 +81030,8 @@ var require_graceful_fs = __commonJS({
         }
       }
       var fs$writeFile = fs34.writeFile;
-      fs34.writeFile = writeFile78;
-      function writeFile78(path86, data2, options2, cb2) {
+      fs34.writeFile = writeFile79;
+      function writeFile79(path86, data2, options2, cb2) {
         if (typeof options2 === "function")
           cb2 = options2, options2 = null;
         return go$writeFile(path86, data2, options2, cb2);
@@ -1151729,8 +1151729,8 @@ var require_graceful_fs2 = __commonJS({
       fs34.createReadStream = createReadStream3;
       fs34.createWriteStream = createWriteStream7;
       var fs$readFile = fs34.readFile;
-      fs34.readFile = readFile88;
-      function readFile88(path86, options2, cb2) {
+      fs34.readFile = readFile89;
+      function readFile89(path86, options2, cb2) {
         if (typeof options2 === "function")
           cb2 = options2, options2 = null;
         return go$readFile(path86, options2, cb2);
@@ -1151746,8 +1151746,8 @@ var require_graceful_fs2 = __commonJS({
         }
       }
       var fs$writeFile = fs34.writeFile;
-      fs34.writeFile = writeFile78;
-      function writeFile78(path86, data2, options2, cb2) {
+      fs34.writeFile = writeFile79;
+      function writeFile79(path86, data2, options2, cb2) {
         if (typeof options2 === "function")
           cb2 = options2, options2 = null;
         return go$writeFile(path86, data2, options2, cb2);
@@ -1160591,10 +1160591,10 @@ var require_make_dir = __commonJS({
     module4.exports = (input3, opts) => Promise.resolve().then(() => {
       checkPath(input3);
       opts = Object.assign({}, defaults3, opts);
-      const mkdir37 = pify(opts.fs.mkdir);
+      const mkdir38 = pify(opts.fs.mkdir);
       const stat3 = pify(opts.fs.stat);
       const make = (pth) => {
-        return mkdir37(pth, opts.mode).then(() => pth).catch((err) => {
+        return mkdir38(pth, opts.mode).then(() => pth).catch((err) => {
           if (err.code === "ENOENT") {
             if (err.message.includes("null bytes") || path86.dirname(pth) === pth) {
               throw err;
@@ -1175296,14 +1175296,14 @@ var require_empty = __commonJS({
     var u7 = require_universalify().fromPromise;
     var fs33 = require_fs();
     var path86 = require("path");
-    var mkdir37 = require_mkdirs();
+    var mkdir38 = require_mkdirs();
     var remove3 = require_remove2();
     var emptyDir = u7(async function emptyDir2(dir) {
       let items;
       try {
         items = await fs33.readdir(dir);
       } catch {
-        return mkdir37.mkdirs(dir);
+        return mkdir38.mkdirs(dir);
       }
       return Promise.all(items.map((item) => remove3.remove(path86.join(dir, item))));
     });
@@ -1175312,7 +1175312,7 @@ var require_empty = __commonJS({
       try {
         items = fs33.readdirSync(dir);
       } catch {
-        return mkdir37.mkdirsSync(dir);
+        return mkdir38.mkdirsSync(dir);
       }
       items.forEach((item) => {
         item = path86.join(dir, item);
@@ -1175335,7 +1175335,7 @@ var require_file = __commonJS({
     var u7 = require_universalify().fromPromise;
     var path86 = require("path");
     var fs33 = require_fs();
-    var mkdir37 = require_mkdirs();
+    var mkdir38 = require_mkdirs();
     async function createFile2(file4) {
       let stats;
       try {
@@ -1175349,7 +1175349,7 @@ var require_file = __commonJS({
         dirStats = await fs33.stat(dir);
       } catch (err) {
         if (err.code === "ENOENT") {
-          await mkdir37.mkdirs(dir);
+          await mkdir38.mkdirs(dir);
           await fs33.writeFile(file4, "");
           return;
         } else {
@@ -1175375,7 +1175375,7 @@ var require_file = __commonJS({
           fs33.readdirSync(dir);
         }
       } catch (err) {
-        if (err && err.code === "ENOENT") mkdir37.mkdirsSync(dir);
+        if (err && err.code === "ENOENT") mkdir38.mkdirsSync(dir);
         else throw err;
       }
       fs33.writeFileSync(file4, "");
@@ -1175394,7 +1175394,7 @@ var require_link = __commonJS({
     var u7 = require_universalify().fromPromise;
     var path86 = require("path");
     var fs33 = require_fs();
-    var mkdir37 = require_mkdirs();
+    var mkdir38 = require_mkdirs();
     var { pathExists: pathExists2 } = require_path_exists();
     var { areIdentical } = require_stat();
     async function createLink(srcpath, dstpath) {
@@ -1175414,7 +1175414,7 @@ var require_link = __commonJS({
       const dir = path86.dirname(dstpath);
       const dirExists = await pathExists2(dir);
       if (!dirExists) {
-        await mkdir37.mkdirs(dir);
+        await mkdir38.mkdirs(dir);
       }
       await fs33.link(srcpath, dstpath);
     }
@@ -1175434,7 +1175434,7 @@ var require_link = __commonJS({
       const dir = path86.dirname(dstpath);
       const dirExists = fs33.existsSync(dir);
       if (dirExists) return fs33.linkSync(srcpath, dstpath);
-      mkdir37.mkdirsSync(dir);
+      mkdir38.mkdirsSync(dir);
       return fs33.linkSync(srcpath, dstpath);
     }
     module4.exports = {
@@ -1175688,7 +1175688,7 @@ var require_jsonfile = __commonJS({
       }
       return obj;
     }
-    var readFile88 = universalify.fromPromise(_readFile);
+    var readFile89 = universalify.fromPromise(_readFile);
     function readFileSync12(file4, options2 = {}) {
       if (typeof options2 === "string") {
         options2 = { encoding: options2 };
@@ -1175713,16 +1175713,16 @@ var require_jsonfile = __commonJS({
       const str3 = stringify5(obj, options2);
       await universalify.fromCallback(fs33.writeFile)(file4, str3, options2);
     }
-    var writeFile78 = universalify.fromPromise(_writeFile);
+    var writeFile79 = universalify.fromPromise(_writeFile);
     function writeFileSync5(file4, obj, options2 = {}) {
       const fs33 = options2.fs || _fs;
       const str3 = stringify5(obj, options2);
       return fs33.writeFileSync(file4, str3, options2);
     }
     module4.exports = {
-      readFile: readFile88,
+      readFile: readFile89,
       readFileSync: readFileSync12,
-      writeFile: writeFile78,
+      writeFile: writeFile79,
       writeFileSync: writeFileSync5
     };
   }
@@ -1175750,19 +1175750,19 @@ var require_output_file = __commonJS({
     var u7 = require_universalify().fromPromise;
     var fs33 = require_fs();
     var path86 = require("path");
-    var mkdir37 = require_mkdirs();
+    var mkdir38 = require_mkdirs();
     var pathExists2 = require_path_exists().pathExists;
     async function outputFile(file4, data2, encoding = "utf-8") {
       const dir = path86.dirname(file4);
       if (!await pathExists2(dir)) {
-        await mkdir37.mkdirs(dir);
+        await mkdir38.mkdirs(dir);
       }
       return fs33.writeFile(file4, data2, encoding);
     }
     function outputFileSync(file4, ...args) {
       const dir = path86.dirname(file4);
       if (!fs33.existsSync(dir)) {
-        mkdir37.mkdirsSync(dir);
+        mkdir38.mkdirsSync(dir);
       }
       fs33.writeFileSync(file4, ...args);
     }
@@ -1228249,7 +1228249,7 @@ var init_Browser2 = __esm({
       let _createUserContext_decorators;
       let _installExtension_decorators;
       let _uninstallExtension_decorators;
-      return class Browser4 extends _classSuper {
+      return class Browser5 extends _classSuper {
         static {
           const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
           __esDecorate19(this, null, _dispose_decorators, { kind: "method", name: "dispose", static: false, private: false, access: { has: (obj) => "dispose" in obj, get: (obj) => obj.dispose }, metadata: _metadata }, null, _instanceExtraInitializers);
@@ -1228263,7 +1228263,7 @@ var init_Browser2 = __esm({
           if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
         }
         static async from(session) {
-          const browser = new Browser4(session);
+          const browser = new Browser5(session);
           await browser.#initialize();
           return browser;
         }
@@ -1283185,6 +1283185,2094 @@ var require_cjs4 = __commonJS({
   }
 });
 
+// ../../../node_modules/.pnpm/pngjs@7.0.0/node_modules/pngjs/lib/chunkstream.js
+var require_chunkstream = __commonJS({
+  "../../../node_modules/.pnpm/pngjs@7.0.0/node_modules/pngjs/lib/chunkstream.js"(exports2, module4) {
+    "use strict";
+    var util4 = require("util");
+    var Stream5 = require("stream");
+    var ChunkStream = module4.exports = function() {
+      Stream5.call(this);
+      this._buffers = [];
+      this._buffered = 0;
+      this._reads = [];
+      this._paused = false;
+      this._encoding = "utf8";
+      this.writable = true;
+    };
+    util4.inherits(ChunkStream, Stream5);
+    ChunkStream.prototype.read = function(length, callback) {
+      this._reads.push({
+        length: Math.abs(length),
+        // if length < 0 then at most this length
+        allowLess: length < 0,
+        func: callback
+      });
+      process.nextTick(
+        function() {
+          this._process();
+          if (this._paused && this._reads && this._reads.length > 0) {
+            this._paused = false;
+            this.emit("drain");
+          }
+        }.bind(this)
+      );
+    };
+    ChunkStream.prototype.write = function(data2, encoding) {
+      if (!this.writable) {
+        this.emit("error", new Error("Stream not writable"));
+        return false;
+      }
+      let dataBuffer;
+      if (Buffer.isBuffer(data2)) {
+        dataBuffer = data2;
+      } else {
+        dataBuffer = Buffer.from(data2, encoding || this._encoding);
+      }
+      this._buffers.push(dataBuffer);
+      this._buffered += dataBuffer.length;
+      this._process();
+      if (this._reads && this._reads.length === 0) {
+        this._paused = true;
+      }
+      return this.writable && !this._paused;
+    };
+    ChunkStream.prototype.end = function(data2, encoding) {
+      if (data2) {
+        this.write(data2, encoding);
+      }
+      this.writable = false;
+      if (!this._buffers) {
+        return;
+      }
+      if (this._buffers.length === 0) {
+        this._end();
+      } else {
+        this._buffers.push(null);
+        this._process();
+      }
+    };
+    ChunkStream.prototype.destroySoon = ChunkStream.prototype.end;
+    ChunkStream.prototype._end = function() {
+      if (this._reads.length > 0) {
+        this.emit("error", new Error("Unexpected end of input"));
+      }
+      this.destroy();
+    };
+    ChunkStream.prototype.destroy = function() {
+      if (!this._buffers) {
+        return;
+      }
+      this.writable = false;
+      this._reads = null;
+      this._buffers = null;
+      this.emit("close");
+    };
+    ChunkStream.prototype._processReadAllowingLess = function(read2) {
+      this._reads.shift();
+      let smallerBuf = this._buffers[0];
+      if (smallerBuf.length > read2.length) {
+        this._buffered -= read2.length;
+        this._buffers[0] = smallerBuf.slice(read2.length);
+        read2.func.call(this, smallerBuf.slice(0, read2.length));
+      } else {
+        this._buffered -= smallerBuf.length;
+        this._buffers.shift();
+        read2.func.call(this, smallerBuf);
+      }
+    };
+    ChunkStream.prototype._processRead = function(read2) {
+      this._reads.shift();
+      let pos2 = 0;
+      let count = 0;
+      let data2 = Buffer.alloc(read2.length);
+      while (pos2 < read2.length) {
+        let buf = this._buffers[count++];
+        let len = Math.min(buf.length, read2.length - pos2);
+        buf.copy(data2, pos2, 0, len);
+        pos2 += len;
+        if (len !== buf.length) {
+          this._buffers[--count] = buf.slice(len);
+        }
+      }
+      if (count > 0) {
+        this._buffers.splice(0, count);
+      }
+      this._buffered -= read2.length;
+      read2.func.call(this, data2);
+    };
+    ChunkStream.prototype._process = function() {
+      try {
+        while (this._buffered > 0 && this._reads && this._reads.length > 0) {
+          let read2 = this._reads[0];
+          if (read2.allowLess) {
+            this._processReadAllowingLess(read2);
+          } else if (this._buffered >= read2.length) {
+            this._processRead(read2);
+          } else {
+            break;
+          }
+        }
+        if (this._buffers && !this.writable) {
+          this._end();
+        }
+      } catch (ex) {
+        this.emit("error", ex);
+      }
+    };
+  }
+});
+
+// ../../../node_modules/.pnpm/pngjs@7.0.0/node_modules/pngjs/lib/interlace.js
+var require_interlace = __commonJS({
+  "../../../node_modules/.pnpm/pngjs@7.0.0/node_modules/pngjs/lib/interlace.js"(exports2) {
+    "use strict";
+    var imagePasses = [
+      {
+        // pass 1 - 1px
+        x: [0],
+        y: [0]
+      },
+      {
+        // pass 2 - 1px
+        x: [4],
+        y: [0]
+      },
+      {
+        // pass 3 - 2px
+        x: [0, 4],
+        y: [4]
+      },
+      {
+        // pass 4 - 4px
+        x: [2, 6],
+        y: [0, 4]
+      },
+      {
+        // pass 5 - 8px
+        x: [0, 2, 4, 6],
+        y: [2, 6]
+      },
+      {
+        // pass 6 - 16px
+        x: [1, 3, 5, 7],
+        y: [0, 2, 4, 6]
+      },
+      {
+        // pass 7 - 32px
+        x: [0, 1, 2, 3, 4, 5, 6, 7],
+        y: [1, 3, 5, 7]
+      }
+    ];
+    exports2.getImagePasses = function(width, height3) {
+      let images = [];
+      let xLeftOver = width % 8;
+      let yLeftOver = height3 % 8;
+      let xRepeats = (width - xLeftOver) / 8;
+      let yRepeats = (height3 - yLeftOver) / 8;
+      for (let i11 = 0; i11 < imagePasses.length; i11++) {
+        let pass = imagePasses[i11];
+        let passWidth = xRepeats * pass.x.length;
+        let passHeight = yRepeats * pass.y.length;
+        for (let j15 = 0; j15 < pass.x.length; j15++) {
+          if (pass.x[j15] < xLeftOver) {
+            passWidth++;
+          } else {
+            break;
+          }
+        }
+        for (let j15 = 0; j15 < pass.y.length; j15++) {
+          if (pass.y[j15] < yLeftOver) {
+            passHeight++;
+          } else {
+            break;
+          }
+        }
+        if (passWidth > 0 && passHeight > 0) {
+          images.push({ width: passWidth, height: passHeight, index: i11 });
+        }
+      }
+      return images;
+    };
+    exports2.getInterlaceIterator = function(width) {
+      return function(x15, y23, pass) {
+        let outerXLeftOver = x15 % imagePasses[pass].x.length;
+        let outerX = (x15 - outerXLeftOver) / imagePasses[pass].x.length * 8 + imagePasses[pass].x[outerXLeftOver];
+        let outerYLeftOver = y23 % imagePasses[pass].y.length;
+        let outerY = (y23 - outerYLeftOver) / imagePasses[pass].y.length * 8 + imagePasses[pass].y[outerYLeftOver];
+        return outerX * 4 + outerY * width * 4;
+      };
+    };
+  }
+});
+
+// ../../../node_modules/.pnpm/pngjs@7.0.0/node_modules/pngjs/lib/paeth-predictor.js
+var require_paeth_predictor = __commonJS({
+  "../../../node_modules/.pnpm/pngjs@7.0.0/node_modules/pngjs/lib/paeth-predictor.js"(exports2, module4) {
+    "use strict";
+    module4.exports = function paethPredictor(left3, above, upLeft) {
+      let paeth = left3 + above - upLeft;
+      let pLeft = Math.abs(paeth - left3);
+      let pAbove = Math.abs(paeth - above);
+      let pUpLeft = Math.abs(paeth - upLeft);
+      if (pLeft <= pAbove && pLeft <= pUpLeft) {
+        return left3;
+      }
+      if (pAbove <= pUpLeft) {
+        return above;
+      }
+      return upLeft;
+    };
+  }
+});
+
+// ../../../node_modules/.pnpm/pngjs@7.0.0/node_modules/pngjs/lib/filter-parse.js
+var require_filter_parse = __commonJS({
+  "../../../node_modules/.pnpm/pngjs@7.0.0/node_modules/pngjs/lib/filter-parse.js"(exports2, module4) {
+    "use strict";
+    var interlaceUtils = require_interlace();
+    var paethPredictor = require_paeth_predictor();
+    function getByteWidth(width, bpp, depth) {
+      let byteWidth = width * bpp;
+      if (depth !== 8) {
+        byteWidth = Math.ceil(byteWidth / (8 / depth));
+      }
+      return byteWidth;
+    }
+    var Filter = module4.exports = function(bitmapInfo, dependencies) {
+      let width = bitmapInfo.width;
+      let height3 = bitmapInfo.height;
+      let interlace = bitmapInfo.interlace;
+      let bpp = bitmapInfo.bpp;
+      let depth = bitmapInfo.depth;
+      this.read = dependencies.read;
+      this.write = dependencies.write;
+      this.complete = dependencies.complete;
+      this._imageIndex = 0;
+      this._images = [];
+      if (interlace) {
+        let passes = interlaceUtils.getImagePasses(width, height3);
+        for (let i11 = 0; i11 < passes.length; i11++) {
+          this._images.push({
+            byteWidth: getByteWidth(passes[i11].width, bpp, depth),
+            height: passes[i11].height,
+            lineIndex: 0
+          });
+        }
+      } else {
+        this._images.push({
+          byteWidth: getByteWidth(width, bpp, depth),
+          height: height3,
+          lineIndex: 0
+        });
+      }
+      if (depth === 8) {
+        this._xComparison = bpp;
+      } else if (depth === 16) {
+        this._xComparison = bpp * 2;
+      } else {
+        this._xComparison = 1;
+      }
+    };
+    Filter.prototype.start = function() {
+      this.read(
+        this._images[this._imageIndex].byteWidth + 1,
+        this._reverseFilterLine.bind(this)
+      );
+    };
+    Filter.prototype._unFilterType1 = function(rawData, unfilteredLine, byteWidth) {
+      let xComparison = this._xComparison;
+      let xBiggerThan = xComparison - 1;
+      for (let x15 = 0; x15 < byteWidth; x15++) {
+        let rawByte = rawData[1 + x15];
+        let f1Left = x15 > xBiggerThan ? unfilteredLine[x15 - xComparison] : 0;
+        unfilteredLine[x15] = rawByte + f1Left;
+      }
+    };
+    Filter.prototype._unFilterType2 = function(rawData, unfilteredLine, byteWidth) {
+      let lastLine3 = this._lastLine;
+      for (let x15 = 0; x15 < byteWidth; x15++) {
+        let rawByte = rawData[1 + x15];
+        let f2Up = lastLine3 ? lastLine3[x15] : 0;
+        unfilteredLine[x15] = rawByte + f2Up;
+      }
+    };
+    Filter.prototype._unFilterType3 = function(rawData, unfilteredLine, byteWidth) {
+      let xComparison = this._xComparison;
+      let xBiggerThan = xComparison - 1;
+      let lastLine3 = this._lastLine;
+      for (let x15 = 0; x15 < byteWidth; x15++) {
+        let rawByte = rawData[1 + x15];
+        let f3Up = lastLine3 ? lastLine3[x15] : 0;
+        let f3Left = x15 > xBiggerThan ? unfilteredLine[x15 - xComparison] : 0;
+        let f3Add = Math.floor((f3Left + f3Up) / 2);
+        unfilteredLine[x15] = rawByte + f3Add;
+      }
+    };
+    Filter.prototype._unFilterType4 = function(rawData, unfilteredLine, byteWidth) {
+      let xComparison = this._xComparison;
+      let xBiggerThan = xComparison - 1;
+      let lastLine3 = this._lastLine;
+      for (let x15 = 0; x15 < byteWidth; x15++) {
+        let rawByte = rawData[1 + x15];
+        let f4Up = lastLine3 ? lastLine3[x15] : 0;
+        let f4Left = x15 > xBiggerThan ? unfilteredLine[x15 - xComparison] : 0;
+        let f4UpLeft = x15 > xBiggerThan && lastLine3 ? lastLine3[x15 - xComparison] : 0;
+        let f4Add = paethPredictor(f4Left, f4Up, f4UpLeft);
+        unfilteredLine[x15] = rawByte + f4Add;
+      }
+    };
+    Filter.prototype._reverseFilterLine = function(rawData) {
+      let filter7 = rawData[0];
+      let unfilteredLine;
+      let currentImage = this._images[this._imageIndex];
+      let byteWidth = currentImage.byteWidth;
+      if (filter7 === 0) {
+        unfilteredLine = rawData.slice(1, byteWidth + 1);
+      } else {
+        unfilteredLine = Buffer.alloc(byteWidth);
+        switch (filter7) {
+          case 1:
+            this._unFilterType1(rawData, unfilteredLine, byteWidth);
+            break;
+          case 2:
+            this._unFilterType2(rawData, unfilteredLine, byteWidth);
+            break;
+          case 3:
+            this._unFilterType3(rawData, unfilteredLine, byteWidth);
+            break;
+          case 4:
+            this._unFilterType4(rawData, unfilteredLine, byteWidth);
+            break;
+          default:
+            throw new Error("Unrecognised filter type - " + filter7);
+        }
+      }
+      this.write(unfilteredLine);
+      currentImage.lineIndex++;
+      if (currentImage.lineIndex >= currentImage.height) {
+        this._lastLine = null;
+        this._imageIndex++;
+        currentImage = this._images[this._imageIndex];
+      } else {
+        this._lastLine = unfilteredLine;
+      }
+      if (currentImage) {
+        this.read(currentImage.byteWidth + 1, this._reverseFilterLine.bind(this));
+      } else {
+        this._lastLine = null;
+        this.complete();
+      }
+    };
+  }
+});
+
+// ../../../node_modules/.pnpm/pngjs@7.0.0/node_modules/pngjs/lib/filter-parse-async.js
+var require_filter_parse_async = __commonJS({
+  "../../../node_modules/.pnpm/pngjs@7.0.0/node_modules/pngjs/lib/filter-parse-async.js"(exports2, module4) {
+    "use strict";
+    var util4 = require("util");
+    var ChunkStream = require_chunkstream();
+    var Filter = require_filter_parse();
+    var FilterAsync = module4.exports = function(bitmapInfo) {
+      ChunkStream.call(this);
+      let buffers = [];
+      let that = this;
+      this._filter = new Filter(bitmapInfo, {
+        read: this.read.bind(this),
+        write: function(buffer) {
+          buffers.push(buffer);
+        },
+        complete: function() {
+          that.emit("complete", Buffer.concat(buffers));
+        }
+      });
+      this._filter.start();
+    };
+    util4.inherits(FilterAsync, ChunkStream);
+  }
+});
+
+// ../../../node_modules/.pnpm/pngjs@7.0.0/node_modules/pngjs/lib/constants.js
+var require_constants109 = __commonJS({
+  "../../../node_modules/.pnpm/pngjs@7.0.0/node_modules/pngjs/lib/constants.js"(exports2, module4) {
+    "use strict";
+    module4.exports = {
+      PNG_SIGNATURE: [137, 80, 78, 71, 13, 10, 26, 10],
+      TYPE_IHDR: 1229472850,
+      TYPE_IEND: 1229278788,
+      TYPE_IDAT: 1229209940,
+      TYPE_PLTE: 1347179589,
+      TYPE_tRNS: 1951551059,
+      // eslint-disable-line camelcase
+      TYPE_gAMA: 1732332865,
+      // eslint-disable-line camelcase
+      // color-type bits
+      COLORTYPE_GRAYSCALE: 0,
+      COLORTYPE_PALETTE: 1,
+      COLORTYPE_COLOR: 2,
+      COLORTYPE_ALPHA: 4,
+      // e.g. grayscale and alpha
+      // color-type combinations
+      COLORTYPE_PALETTE_COLOR: 3,
+      COLORTYPE_COLOR_ALPHA: 6,
+      COLORTYPE_TO_BPP_MAP: {
+        0: 1,
+        2: 3,
+        3: 1,
+        4: 2,
+        6: 4
+      },
+      GAMMA_DIVISION: 1e5
+    };
+  }
+});
+
+// ../../../node_modules/.pnpm/pngjs@7.0.0/node_modules/pngjs/lib/crc.js
+var require_crc = __commonJS({
+  "../../../node_modules/.pnpm/pngjs@7.0.0/node_modules/pngjs/lib/crc.js"(exports2, module4) {
+    "use strict";
+    var crcTable = [];
+    (function() {
+      for (let i11 = 0; i11 < 256; i11++) {
+        let currentCrc = i11;
+        for (let j15 = 0; j15 < 8; j15++) {
+          if (currentCrc & 1) {
+            currentCrc = 3988292384 ^ currentCrc >>> 1;
+          } else {
+            currentCrc = currentCrc >>> 1;
+          }
+        }
+        crcTable[i11] = currentCrc;
+      }
+    })();
+    var CrcCalculator = module4.exports = function() {
+      this._crc = -1;
+    };
+    CrcCalculator.prototype.write = function(data2) {
+      for (let i11 = 0; i11 < data2.length; i11++) {
+        this._crc = crcTable[(this._crc ^ data2[i11]) & 255] ^ this._crc >>> 8;
+      }
+      return true;
+    };
+    CrcCalculator.prototype.crc32 = function() {
+      return this._crc ^ -1;
+    };
+    CrcCalculator.crc32 = function(buf) {
+      let crc = -1;
+      for (let i11 = 0; i11 < buf.length; i11++) {
+        crc = crcTable[(crc ^ buf[i11]) & 255] ^ crc >>> 8;
+      }
+      return crc ^ -1;
+    };
+  }
+});
+
+// ../../../node_modules/.pnpm/pngjs@7.0.0/node_modules/pngjs/lib/parser.js
+var require_parser4 = __commonJS({
+  "../../../node_modules/.pnpm/pngjs@7.0.0/node_modules/pngjs/lib/parser.js"(exports2, module4) {
+    "use strict";
+    var constants2 = require_constants109();
+    var CrcCalculator = require_crc();
+    var Parser8 = module4.exports = function(options2, dependencies) {
+      this._options = options2;
+      options2.checkCRC = options2.checkCRC !== false;
+      this._hasIHDR = false;
+      this._hasIEND = false;
+      this._emittedHeadersFinished = false;
+      this._palette = [];
+      this._colorType = 0;
+      this._chunks = {};
+      this._chunks[constants2.TYPE_IHDR] = this._handleIHDR.bind(this);
+      this._chunks[constants2.TYPE_IEND] = this._handleIEND.bind(this);
+      this._chunks[constants2.TYPE_IDAT] = this._handleIDAT.bind(this);
+      this._chunks[constants2.TYPE_PLTE] = this._handlePLTE.bind(this);
+      this._chunks[constants2.TYPE_tRNS] = this._handleTRNS.bind(this);
+      this._chunks[constants2.TYPE_gAMA] = this._handleGAMA.bind(this);
+      this.read = dependencies.read;
+      this.error = dependencies.error;
+      this.metadata = dependencies.metadata;
+      this.gamma = dependencies.gamma;
+      this.transColor = dependencies.transColor;
+      this.palette = dependencies.palette;
+      this.parsed = dependencies.parsed;
+      this.inflateData = dependencies.inflateData;
+      this.finished = dependencies.finished;
+      this.simpleTransparency = dependencies.simpleTransparency;
+      this.headersFinished = dependencies.headersFinished || function() {
+      };
+    };
+    Parser8.prototype.start = function() {
+      this.read(constants2.PNG_SIGNATURE.length, this._parseSignature.bind(this));
+    };
+    Parser8.prototype._parseSignature = function(data2) {
+      let signature = constants2.PNG_SIGNATURE;
+      for (let i11 = 0; i11 < signature.length; i11++) {
+        if (data2[i11] !== signature[i11]) {
+          this.error(new Error("Invalid file signature"));
+          return;
+        }
+      }
+      this.read(8, this._parseChunkBegin.bind(this));
+    };
+    Parser8.prototype._parseChunkBegin = function(data2) {
+      let length = data2.readUInt32BE(0);
+      let type8 = data2.readUInt32BE(4);
+      let name3 = "";
+      for (let i11 = 4; i11 < 8; i11++) {
+        name3 += String.fromCharCode(data2[i11]);
+      }
+      let ancillary = Boolean(data2[4] & 32);
+      if (!this._hasIHDR && type8 !== constants2.TYPE_IHDR) {
+        this.error(new Error("Expected IHDR on beggining"));
+        return;
+      }
+      this._crc = new CrcCalculator();
+      this._crc.write(Buffer.from(name3));
+      if (this._chunks[type8]) {
+        return this._chunks[type8](length);
+      }
+      if (!ancillary) {
+        this.error(new Error("Unsupported critical chunk type " + name3));
+        return;
+      }
+      this.read(length + 4, this._skipChunk.bind(this));
+    };
+    Parser8.prototype._skipChunk = function() {
+      this.read(8, this._parseChunkBegin.bind(this));
+    };
+    Parser8.prototype._handleChunkEnd = function() {
+      this.read(4, this._parseChunkEnd.bind(this));
+    };
+    Parser8.prototype._parseChunkEnd = function(data2) {
+      let fileCrc = data2.readInt32BE(0);
+      let calcCrc = this._crc.crc32();
+      if (this._options.checkCRC && calcCrc !== fileCrc) {
+        this.error(new Error("Crc error - " + fileCrc + " - " + calcCrc));
+        return;
+      }
+      if (!this._hasIEND) {
+        this.read(8, this._parseChunkBegin.bind(this));
+      }
+    };
+    Parser8.prototype._handleIHDR = function(length) {
+      this.read(length, this._parseIHDR.bind(this));
+    };
+    Parser8.prototype._parseIHDR = function(data2) {
+      this._crc.write(data2);
+      let width = data2.readUInt32BE(0);
+      let height3 = data2.readUInt32BE(4);
+      let depth = data2[8];
+      let colorType = data2[9];
+      let compr = data2[10];
+      let filter7 = data2[11];
+      let interlace = data2[12];
+      if (depth !== 8 && depth !== 4 && depth !== 2 && depth !== 1 && depth !== 16) {
+        this.error(new Error("Unsupported bit depth " + depth));
+        return;
+      }
+      if (!(colorType in constants2.COLORTYPE_TO_BPP_MAP)) {
+        this.error(new Error("Unsupported color type"));
+        return;
+      }
+      if (compr !== 0) {
+        this.error(new Error("Unsupported compression method"));
+        return;
+      }
+      if (filter7 !== 0) {
+        this.error(new Error("Unsupported filter method"));
+        return;
+      }
+      if (interlace !== 0 && interlace !== 1) {
+        this.error(new Error("Unsupported interlace method"));
+        return;
+      }
+      this._colorType = colorType;
+      let bpp = constants2.COLORTYPE_TO_BPP_MAP[this._colorType];
+      this._hasIHDR = true;
+      this.metadata({
+        width,
+        height: height3,
+        depth,
+        interlace: Boolean(interlace),
+        palette: Boolean(colorType & constants2.COLORTYPE_PALETTE),
+        color: Boolean(colorType & constants2.COLORTYPE_COLOR),
+        alpha: Boolean(colorType & constants2.COLORTYPE_ALPHA),
+        bpp,
+        colorType
+      });
+      this._handleChunkEnd();
+    };
+    Parser8.prototype._handlePLTE = function(length) {
+      this.read(length, this._parsePLTE.bind(this));
+    };
+    Parser8.prototype._parsePLTE = function(data2) {
+      this._crc.write(data2);
+      let entries10 = Math.floor(data2.length / 3);
+      for (let i11 = 0; i11 < entries10; i11++) {
+        this._palette.push([data2[i11 * 3], data2[i11 * 3 + 1], data2[i11 * 3 + 2], 255]);
+      }
+      this.palette(this._palette);
+      this._handleChunkEnd();
+    };
+    Parser8.prototype._handleTRNS = function(length) {
+      this.simpleTransparency();
+      this.read(length, this._parseTRNS.bind(this));
+    };
+    Parser8.prototype._parseTRNS = function(data2) {
+      this._crc.write(data2);
+      if (this._colorType === constants2.COLORTYPE_PALETTE_COLOR) {
+        if (this._palette.length === 0) {
+          this.error(new Error("Transparency chunk must be after palette"));
+          return;
+        }
+        if (data2.length > this._palette.length) {
+          this.error(new Error("More transparent colors than palette size"));
+          return;
+        }
+        for (let i11 = 0; i11 < data2.length; i11++) {
+          this._palette[i11][3] = data2[i11];
+        }
+        this.palette(this._palette);
+      }
+      if (this._colorType === constants2.COLORTYPE_GRAYSCALE) {
+        this.transColor([data2.readUInt16BE(0)]);
+      }
+      if (this._colorType === constants2.COLORTYPE_COLOR) {
+        this.transColor([
+          data2.readUInt16BE(0),
+          data2.readUInt16BE(2),
+          data2.readUInt16BE(4)
+        ]);
+      }
+      this._handleChunkEnd();
+    };
+    Parser8.prototype._handleGAMA = function(length) {
+      this.read(length, this._parseGAMA.bind(this));
+    };
+    Parser8.prototype._parseGAMA = function(data2) {
+      this._crc.write(data2);
+      this.gamma(data2.readUInt32BE(0) / constants2.GAMMA_DIVISION);
+      this._handleChunkEnd();
+    };
+    Parser8.prototype._handleIDAT = function(length) {
+      if (!this._emittedHeadersFinished) {
+        this._emittedHeadersFinished = true;
+        this.headersFinished();
+      }
+      this.read(-length, this._parseIDAT.bind(this, length));
+    };
+    Parser8.prototype._parseIDAT = function(length, data2) {
+      this._crc.write(data2);
+      if (this._colorType === constants2.COLORTYPE_PALETTE_COLOR && this._palette.length === 0) {
+        throw new Error("Expected palette not found");
+      }
+      this.inflateData(data2);
+      let leftOverLength = length - data2.length;
+      if (leftOverLength > 0) {
+        this._handleIDAT(leftOverLength);
+      } else {
+        this._handleChunkEnd();
+      }
+    };
+    Parser8.prototype._handleIEND = function(length) {
+      this.read(length, this._parseIEND.bind(this));
+    };
+    Parser8.prototype._parseIEND = function(data2) {
+      this._crc.write(data2);
+      this._hasIEND = true;
+      this._handleChunkEnd();
+      if (this.finished) {
+        this.finished();
+      }
+    };
+  }
+});
+
+// ../../../node_modules/.pnpm/pngjs@7.0.0/node_modules/pngjs/lib/bitmapper.js
+var require_bitmapper = __commonJS({
+  "../../../node_modules/.pnpm/pngjs@7.0.0/node_modules/pngjs/lib/bitmapper.js"(exports2) {
+    "use strict";
+    var interlaceUtils = require_interlace();
+    var pixelBppMapper = [
+      // 0 - dummy entry
+      function() {
+      },
+      // 1 - L
+      // 0: 0, 1: 0, 2: 0, 3: 0xff
+      function(pxData, data2, pxPos, rawPos) {
+        if (rawPos === data2.length) {
+          throw new Error("Ran out of data");
+        }
+        let pixel = data2[rawPos];
+        pxData[pxPos] = pixel;
+        pxData[pxPos + 1] = pixel;
+        pxData[pxPos + 2] = pixel;
+        pxData[pxPos + 3] = 255;
+      },
+      // 2 - LA
+      // 0: 0, 1: 0, 2: 0, 3: 1
+      function(pxData, data2, pxPos, rawPos) {
+        if (rawPos + 1 >= data2.length) {
+          throw new Error("Ran out of data");
+        }
+        let pixel = data2[rawPos];
+        pxData[pxPos] = pixel;
+        pxData[pxPos + 1] = pixel;
+        pxData[pxPos + 2] = pixel;
+        pxData[pxPos + 3] = data2[rawPos + 1];
+      },
+      // 3 - RGB
+      // 0: 0, 1: 1, 2: 2, 3: 0xff
+      function(pxData, data2, pxPos, rawPos) {
+        if (rawPos + 2 >= data2.length) {
+          throw new Error("Ran out of data");
+        }
+        pxData[pxPos] = data2[rawPos];
+        pxData[pxPos + 1] = data2[rawPos + 1];
+        pxData[pxPos + 2] = data2[rawPos + 2];
+        pxData[pxPos + 3] = 255;
+      },
+      // 4 - RGBA
+      // 0: 0, 1: 1, 2: 2, 3: 3
+      function(pxData, data2, pxPos, rawPos) {
+        if (rawPos + 3 >= data2.length) {
+          throw new Error("Ran out of data");
+        }
+        pxData[pxPos] = data2[rawPos];
+        pxData[pxPos + 1] = data2[rawPos + 1];
+        pxData[pxPos + 2] = data2[rawPos + 2];
+        pxData[pxPos + 3] = data2[rawPos + 3];
+      }
+    ];
+    var pixelBppCustomMapper = [
+      // 0 - dummy entry
+      function() {
+      },
+      // 1 - L
+      // 0: 0, 1: 0, 2: 0, 3: 0xff
+      function(pxData, pixelData, pxPos, maxBit) {
+        let pixel = pixelData[0];
+        pxData[pxPos] = pixel;
+        pxData[pxPos + 1] = pixel;
+        pxData[pxPos + 2] = pixel;
+        pxData[pxPos + 3] = maxBit;
+      },
+      // 2 - LA
+      // 0: 0, 1: 0, 2: 0, 3: 1
+      function(pxData, pixelData, pxPos) {
+        let pixel = pixelData[0];
+        pxData[pxPos] = pixel;
+        pxData[pxPos + 1] = pixel;
+        pxData[pxPos + 2] = pixel;
+        pxData[pxPos + 3] = pixelData[1];
+      },
+      // 3 - RGB
+      // 0: 0, 1: 1, 2: 2, 3: 0xff
+      function(pxData, pixelData, pxPos, maxBit) {
+        pxData[pxPos] = pixelData[0];
+        pxData[pxPos + 1] = pixelData[1];
+        pxData[pxPos + 2] = pixelData[2];
+        pxData[pxPos + 3] = maxBit;
+      },
+      // 4 - RGBA
+      // 0: 0, 1: 1, 2: 2, 3: 3
+      function(pxData, pixelData, pxPos) {
+        pxData[pxPos] = pixelData[0];
+        pxData[pxPos + 1] = pixelData[1];
+        pxData[pxPos + 2] = pixelData[2];
+        pxData[pxPos + 3] = pixelData[3];
+      }
+    ];
+    function bitRetriever(data2, depth) {
+      let leftOver = [];
+      let i11 = 0;
+      function split2() {
+        if (i11 === data2.length) {
+          throw new Error("Ran out of data");
+        }
+        let byte = data2[i11];
+        i11++;
+        let byte8, byte7, byte6, byte5, byte4, byte3, byte2, byte1;
+        switch (depth) {
+          default:
+            throw new Error("unrecognised depth");
+          case 16:
+            byte2 = data2[i11];
+            i11++;
+            leftOver.push((byte << 8) + byte2);
+            break;
+          case 4:
+            byte2 = byte & 15;
+            byte1 = byte >> 4;
+            leftOver.push(byte1, byte2);
+            break;
+          case 2:
+            byte4 = byte & 3;
+            byte3 = byte >> 2 & 3;
+            byte2 = byte >> 4 & 3;
+            byte1 = byte >> 6 & 3;
+            leftOver.push(byte1, byte2, byte3, byte4);
+            break;
+          case 1:
+            byte8 = byte & 1;
+            byte7 = byte >> 1 & 1;
+            byte6 = byte >> 2 & 1;
+            byte5 = byte >> 3 & 1;
+            byte4 = byte >> 4 & 1;
+            byte3 = byte >> 5 & 1;
+            byte2 = byte >> 6 & 1;
+            byte1 = byte >> 7 & 1;
+            leftOver.push(byte1, byte2, byte3, byte4, byte5, byte6, byte7, byte8);
+            break;
+        }
+      }
+      return {
+        get: function(count) {
+          while (leftOver.length < count) {
+            split2();
+          }
+          let returner = leftOver.slice(0, count);
+          leftOver = leftOver.slice(count);
+          return returner;
+        },
+        resetAfterLine: function() {
+          leftOver.length = 0;
+        },
+        end: function() {
+          if (i11 !== data2.length) {
+            throw new Error("extra data found");
+          }
+        }
+      };
+    }
+    function mapImage8Bit(image3, pxData, getPxPos, bpp, data2, rawPos) {
+      let imageWidth = image3.width;
+      let imageHeight = image3.height;
+      let imagePass = image3.index;
+      for (let y23 = 0; y23 < imageHeight; y23++) {
+        for (let x15 = 0; x15 < imageWidth; x15++) {
+          let pxPos = getPxPos(x15, y23, imagePass);
+          pixelBppMapper[bpp](pxData, data2, pxPos, rawPos);
+          rawPos += bpp;
+        }
+      }
+      return rawPos;
+    }
+    function mapImageCustomBit(image3, pxData, getPxPos, bpp, bits, maxBit) {
+      let imageWidth = image3.width;
+      let imageHeight = image3.height;
+      let imagePass = image3.index;
+      for (let y23 = 0; y23 < imageHeight; y23++) {
+        for (let x15 = 0; x15 < imageWidth; x15++) {
+          let pixelData = bits.get(bpp);
+          let pxPos = getPxPos(x15, y23, imagePass);
+          pixelBppCustomMapper[bpp](pxData, pixelData, pxPos, maxBit);
+        }
+        bits.resetAfterLine();
+      }
+    }
+    exports2.dataToBitMap = function(data2, bitmapInfo) {
+      let width = bitmapInfo.width;
+      let height3 = bitmapInfo.height;
+      let depth = bitmapInfo.depth;
+      let bpp = bitmapInfo.bpp;
+      let interlace = bitmapInfo.interlace;
+      let bits;
+      if (depth !== 8) {
+        bits = bitRetriever(data2, depth);
+      }
+      let pxData;
+      if (depth <= 8) {
+        pxData = Buffer.alloc(width * height3 * 4);
+      } else {
+        pxData = new Uint16Array(width * height3 * 4);
+      }
+      let maxBit = Math.pow(2, depth) - 1;
+      let rawPos = 0;
+      let images;
+      let getPxPos;
+      if (interlace) {
+        images = interlaceUtils.getImagePasses(width, height3);
+        getPxPos = interlaceUtils.getInterlaceIterator(width, height3);
+      } else {
+        let nonInterlacedPxPos = 0;
+        getPxPos = function() {
+          let returner = nonInterlacedPxPos;
+          nonInterlacedPxPos += 4;
+          return returner;
+        };
+        images = [{ width, height: height3 }];
+      }
+      for (let imageIndex = 0; imageIndex < images.length; imageIndex++) {
+        if (depth === 8) {
+          rawPos = mapImage8Bit(
+            images[imageIndex],
+            pxData,
+            getPxPos,
+            bpp,
+            data2,
+            rawPos
+          );
+        } else {
+          mapImageCustomBit(
+            images[imageIndex],
+            pxData,
+            getPxPos,
+            bpp,
+            bits,
+            maxBit
+          );
+        }
+      }
+      if (depth === 8) {
+        if (rawPos !== data2.length) {
+          throw new Error("extra data found");
+        }
+      } else {
+        bits.end();
+      }
+      return pxData;
+    };
+  }
+});
+
+// ../../../node_modules/.pnpm/pngjs@7.0.0/node_modules/pngjs/lib/format-normaliser.js
+var require_format_normaliser = __commonJS({
+  "../../../node_modules/.pnpm/pngjs@7.0.0/node_modules/pngjs/lib/format-normaliser.js"(exports2, module4) {
+    "use strict";
+    function dePalette(indata, outdata, width, height3, palette) {
+      let pxPos = 0;
+      for (let y23 = 0; y23 < height3; y23++) {
+        for (let x15 = 0; x15 < width; x15++) {
+          let color3 = palette[indata[pxPos]];
+          if (!color3) {
+            throw new Error("index " + indata[pxPos] + " not in palette");
+          }
+          for (let i11 = 0; i11 < 4; i11++) {
+            outdata[pxPos + i11] = color3[i11];
+          }
+          pxPos += 4;
+        }
+      }
+    }
+    function replaceTransparentColor(indata, outdata, width, height3, transColor) {
+      let pxPos = 0;
+      for (let y23 = 0; y23 < height3; y23++) {
+        for (let x15 = 0; x15 < width; x15++) {
+          let makeTrans = false;
+          if (transColor.length === 1) {
+            if (transColor[0] === indata[pxPos]) {
+              makeTrans = true;
+            }
+          } else if (transColor[0] === indata[pxPos] && transColor[1] === indata[pxPos + 1] && transColor[2] === indata[pxPos + 2]) {
+            makeTrans = true;
+          }
+          if (makeTrans) {
+            for (let i11 = 0; i11 < 4; i11++) {
+              outdata[pxPos + i11] = 0;
+            }
+          }
+          pxPos += 4;
+        }
+      }
+    }
+    function scaleDepth(indata, outdata, width, height3, depth) {
+      let maxOutSample = 255;
+      let maxInSample = Math.pow(2, depth) - 1;
+      let pxPos = 0;
+      for (let y23 = 0; y23 < height3; y23++) {
+        for (let x15 = 0; x15 < width; x15++) {
+          for (let i11 = 0; i11 < 4; i11++) {
+            outdata[pxPos + i11] = Math.floor(
+              indata[pxPos + i11] * maxOutSample / maxInSample + 0.5
+            );
+          }
+          pxPos += 4;
+        }
+      }
+    }
+    module4.exports = function(indata, imageData, skipRescale = false) {
+      let depth = imageData.depth;
+      let width = imageData.width;
+      let height3 = imageData.height;
+      let colorType = imageData.colorType;
+      let transColor = imageData.transColor;
+      let palette = imageData.palette;
+      let outdata = indata;
+      if (colorType === 3) {
+        dePalette(indata, outdata, width, height3, palette);
+      } else {
+        if (transColor) {
+          replaceTransparentColor(indata, outdata, width, height3, transColor);
+        }
+        if (depth !== 8 && !skipRescale) {
+          if (depth === 16) {
+            outdata = Buffer.alloc(width * height3 * 4);
+          }
+          scaleDepth(indata, outdata, width, height3, depth);
+        }
+      }
+      return outdata;
+    };
+  }
+});
+
+// ../../../node_modules/.pnpm/pngjs@7.0.0/node_modules/pngjs/lib/parser-async.js
+var require_parser_async = __commonJS({
+  "../../../node_modules/.pnpm/pngjs@7.0.0/node_modules/pngjs/lib/parser-async.js"(exports2, module4) {
+    "use strict";
+    var util4 = require("util");
+    var zlib4 = require("zlib");
+    var ChunkStream = require_chunkstream();
+    var FilterAsync = require_filter_parse_async();
+    var Parser8 = require_parser4();
+    var bitmapper = require_bitmapper();
+    var formatNormaliser = require_format_normaliser();
+    var ParserAsync = module4.exports = function(options2) {
+      ChunkStream.call(this);
+      this._parser = new Parser8(options2, {
+        read: this.read.bind(this),
+        error: this._handleError.bind(this),
+        metadata: this._handleMetaData.bind(this),
+        gamma: this.emit.bind(this, "gamma"),
+        palette: this._handlePalette.bind(this),
+        transColor: this._handleTransColor.bind(this),
+        finished: this._finished.bind(this),
+        inflateData: this._inflateData.bind(this),
+        simpleTransparency: this._simpleTransparency.bind(this),
+        headersFinished: this._headersFinished.bind(this)
+      });
+      this._options = options2;
+      this.writable = true;
+      this._parser.start();
+    };
+    util4.inherits(ParserAsync, ChunkStream);
+    ParserAsync.prototype._handleError = function(err) {
+      this.emit("error", err);
+      this.writable = false;
+      this.destroy();
+      if (this._inflate && this._inflate.destroy) {
+        this._inflate.destroy();
+      }
+      if (this._filter) {
+        this._filter.destroy();
+        this._filter.on("error", function() {
+        });
+      }
+      this.errord = true;
+    };
+    ParserAsync.prototype._inflateData = function(data2) {
+      if (!this._inflate) {
+        if (this._bitmapInfo.interlace) {
+          this._inflate = zlib4.createInflate();
+          this._inflate.on("error", this.emit.bind(this, "error"));
+          this._filter.on("complete", this._complete.bind(this));
+          this._inflate.pipe(this._filter);
+        } else {
+          let rowSize = (this._bitmapInfo.width * this._bitmapInfo.bpp * this._bitmapInfo.depth + 7 >> 3) + 1;
+          let imageSize2 = rowSize * this._bitmapInfo.height;
+          let chunkSize = Math.max(imageSize2, zlib4.Z_MIN_CHUNK);
+          this._inflate = zlib4.createInflate({ chunkSize });
+          let leftToInflate = imageSize2;
+          let emitError = this.emit.bind(this, "error");
+          this._inflate.on("error", function(err) {
+            if (!leftToInflate) {
+              return;
+            }
+            emitError(err);
+          });
+          this._filter.on("complete", this._complete.bind(this));
+          let filterWrite = this._filter.write.bind(this._filter);
+          this._inflate.on("data", function(chunk2) {
+            if (!leftToInflate) {
+              return;
+            }
+            if (chunk2.length > leftToInflate) {
+              chunk2 = chunk2.slice(0, leftToInflate);
+            }
+            leftToInflate -= chunk2.length;
+            filterWrite(chunk2);
+          });
+          this._inflate.on("end", this._filter.end.bind(this._filter));
+        }
+      }
+      this._inflate.write(data2);
+    };
+    ParserAsync.prototype._handleMetaData = function(metaData) {
+      this._metaData = metaData;
+      this._bitmapInfo = Object.create(metaData);
+      this._filter = new FilterAsync(this._bitmapInfo);
+    };
+    ParserAsync.prototype._handleTransColor = function(transColor) {
+      this._bitmapInfo.transColor = transColor;
+    };
+    ParserAsync.prototype._handlePalette = function(palette) {
+      this._bitmapInfo.palette = palette;
+    };
+    ParserAsync.prototype._simpleTransparency = function() {
+      this._metaData.alpha = true;
+    };
+    ParserAsync.prototype._headersFinished = function() {
+      this.emit("metadata", this._metaData);
+    };
+    ParserAsync.prototype._finished = function() {
+      if (this.errord) {
+        return;
+      }
+      if (!this._inflate) {
+        this.emit("error", "No Inflate block");
+      } else {
+        this._inflate.end();
+      }
+    };
+    ParserAsync.prototype._complete = function(filteredData) {
+      if (this.errord) {
+        return;
+      }
+      let normalisedBitmapData;
+      try {
+        let bitmapData = bitmapper.dataToBitMap(filteredData, this._bitmapInfo);
+        normalisedBitmapData = formatNormaliser(
+          bitmapData,
+          this._bitmapInfo,
+          this._options.skipRescale
+        );
+        bitmapData = null;
+      } catch (ex) {
+        this._handleError(ex);
+        return;
+      }
+      this.emit("parsed", normalisedBitmapData);
+    };
+  }
+});
+
+// ../../../node_modules/.pnpm/pngjs@7.0.0/node_modules/pngjs/lib/bitpacker.js
+var require_bitpacker = __commonJS({
+  "../../../node_modules/.pnpm/pngjs@7.0.0/node_modules/pngjs/lib/bitpacker.js"(exports2, module4) {
+    "use strict";
+    var constants2 = require_constants109();
+    module4.exports = function(dataIn, width, height3, options2) {
+      let outHasAlpha = [constants2.COLORTYPE_COLOR_ALPHA, constants2.COLORTYPE_ALPHA].indexOf(
+        options2.colorType
+      ) !== -1;
+      if (options2.colorType === options2.inputColorType) {
+        let bigEndian = (function() {
+          let buffer = new ArrayBuffer(2);
+          new DataView(buffer).setInt16(
+            0,
+            256,
+            true
+            /* littleEndian */
+          );
+          return new Int16Array(buffer)[0] !== 256;
+        })();
+        if (options2.bitDepth === 8 || options2.bitDepth === 16 && bigEndian) {
+          return dataIn;
+        }
+      }
+      let data2 = options2.bitDepth !== 16 ? dataIn : new Uint16Array(dataIn.buffer);
+      let maxValue = 255;
+      let inBpp = constants2.COLORTYPE_TO_BPP_MAP[options2.inputColorType];
+      if (inBpp === 4 && !options2.inputHasAlpha) {
+        inBpp = 3;
+      }
+      let outBpp = constants2.COLORTYPE_TO_BPP_MAP[options2.colorType];
+      if (options2.bitDepth === 16) {
+        maxValue = 65535;
+        outBpp *= 2;
+      }
+      let outData = Buffer.alloc(width * height3 * outBpp);
+      let inIndex = 0;
+      let outIndex = 0;
+      let bgColor = options2.bgColor || {};
+      if (bgColor.red === void 0) {
+        bgColor.red = maxValue;
+      }
+      if (bgColor.green === void 0) {
+        bgColor.green = maxValue;
+      }
+      if (bgColor.blue === void 0) {
+        bgColor.blue = maxValue;
+      }
+      function getRGBA() {
+        let red;
+        let green;
+        let blue;
+        let alpha = maxValue;
+        switch (options2.inputColorType) {
+          case constants2.COLORTYPE_COLOR_ALPHA:
+            alpha = data2[inIndex + 3];
+            red = data2[inIndex];
+            green = data2[inIndex + 1];
+            blue = data2[inIndex + 2];
+            break;
+          case constants2.COLORTYPE_COLOR:
+            red = data2[inIndex];
+            green = data2[inIndex + 1];
+            blue = data2[inIndex + 2];
+            break;
+          case constants2.COLORTYPE_ALPHA:
+            alpha = data2[inIndex + 1];
+            red = data2[inIndex];
+            green = red;
+            blue = red;
+            break;
+          case constants2.COLORTYPE_GRAYSCALE:
+            red = data2[inIndex];
+            green = red;
+            blue = red;
+            break;
+          default:
+            throw new Error(
+              "input color type:" + options2.inputColorType + " is not supported at present"
+            );
+        }
+        if (options2.inputHasAlpha) {
+          if (!outHasAlpha) {
+            alpha /= maxValue;
+            red = Math.min(
+              Math.max(Math.round((1 - alpha) * bgColor.red + alpha * red), 0),
+              maxValue
+            );
+            green = Math.min(
+              Math.max(Math.round((1 - alpha) * bgColor.green + alpha * green), 0),
+              maxValue
+            );
+            blue = Math.min(
+              Math.max(Math.round((1 - alpha) * bgColor.blue + alpha * blue), 0),
+              maxValue
+            );
+          }
+        }
+        return { red, green, blue, alpha };
+      }
+      for (let y23 = 0; y23 < height3; y23++) {
+        for (let x15 = 0; x15 < width; x15++) {
+          let rgba = getRGBA(data2, inIndex);
+          switch (options2.colorType) {
+            case constants2.COLORTYPE_COLOR_ALPHA:
+            case constants2.COLORTYPE_COLOR:
+              if (options2.bitDepth === 8) {
+                outData[outIndex] = rgba.red;
+                outData[outIndex + 1] = rgba.green;
+                outData[outIndex + 2] = rgba.blue;
+                if (outHasAlpha) {
+                  outData[outIndex + 3] = rgba.alpha;
+                }
+              } else {
+                outData.writeUInt16BE(rgba.red, outIndex);
+                outData.writeUInt16BE(rgba.green, outIndex + 2);
+                outData.writeUInt16BE(rgba.blue, outIndex + 4);
+                if (outHasAlpha) {
+                  outData.writeUInt16BE(rgba.alpha, outIndex + 6);
+                }
+              }
+              break;
+            case constants2.COLORTYPE_ALPHA:
+            case constants2.COLORTYPE_GRAYSCALE: {
+              let grayscale = (rgba.red + rgba.green + rgba.blue) / 3;
+              if (options2.bitDepth === 8) {
+                outData[outIndex] = grayscale;
+                if (outHasAlpha) {
+                  outData[outIndex + 1] = rgba.alpha;
+                }
+              } else {
+                outData.writeUInt16BE(grayscale, outIndex);
+                if (outHasAlpha) {
+                  outData.writeUInt16BE(rgba.alpha, outIndex + 2);
+                }
+              }
+              break;
+            }
+            default:
+              throw new Error("unrecognised color Type " + options2.colorType);
+          }
+          inIndex += inBpp;
+          outIndex += outBpp;
+        }
+      }
+      return outData;
+    };
+  }
+});
+
+// ../../../node_modules/.pnpm/pngjs@7.0.0/node_modules/pngjs/lib/filter-pack.js
+var require_filter_pack = __commonJS({
+  "../../../node_modules/.pnpm/pngjs@7.0.0/node_modules/pngjs/lib/filter-pack.js"(exports2, module4) {
+    "use strict";
+    var paethPredictor = require_paeth_predictor();
+    function filterNone(pxData, pxPos, byteWidth, rawData, rawPos) {
+      for (let x15 = 0; x15 < byteWidth; x15++) {
+        rawData[rawPos + x15] = pxData[pxPos + x15];
+      }
+    }
+    function filterSumNone(pxData, pxPos, byteWidth) {
+      let sum = 0;
+      let length = pxPos + byteWidth;
+      for (let i11 = pxPos; i11 < length; i11++) {
+        sum += Math.abs(pxData[i11]);
+      }
+      return sum;
+    }
+    function filterSub(pxData, pxPos, byteWidth, rawData, rawPos, bpp) {
+      for (let x15 = 0; x15 < byteWidth; x15++) {
+        let left3 = x15 >= bpp ? pxData[pxPos + x15 - bpp] : 0;
+        let val = pxData[pxPos + x15] - left3;
+        rawData[rawPos + x15] = val;
+      }
+    }
+    function filterSumSub(pxData, pxPos, byteWidth, bpp) {
+      let sum = 0;
+      for (let x15 = 0; x15 < byteWidth; x15++) {
+        let left3 = x15 >= bpp ? pxData[pxPos + x15 - bpp] : 0;
+        let val = pxData[pxPos + x15] - left3;
+        sum += Math.abs(val);
+      }
+      return sum;
+    }
+    function filterUp(pxData, pxPos, byteWidth, rawData, rawPos) {
+      for (let x15 = 0; x15 < byteWidth; x15++) {
+        let up4 = pxPos > 0 ? pxData[pxPos + x15 - byteWidth] : 0;
+        let val = pxData[pxPos + x15] - up4;
+        rawData[rawPos + x15] = val;
+      }
+    }
+    function filterSumUp(pxData, pxPos, byteWidth) {
+      let sum = 0;
+      let length = pxPos + byteWidth;
+      for (let x15 = pxPos; x15 < length; x15++) {
+        let up4 = pxPos > 0 ? pxData[x15 - byteWidth] : 0;
+        let val = pxData[x15] - up4;
+        sum += Math.abs(val);
+      }
+      return sum;
+    }
+    function filterAvg(pxData, pxPos, byteWidth, rawData, rawPos, bpp) {
+      for (let x15 = 0; x15 < byteWidth; x15++) {
+        let left3 = x15 >= bpp ? pxData[pxPos + x15 - bpp] : 0;
+        let up4 = pxPos > 0 ? pxData[pxPos + x15 - byteWidth] : 0;
+        let val = pxData[pxPos + x15] - (left3 + up4 >> 1);
+        rawData[rawPos + x15] = val;
+      }
+    }
+    function filterSumAvg(pxData, pxPos, byteWidth, bpp) {
+      let sum = 0;
+      for (let x15 = 0; x15 < byteWidth; x15++) {
+        let left3 = x15 >= bpp ? pxData[pxPos + x15 - bpp] : 0;
+        let up4 = pxPos > 0 ? pxData[pxPos + x15 - byteWidth] : 0;
+        let val = pxData[pxPos + x15] - (left3 + up4 >> 1);
+        sum += Math.abs(val);
+      }
+      return sum;
+    }
+    function filterPaeth(pxData, pxPos, byteWidth, rawData, rawPos, bpp) {
+      for (let x15 = 0; x15 < byteWidth; x15++) {
+        let left3 = x15 >= bpp ? pxData[pxPos + x15 - bpp] : 0;
+        let up4 = pxPos > 0 ? pxData[pxPos + x15 - byteWidth] : 0;
+        let upleft = pxPos > 0 && x15 >= bpp ? pxData[pxPos + x15 - (byteWidth + bpp)] : 0;
+        let val = pxData[pxPos + x15] - paethPredictor(left3, up4, upleft);
+        rawData[rawPos + x15] = val;
+      }
+    }
+    function filterSumPaeth(pxData, pxPos, byteWidth, bpp) {
+      let sum = 0;
+      for (let x15 = 0; x15 < byteWidth; x15++) {
+        let left3 = x15 >= bpp ? pxData[pxPos + x15 - bpp] : 0;
+        let up4 = pxPos > 0 ? pxData[pxPos + x15 - byteWidth] : 0;
+        let upleft = pxPos > 0 && x15 >= bpp ? pxData[pxPos + x15 - (byteWidth + bpp)] : 0;
+        let val = pxData[pxPos + x15] - paethPredictor(left3, up4, upleft);
+        sum += Math.abs(val);
+      }
+      return sum;
+    }
+    var filters = {
+      0: filterNone,
+      1: filterSub,
+      2: filterUp,
+      3: filterAvg,
+      4: filterPaeth
+    };
+    var filterSums = {
+      0: filterSumNone,
+      1: filterSumSub,
+      2: filterSumUp,
+      3: filterSumAvg,
+      4: filterSumPaeth
+    };
+    module4.exports = function(pxData, width, height3, options2, bpp) {
+      let filterTypes;
+      if (!("filterType" in options2) || options2.filterType === -1) {
+        filterTypes = [0, 1, 2, 3, 4];
+      } else if (typeof options2.filterType === "number") {
+        filterTypes = [options2.filterType];
+      } else {
+        throw new Error("unrecognised filter types");
+      }
+      if (options2.bitDepth === 16) {
+        bpp *= 2;
+      }
+      let byteWidth = width * bpp;
+      let rawPos = 0;
+      let pxPos = 0;
+      let rawData = Buffer.alloc((byteWidth + 1) * height3);
+      let sel = filterTypes[0];
+      for (let y23 = 0; y23 < height3; y23++) {
+        if (filterTypes.length > 1) {
+          let min = Infinity;
+          for (let i11 = 0; i11 < filterTypes.length; i11++) {
+            let sum = filterSums[filterTypes[i11]](pxData, pxPos, byteWidth, bpp);
+            if (sum < min) {
+              sel = filterTypes[i11];
+              min = sum;
+            }
+          }
+        }
+        rawData[rawPos] = sel;
+        rawPos++;
+        filters[sel](pxData, pxPos, byteWidth, rawData, rawPos, bpp);
+        rawPos += byteWidth;
+        pxPos += byteWidth;
+      }
+      return rawData;
+    };
+  }
+});
+
+// ../../../node_modules/.pnpm/pngjs@7.0.0/node_modules/pngjs/lib/packer.js
+var require_packer = __commonJS({
+  "../../../node_modules/.pnpm/pngjs@7.0.0/node_modules/pngjs/lib/packer.js"(exports2, module4) {
+    "use strict";
+    var constants2 = require_constants109();
+    var CrcStream = require_crc();
+    var bitPacker = require_bitpacker();
+    var filter7 = require_filter_pack();
+    var zlib4 = require("zlib");
+    var Packer = module4.exports = function(options2) {
+      this._options = options2;
+      options2.deflateChunkSize = options2.deflateChunkSize || 32 * 1024;
+      options2.deflateLevel = options2.deflateLevel != null ? options2.deflateLevel : 9;
+      options2.deflateStrategy = options2.deflateStrategy != null ? options2.deflateStrategy : 3;
+      options2.inputHasAlpha = options2.inputHasAlpha != null ? options2.inputHasAlpha : true;
+      options2.deflateFactory = options2.deflateFactory || zlib4.createDeflate;
+      options2.bitDepth = options2.bitDepth || 8;
+      options2.colorType = typeof options2.colorType === "number" ? options2.colorType : constants2.COLORTYPE_COLOR_ALPHA;
+      options2.inputColorType = typeof options2.inputColorType === "number" ? options2.inputColorType : constants2.COLORTYPE_COLOR_ALPHA;
+      if ([
+        constants2.COLORTYPE_GRAYSCALE,
+        constants2.COLORTYPE_COLOR,
+        constants2.COLORTYPE_COLOR_ALPHA,
+        constants2.COLORTYPE_ALPHA
+      ].indexOf(options2.colorType) === -1) {
+        throw new Error(
+          "option color type:" + options2.colorType + " is not supported at present"
+        );
+      }
+      if ([
+        constants2.COLORTYPE_GRAYSCALE,
+        constants2.COLORTYPE_COLOR,
+        constants2.COLORTYPE_COLOR_ALPHA,
+        constants2.COLORTYPE_ALPHA
+      ].indexOf(options2.inputColorType) === -1) {
+        throw new Error(
+          "option input color type:" + options2.inputColorType + " is not supported at present"
+        );
+      }
+      if (options2.bitDepth !== 8 && options2.bitDepth !== 16) {
+        throw new Error(
+          "option bit depth:" + options2.bitDepth + " is not supported at present"
+        );
+      }
+    };
+    Packer.prototype.getDeflateOptions = function() {
+      return {
+        chunkSize: this._options.deflateChunkSize,
+        level: this._options.deflateLevel,
+        strategy: this._options.deflateStrategy
+      };
+    };
+    Packer.prototype.createDeflate = function() {
+      return this._options.deflateFactory(this.getDeflateOptions());
+    };
+    Packer.prototype.filterData = function(data2, width, height3) {
+      let packedData = bitPacker(data2, width, height3, this._options);
+      let bpp = constants2.COLORTYPE_TO_BPP_MAP[this._options.colorType];
+      let filteredData = filter7(packedData, width, height3, this._options, bpp);
+      return filteredData;
+    };
+    Packer.prototype._packChunk = function(type8, data2) {
+      let len = data2 ? data2.length : 0;
+      let buf = Buffer.alloc(len + 12);
+      buf.writeUInt32BE(len, 0);
+      buf.writeUInt32BE(type8, 4);
+      if (data2) {
+        data2.copy(buf, 8);
+      }
+      buf.writeInt32BE(
+        CrcStream.crc32(buf.slice(4, buf.length - 4)),
+        buf.length - 4
+      );
+      return buf;
+    };
+    Packer.prototype.packGAMA = function(gamma) {
+      let buf = Buffer.alloc(4);
+      buf.writeUInt32BE(Math.floor(gamma * constants2.GAMMA_DIVISION), 0);
+      return this._packChunk(constants2.TYPE_gAMA, buf);
+    };
+    Packer.prototype.packIHDR = function(width, height3) {
+      let buf = Buffer.alloc(13);
+      buf.writeUInt32BE(width, 0);
+      buf.writeUInt32BE(height3, 4);
+      buf[8] = this._options.bitDepth;
+      buf[9] = this._options.colorType;
+      buf[10] = 0;
+      buf[11] = 0;
+      buf[12] = 0;
+      return this._packChunk(constants2.TYPE_IHDR, buf);
+    };
+    Packer.prototype.packIDAT = function(data2) {
+      return this._packChunk(constants2.TYPE_IDAT, data2);
+    };
+    Packer.prototype.packIEND = function() {
+      return this._packChunk(constants2.TYPE_IEND, null);
+    };
+  }
+});
+
+// ../../../node_modules/.pnpm/pngjs@7.0.0/node_modules/pngjs/lib/packer-async.js
+var require_packer_async = __commonJS({
+  "../../../node_modules/.pnpm/pngjs@7.0.0/node_modules/pngjs/lib/packer-async.js"(exports2, module4) {
+    "use strict";
+    var util4 = require("util");
+    var Stream5 = require("stream");
+    var constants2 = require_constants109();
+    var Packer = require_packer();
+    var PackerAsync = module4.exports = function(opt) {
+      Stream5.call(this);
+      let options2 = opt || {};
+      this._packer = new Packer(options2);
+      this._deflate = this._packer.createDeflate();
+      this.readable = true;
+    };
+    util4.inherits(PackerAsync, Stream5);
+    PackerAsync.prototype.pack = function(data2, width, height3, gamma) {
+      this.emit("data", Buffer.from(constants2.PNG_SIGNATURE));
+      this.emit("data", this._packer.packIHDR(width, height3));
+      if (gamma) {
+        this.emit("data", this._packer.packGAMA(gamma));
+      }
+      let filteredData = this._packer.filterData(data2, width, height3);
+      this._deflate.on("error", this.emit.bind(this, "error"));
+      this._deflate.on(
+        "data",
+        function(compressedData) {
+          this.emit("data", this._packer.packIDAT(compressedData));
+        }.bind(this)
+      );
+      this._deflate.on(
+        "end",
+        function() {
+          this.emit("data", this._packer.packIEND());
+          this.emit("end");
+        }.bind(this)
+      );
+      this._deflate.end(filteredData);
+    };
+  }
+});
+
+// ../../../node_modules/.pnpm/pngjs@7.0.0/node_modules/pngjs/lib/sync-inflate.js
+var require_sync_inflate = __commonJS({
+  "../../../node_modules/.pnpm/pngjs@7.0.0/node_modules/pngjs/lib/sync-inflate.js"(exports2, module4) {
+    "use strict";
+    var assert12 = require("assert").ok;
+    var zlib4 = require("zlib");
+    var util4 = require("util");
+    var kMaxLength = require("buffer").kMaxLength;
+    function Inflate(opts) {
+      if (!(this instanceof Inflate)) {
+        return new Inflate(opts);
+      }
+      if (opts && opts.chunkSize < zlib4.Z_MIN_CHUNK) {
+        opts.chunkSize = zlib4.Z_MIN_CHUNK;
+      }
+      zlib4.Inflate.call(this, opts);
+      this._offset = this._offset === void 0 ? this._outOffset : this._offset;
+      this._buffer = this._buffer || this._outBuffer;
+      if (opts && opts.maxLength != null) {
+        this._maxLength = opts.maxLength;
+      }
+    }
+    function createInflate(opts) {
+      return new Inflate(opts);
+    }
+    function _close2(engine, callback) {
+      if (callback) {
+        process.nextTick(callback);
+      }
+      if (!engine._handle) {
+        return;
+      }
+      engine._handle.close();
+      engine._handle = null;
+    }
+    Inflate.prototype._processChunk = function(chunk2, flushFlag, asyncCb) {
+      if (typeof asyncCb === "function") {
+        return zlib4.Inflate._processChunk.call(this, chunk2, flushFlag, asyncCb);
+      }
+      let self2 = this;
+      let availInBefore = chunk2 && chunk2.length;
+      let availOutBefore = this._chunkSize - this._offset;
+      let leftToInflate = this._maxLength;
+      let inOff = 0;
+      let buffers = [];
+      let nread = 0;
+      let error49;
+      this.on("error", function(err) {
+        error49 = err;
+      });
+      function handleChunk(availInAfter, availOutAfter) {
+        if (self2._hadError) {
+          return;
+        }
+        let have = availOutBefore - availOutAfter;
+        assert12(have >= 0, "have should not go down");
+        if (have > 0) {
+          let out = self2._buffer.slice(self2._offset, self2._offset + have);
+          self2._offset += have;
+          if (out.length > leftToInflate) {
+            out = out.slice(0, leftToInflate);
+          }
+          buffers.push(out);
+          nread += out.length;
+          leftToInflate -= out.length;
+          if (leftToInflate === 0) {
+            return false;
+          }
+        }
+        if (availOutAfter === 0 || self2._offset >= self2._chunkSize) {
+          availOutBefore = self2._chunkSize;
+          self2._offset = 0;
+          self2._buffer = Buffer.allocUnsafe(self2._chunkSize);
+        }
+        if (availOutAfter === 0) {
+          inOff += availInBefore - availInAfter;
+          availInBefore = availInAfter;
+          return true;
+        }
+        return false;
+      }
+      assert12(this._handle, "zlib binding closed");
+      let res;
+      do {
+        res = this._handle.writeSync(
+          flushFlag,
+          chunk2,
+          // in
+          inOff,
+          // in_off
+          availInBefore,
+          // in_len
+          this._buffer,
+          // out
+          this._offset,
+          //out_off
+          availOutBefore
+        );
+        res = res || this._writeState;
+      } while (!this._hadError && handleChunk(res[0], res[1]));
+      if (this._hadError) {
+        throw error49;
+      }
+      if (nread >= kMaxLength) {
+        _close2(this);
+        throw new RangeError(
+          "Cannot create final Buffer. It would be larger than 0x" + kMaxLength.toString(16) + " bytes"
+        );
+      }
+      let buf = Buffer.concat(buffers, nread);
+      _close2(this);
+      return buf;
+    };
+    util4.inherits(Inflate, zlib4.Inflate);
+    function zlibBufferSync(engine, buffer) {
+      if (typeof buffer === "string") {
+        buffer = Buffer.from(buffer);
+      }
+      if (!(buffer instanceof Buffer)) {
+        throw new TypeError("Not a string or buffer");
+      }
+      let flushFlag = engine._finishFlushFlag;
+      if (flushFlag == null) {
+        flushFlag = zlib4.Z_FINISH;
+      }
+      return engine._processChunk(buffer, flushFlag);
+    }
+    function inflateSync(buffer, opts) {
+      return zlibBufferSync(new Inflate(opts), buffer);
+    }
+    module4.exports = exports2 = inflateSync;
+    exports2.Inflate = Inflate;
+    exports2.createInflate = createInflate;
+    exports2.inflateSync = inflateSync;
+  }
+});
+
+// ../../../node_modules/.pnpm/pngjs@7.0.0/node_modules/pngjs/lib/sync-reader.js
+var require_sync_reader = __commonJS({
+  "../../../node_modules/.pnpm/pngjs@7.0.0/node_modules/pngjs/lib/sync-reader.js"(exports2, module4) {
+    "use strict";
+    var SyncReader = module4.exports = function(buffer) {
+      this._buffer = buffer;
+      this._reads = [];
+    };
+    SyncReader.prototype.read = function(length, callback) {
+      this._reads.push({
+        length: Math.abs(length),
+        // if length < 0 then at most this length
+        allowLess: length < 0,
+        func: callback
+      });
+    };
+    SyncReader.prototype.process = function() {
+      while (this._reads.length > 0 && this._buffer.length) {
+        let read2 = this._reads[0];
+        if (this._buffer.length && (this._buffer.length >= read2.length || read2.allowLess)) {
+          this._reads.shift();
+          let buf = this._buffer;
+          this._buffer = buf.slice(read2.length);
+          read2.func.call(this, buf.slice(0, read2.length));
+        } else {
+          break;
+        }
+      }
+      if (this._reads.length > 0) {
+        throw new Error("There are some read requests waitng on finished stream");
+      }
+      if (this._buffer.length > 0) {
+        throw new Error("unrecognised content at end of stream");
+      }
+    };
+  }
+});
+
+// ../../../node_modules/.pnpm/pngjs@7.0.0/node_modules/pngjs/lib/filter-parse-sync.js
+var require_filter_parse_sync = __commonJS({
+  "../../../node_modules/.pnpm/pngjs@7.0.0/node_modules/pngjs/lib/filter-parse-sync.js"(exports2) {
+    "use strict";
+    var SyncReader = require_sync_reader();
+    var Filter = require_filter_parse();
+    exports2.process = function(inBuffer, bitmapInfo) {
+      let outBuffers = [];
+      let reader = new SyncReader(inBuffer);
+      let filter7 = new Filter(bitmapInfo, {
+        read: reader.read.bind(reader),
+        write: function(bufferPart) {
+          outBuffers.push(bufferPart);
+        },
+        complete: function() {
+        }
+      });
+      filter7.start();
+      reader.process();
+      return Buffer.concat(outBuffers);
+    };
+  }
+});
+
+// ../../../node_modules/.pnpm/pngjs@7.0.0/node_modules/pngjs/lib/parser-sync.js
+var require_parser_sync = __commonJS({
+  "../../../node_modules/.pnpm/pngjs@7.0.0/node_modules/pngjs/lib/parser-sync.js"(exports2, module4) {
+    "use strict";
+    var hasSyncZlib = true;
+    var zlib4 = require("zlib");
+    var inflateSync = require_sync_inflate();
+    if (!zlib4.deflateSync) {
+      hasSyncZlib = false;
+    }
+    var SyncReader = require_sync_reader();
+    var FilterSync = require_filter_parse_sync();
+    var Parser8 = require_parser4();
+    var bitmapper = require_bitmapper();
+    var formatNormaliser = require_format_normaliser();
+    module4.exports = function(buffer, options2) {
+      if (!hasSyncZlib) {
+        throw new Error(
+          "To use the sync capability of this library in old node versions, please pin pngjs to v2.3.0"
+        );
+      }
+      let err;
+      function handleError3(_err_) {
+        err = _err_;
+      }
+      let metaData;
+      function handleMetaData(_metaData_) {
+        metaData = _metaData_;
+      }
+      function handleTransColor(transColor) {
+        metaData.transColor = transColor;
+      }
+      function handlePalette(palette) {
+        metaData.palette = palette;
+      }
+      function handleSimpleTransparency() {
+        metaData.alpha = true;
+      }
+      let gamma;
+      function handleGamma(_gamma_) {
+        gamma = _gamma_;
+      }
+      let inflateDataList = [];
+      function handleInflateData(inflatedData2) {
+        inflateDataList.push(inflatedData2);
+      }
+      let reader = new SyncReader(buffer);
+      let parser4 = new Parser8(options2, {
+        read: reader.read.bind(reader),
+        error: handleError3,
+        metadata: handleMetaData,
+        gamma: handleGamma,
+        palette: handlePalette,
+        transColor: handleTransColor,
+        inflateData: handleInflateData,
+        simpleTransparency: handleSimpleTransparency
+      });
+      parser4.start();
+      reader.process();
+      if (err) {
+        throw err;
+      }
+      let inflateData = Buffer.concat(inflateDataList);
+      inflateDataList.length = 0;
+      let inflatedData;
+      if (metaData.interlace) {
+        inflatedData = zlib4.inflateSync(inflateData);
+      } else {
+        let rowSize = (metaData.width * metaData.bpp * metaData.depth + 7 >> 3) + 1;
+        let imageSize2 = rowSize * metaData.height;
+        inflatedData = inflateSync(inflateData, {
+          chunkSize: imageSize2,
+          maxLength: imageSize2
+        });
+      }
+      inflateData = null;
+      if (!inflatedData || !inflatedData.length) {
+        throw new Error("bad png - invalid inflate data response");
+      }
+      let unfilteredData = FilterSync.process(inflatedData, metaData);
+      inflateData = null;
+      let bitmapData = bitmapper.dataToBitMap(unfilteredData, metaData);
+      unfilteredData = null;
+      let normalisedBitmapData = formatNormaliser(
+        bitmapData,
+        metaData,
+        options2.skipRescale
+      );
+      metaData.data = normalisedBitmapData;
+      metaData.gamma = gamma || 0;
+      return metaData;
+    };
+  }
+});
+
+// ../../../node_modules/.pnpm/pngjs@7.0.0/node_modules/pngjs/lib/packer-sync.js
+var require_packer_sync = __commonJS({
+  "../../../node_modules/.pnpm/pngjs@7.0.0/node_modules/pngjs/lib/packer-sync.js"(exports2, module4) {
+    "use strict";
+    var hasSyncZlib = true;
+    var zlib4 = require("zlib");
+    if (!zlib4.deflateSync) {
+      hasSyncZlib = false;
+    }
+    var constants2 = require_constants109();
+    var Packer = require_packer();
+    module4.exports = function(metaData, opt) {
+      if (!hasSyncZlib) {
+        throw new Error(
+          "To use the sync capability of this library in old node versions, please pin pngjs to v2.3.0"
+        );
+      }
+      let options2 = opt || {};
+      let packer = new Packer(options2);
+      let chunks = [];
+      chunks.push(Buffer.from(constants2.PNG_SIGNATURE));
+      chunks.push(packer.packIHDR(metaData.width, metaData.height));
+      if (metaData.gamma) {
+        chunks.push(packer.packGAMA(metaData.gamma));
+      }
+      let filteredData = packer.filterData(
+        metaData.data,
+        metaData.width,
+        metaData.height
+      );
+      let compressedData = zlib4.deflateSync(
+        filteredData,
+        packer.getDeflateOptions()
+      );
+      filteredData = null;
+      if (!compressedData || !compressedData.length) {
+        throw new Error("bad png - invalid compressed data response");
+      }
+      chunks.push(packer.packIDAT(compressedData));
+      chunks.push(packer.packIEND());
+      return Buffer.concat(chunks);
+    };
+  }
+});
+
+// ../../../node_modules/.pnpm/pngjs@7.0.0/node_modules/pngjs/lib/png-sync.js
+var require_png_sync = __commonJS({
+  "../../../node_modules/.pnpm/pngjs@7.0.0/node_modules/pngjs/lib/png-sync.js"(exports2) {
+    "use strict";
+    var parse18 = require_parser_sync();
+    var pack = require_packer_sync();
+    exports2.read = function(buffer, options2) {
+      return parse18(buffer, options2 || {});
+    };
+    exports2.write = function(png, options2) {
+      return pack(png, options2);
+    };
+  }
+});
+
+// ../../../node_modules/.pnpm/pngjs@7.0.0/node_modules/pngjs/lib/png.js
+var require_png2 = __commonJS({
+  "../../../node_modules/.pnpm/pngjs@7.0.0/node_modules/pngjs/lib/png.js"(exports2) {
+    "use strict";
+    var util4 = require("util");
+    var Stream5 = require("stream");
+    var Parser8 = require_parser_async();
+    var Packer = require_packer_async();
+    var PNGSync = require_png_sync();
+    var PNG2 = exports2.PNG = function(options2) {
+      Stream5.call(this);
+      options2 = options2 || {};
+      this.width = options2.width | 0;
+      this.height = options2.height | 0;
+      this.data = this.width > 0 && this.height > 0 ? Buffer.alloc(4 * this.width * this.height) : null;
+      if (options2.fill && this.data) {
+        this.data.fill(0);
+      }
+      this.gamma = 0;
+      this.readable = this.writable = true;
+      this._parser = new Parser8(options2);
+      this._parser.on("error", this.emit.bind(this, "error"));
+      this._parser.on("close", this._handleClose.bind(this));
+      this._parser.on("metadata", this._metadata.bind(this));
+      this._parser.on("gamma", this._gamma.bind(this));
+      this._parser.on(
+        "parsed",
+        function(data2) {
+          this.data = data2;
+          this.emit("parsed", data2);
+        }.bind(this)
+      );
+      this._packer = new Packer(options2);
+      this._packer.on("data", this.emit.bind(this, "data"));
+      this._packer.on("end", this.emit.bind(this, "end"));
+      this._parser.on("close", this._handleClose.bind(this));
+      this._packer.on("error", this.emit.bind(this, "error"));
+    };
+    util4.inherits(PNG2, Stream5);
+    PNG2.sync = PNGSync;
+    PNG2.prototype.pack = function() {
+      if (!this.data || !this.data.length) {
+        this.emit("error", "No data provided");
+        return this;
+      }
+      process.nextTick(
+        function() {
+          this._packer.pack(this.data, this.width, this.height, this.gamma);
+        }.bind(this)
+      );
+      return this;
+    };
+    PNG2.prototype.parse = function(data2, callback) {
+      if (callback) {
+        let onParsed, onError2;
+        onParsed = function(parsedData) {
+          this.removeListener("error", onError2);
+          this.data = parsedData;
+          callback(null, this);
+        }.bind(this);
+        onError2 = function(err) {
+          this.removeListener("parsed", onParsed);
+          callback(err, null);
+        }.bind(this);
+        this.once("parsed", onParsed);
+        this.once("error", onError2);
+      }
+      this.end(data2);
+      return this;
+    };
+    PNG2.prototype.write = function(data2) {
+      this._parser.write(data2);
+      return true;
+    };
+    PNG2.prototype.end = function(data2) {
+      this._parser.end(data2);
+    };
+    PNG2.prototype._metadata = function(metadata) {
+      this.width = metadata.width;
+      this.height = metadata.height;
+      this.emit("metadata", metadata);
+    };
+    PNG2.prototype._gamma = function(gamma) {
+      this.gamma = gamma;
+    };
+    PNG2.prototype._handleClose = function() {
+      if (!this._parser.writable && !this._packer.readable) {
+        this.emit("close");
+      }
+    };
+    PNG2.bitblt = function(src, dst, srcX, srcY, width, height3, deltaX, deltaY) {
+      srcX |= 0;
+      srcY |= 0;
+      width |= 0;
+      height3 |= 0;
+      deltaX |= 0;
+      deltaY |= 0;
+      if (srcX > src.width || srcY > src.height || srcX + width > src.width || srcY + height3 > src.height) {
+        throw new Error("bitblt reading outside image");
+      }
+      if (deltaX > dst.width || deltaY > dst.height || deltaX + width > dst.width || deltaY + height3 > dst.height) {
+        throw new Error("bitblt writing outside image");
+      }
+      for (let y23 = 0; y23 < height3; y23++) {
+        src.data.copy(
+          dst.data,
+          (deltaY + y23) * dst.width + deltaX << 2,
+          (srcY + y23) * src.width + srcX << 2,
+          (srcY + y23) * src.width + srcX + width << 2
+        );
+      }
+    };
+    PNG2.prototype.bitblt = function(dst, srcX, srcY, width, height3, deltaX, deltaY) {
+      PNG2.bitblt(this, dst, srcX, srcY, width, height3, deltaX, deltaY);
+      return this;
+    };
+    PNG2.adjustGamma = function(src) {
+      if (src.gamma) {
+        for (let y23 = 0; y23 < src.height; y23++) {
+          for (let x15 = 0; x15 < src.width; x15++) {
+            let idx = src.width * y23 + x15 << 2;
+            for (let i11 = 0; i11 < 3; i11++) {
+              let sample = src.data[idx + i11] / 255;
+              sample = Math.pow(sample, 1 / 2.2 / src.gamma);
+              src.data[idx + i11] = Math.round(sample * 255);
+            }
+          }
+        }
+        src.gamma = 0;
+      }
+    };
+    PNG2.prototype.adjustGamma = function() {
+      PNG2.adjustGamma(this);
+    };
+  }
+});
+
 // ../../../node_modules/.pnpm/validate-npm-package-name@5.0.1/node_modules/validate-npm-package-name/lib/index.js
 var require_lib20 = __commonJS({
   "../../../node_modules/.pnpm/validate-npm-package-name@5.0.1/node_modules/validate-npm-package-name/lib/index.js"(exports2, module4) {
@@ -1286964,7 +1289052,7 @@ var require_errors154 = __commonJS({
 });
 
 // ../../../node_modules/.pnpm/undici@6.23.0/node_modules/undici/lib/core/constants.js
-var require_constants109 = __commonJS({
+var require_constants110 = __commonJS({
   "../../../node_modules/.pnpm/undici@6.23.0/node_modules/undici/lib/core/constants.js"(exports2, module4) {
     "use strict";
     var headerNameLowerCasedRecord = {};
@@ -1287085,7 +1289173,7 @@ var require_tree = __commonJS({
     var {
       wellknownHeaderNames,
       headerNameLowerCasedRecord
-    } = require_constants109();
+    } = require_constants110();
     var TstNode = class _TstNode {
       /** @type {any} */
       value = null;
@@ -1287232,7 +1289320,7 @@ var require_util10 = __commonJS({
     var { stringify: stringify5 } = require("querystring");
     var { EventEmitter: EE3 } = require("events");
     var { InvalidArgumentError } = require_errors154();
-    var { headerNameLowerCasedRecord } = require_constants109();
+    var { headerNameLowerCasedRecord } = require_constants110();
     var { tree } = require_tree();
     var [nodeMajor, nodeMinor] = process.versions.node.split(".").map((v21) => Number(v21));
     var BodyAsyncIterable = class {
@@ -1287933,7 +1290021,7 @@ var require_request4 = __commonJS({
       normalizedMethodRecords
     } = require_util10();
     var { channels } = require_diagnostics();
-    var { headerNameLowerCasedRecord } = require_constants109();
+    var { headerNameLowerCasedRecord } = require_constants110();
     var invalidPathRegex = /[^\u0021-\u00ff]/;
     var kHandler = Symbol("handler");
     var Request9 = class {
@@ -1288881,7 +1290969,7 @@ var require_utils20 = __commonJS({
 });
 
 // ../../../node_modules/.pnpm/undici@6.23.0/node_modules/undici/lib/llhttp/constants.js
-var require_constants110 = __commonJS({
+var require_constants111 = __commonJS({
   "../../../node_modules/.pnpm/undici@6.23.0/node_modules/undici/lib/llhttp/constants.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
@@ -1289220,7 +1291308,7 @@ var require_llhttp_simd_wasm = __commonJS({
 });
 
 // ../../../node_modules/.pnpm/undici@6.23.0/node_modules/undici/lib/web/fetch/constants.js
-var require_constants111 = __commonJS({
+var require_constants112 = __commonJS({
   "../../../node_modules/.pnpm/undici@6.23.0/node_modules/undici/lib/web/fetch/constants.js"(exports2, module4) {
     "use strict";
     var corsSafeListedMethods = (
@@ -1290250,7 +1292338,7 @@ var require_util11 = __commonJS({
     "use strict";
     var { Transform } = require("stream");
     var zlib4 = require("zlib");
-    var { redirectStatusSet, referrerPolicySet: referrerPolicyTokens, badPortsSet } = require_constants111();
+    var { redirectStatusSet, referrerPolicySet: referrerPolicyTokens, badPortsSet } = require_constants112();
     var { getGlobalOrigin } = require_global();
     var { collectASequenceOfCodePoints, collectAnHTTPQuotedString, removeChars, parseMIMEType } = require_data_url();
     var { performance: performance2 } = require("perf_hooks");
@@ -1291956,7 +1294044,7 @@ var require_client_h1 = __commonJS({
       kResume,
       kHTTPContext
     } = require_symbols();
-    var constants2 = require_constants110();
+    var constants2 = require_constants111();
     var EMPTY_BUF = Buffer.alloc(0);
     var FastBuffer = Buffer[Symbol.species];
     var addListener = util4.addListener;
@@ -1298367,7 +1300455,7 @@ var require_response2 = __commonJS({
     var {
       redirectStatusSet,
       nullBodyStatus
-    } = require_constants111();
+    } = require_constants112();
     var { kState, kHeaders } = require_symbols2();
     var { webidl } = require_webidl();
     var { FormData: FormData6 } = require_formdata();
@@ -1298809,7 +1300897,7 @@ var require_request5 = __commonJS({
       requestCredentials,
       requestCache,
       requestDuplex
-    } = require_constants111();
+    } = require_constants112();
     var { kEnumerableProperty, normalizedMethodRecordsBase, normalizedMethodRecords } = util4;
     var { kHeaders, kSignal, kState, kDispatcher } = require_symbols2();
     var { webidl } = require_webidl();
@@ -1299539,7 +1301627,7 @@ var require_fetch = __commonJS({
       safeMethodsSet,
       requestBodyHeader,
       subresourceSet
-    } = require_constants111();
+    } = require_constants112();
     var EE3 = require("events");
     var { Readable: Readable6, pipeline: pipeline5, finished: finished2 } = require("stream");
     var { addAbortListener, isErrored, isReadable: isReadable2, bufferToLowerCasedHeaderName } = require_util10();
@@ -1302057,7 +1304145,7 @@ var require_cachestorage = __commonJS({
 });
 
 // ../../../node_modules/.pnpm/undici@6.23.0/node_modules/undici/lib/web/cookies/constants.js
-var require_constants112 = __commonJS({
+var require_constants113 = __commonJS({
   "../../../node_modules/.pnpm/undici@6.23.0/node_modules/undici/lib/web/cookies/constants.js"(exports2, module4) {
     "use strict";
     var maxAttributeValueSize = 1024;
@@ -1302243,7 +1304331,7 @@ var require_util15 = __commonJS({
 var require_parse5 = __commonJS({
   "../../../node_modules/.pnpm/undici@6.23.0/node_modules/undici/lib/web/cookies/parse.js"(exports2, module4) {
     "use strict";
-    var { maxNameValuePairSize, maxAttributeValueSize } = require_constants112();
+    var { maxNameValuePairSize, maxAttributeValueSize } = require_constants113();
     var { isCTLExcludingHtab } = require_util15();
     var { collectASequenceOfCodePointsFast } = require_data_url();
     var assert12 = require("assert");
@@ -1302775,7 +1304863,7 @@ var require_events2 = __commonJS({
 });
 
 // ../../../node_modules/.pnpm/undici@6.23.0/node_modules/undici/lib/web/websocket/constants.js
-var require_constants113 = __commonJS({
+var require_constants114 = __commonJS({
   "../../../node_modules/.pnpm/undici@6.23.0/node_modules/undici/lib/web/websocket/constants.js"(exports2, module4) {
     "use strict";
     var uid = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
@@ -1302853,7 +1304941,7 @@ var require_util16 = __commonJS({
   "../../../node_modules/.pnpm/undici@6.23.0/node_modules/undici/lib/web/websocket/util.js"(exports2, module4) {
     "use strict";
     var { kReadyState, kController, kResponse, kBinaryType, kWebSocketURL } = require_symbols5();
-    var { states, opcodes } = require_constants113();
+    var { states, opcodes } = require_constants114();
     var { ErrorEvent, createFastMessageEvent } = require_events2();
     var { isUtf8 } = require("buffer");
     var { collectASequenceOfCodePointsFast, removeHTTPWhitespace } = require_data_url();
@@ -1303021,7 +1305109,7 @@ var require_util16 = __commonJS({
 var require_frame = __commonJS({
   "../../../node_modules/.pnpm/undici@6.23.0/node_modules/undici/lib/web/websocket/frame.js"(exports2, module4) {
     "use strict";
-    var { maxUnsigned16Bit } = require_constants113();
+    var { maxUnsigned16Bit } = require_constants114();
     var BUFFER_SIZE = 16386;
     var crypto5;
     var buffer = null;
@@ -1303098,7 +1305186,7 @@ var require_frame = __commonJS({
 var require_connection = __commonJS({
   "../../../node_modules/.pnpm/undici@6.23.0/node_modules/undici/lib/web/websocket/connection.js"(exports2, module4) {
     "use strict";
-    var { uid, states, sentCloseFrameState, emptyBuffer, opcodes } = require_constants113();
+    var { uid, states, sentCloseFrameState, emptyBuffer, opcodes } = require_constants114();
     var {
       kReadyState,
       kSentClose,
@@ -1303340,7 +1305428,7 @@ var require_receiver2 = __commonJS({
     "use strict";
     var { Writable: Writable2 } = require("stream");
     var assert12 = require("assert");
-    var { parserStates, opcodes, states, emptyBuffer, sentCloseFrameState } = require_constants113();
+    var { parserStates, opcodes, states, emptyBuffer, sentCloseFrameState } = require_constants114();
     var { kReadyState, kSentClose, kResponse, kReceivedClose } = require_symbols5();
     var { channels } = require_diagnostics();
     var {
@@ -1303644,7 +1305732,7 @@ var require_sender2 = __commonJS({
   "../../../node_modules/.pnpm/undici@6.23.0/node_modules/undici/lib/web/websocket/sender.js"(exports2, module4) {
     "use strict";
     var { WebsocketFrameSend } = require_frame();
-    var { opcodes, sendHints } = require_constants113();
+    var { opcodes, sendHints } = require_constants114();
     var FixedQueue = require_fixed_queue();
     var FastBuffer = Buffer[Symbol.species];
     var SendQueue = class {
@@ -1303728,7 +1305816,7 @@ var require_websocket67 = __commonJS({
     var { webidl } = require_webidl();
     var { URLSerializer } = require_data_url();
     var { environmentSettingsObject } = require_util11();
-    var { staticPropertyDescriptors, states, sentCloseFrameState, sendHints } = require_constants113();
+    var { staticPropertyDescriptors, states, sentCloseFrameState, sendHints } = require_constants114();
     var {
       kWebSocketURL,
       kReadyState,
@@ -1498423,6 +1500511,11 @@ var Generation = class {
       origin: this.model.staticExplicit("JsonUtils"),
       namespace: this.namespaces.core
     }),
+    /** Test assertion helper for JSON comparison */
+    JsonAssert: () => this.csharp.classReference({
+      origin: this.model.staticExplicit("JsonAssert"),
+      namespace: this.namespaces.testUtils
+    }),
     /** Factory for creating custom pagination instances */
     CustomPagerFactory: () => this.csharp.classReference({
       origin: this.model.staticExplicit(`${this.names.classes.customPager}Factory`),
@@ -1589018,13 +1591111,13 @@ async function removeInvalidAiExamples({ sourceFilePath, context: context2 }) {
         }
       }
     }
-    const { writeFile: writeFile78 } = await import("fs/promises");
+    const { writeFile: writeFile79 } = await import("fs/promises");
     const yamlContent = jsYaml.dump(parsed, {
       indent: 2,
       lineWidth: -1,
       noRefs: true
     });
-    await writeFile78(overrideFilePath, yamlContent, "utf-8");
+    await writeFile79(overrideFilePath, yamlContent, "utf-8");
     context2.logger.info(`Removed ${validationResult.invalidCount} invalid AI examples from ai_examples_override.yml`);
     return {
       removedCount: validationResult.invalidCount,
@@ -1632565,6 +1634658,17 @@ https://buildwithfern.com/learn/docs/getting-started/project-structure#api-defin
         context: this.taskContext,
         sourceResolver: new SourceResolverImpl(this.taskContext, workspace)
       });
+    } else if (Object.keys(snippetsConfig).length > 0) {
+      try {
+        workspace = await this.getFernWorkspaceForApiSection(item).toFernWorkspace({ context: this.taskContext }, {
+          enableUniqueErrorsPerEndpoint: true,
+          detectGlobalHeaders: false,
+          objectQueryParameters: true,
+          preserveSchemaIds: true
+        });
+      } catch (error49) {
+        this.taskContext.logger.debug(`Could not load workspace for dynamic snippets: ${error49}. Dynamic snippets may not be available.`);
+      }
     }
     if (this.docsWorkspace.config.settings?.substituteEnvVars) {
       ir14 = replaceEnvVariables(ir14, {
@@ -1652567,7 +1654671,7 @@ var AccessTokenPosthogManager = class {
         properties: {
           ...event,
           ...event.properties,
-          version: "3.54.0",
+          version: "3.55.0-1-g14779898708",
           usingAccessToken: true
         }
       });
@@ -1652617,7 +1654721,7 @@ var UserPosthogManager = class {
       distinctId: this.userId ?? await this.getPersistedDistinctId(),
       event: "CLI",
       properties: {
-        version: "3.54.0",
+        version: "3.55.0-1-g14779898708",
         ...event,
         ...event.properties,
         usingAccessToken: false,
@@ -1678170,12 +1680274,12 @@ var import_node_path20 = __toESM(require("path"), 1);
 
 // ../../../node_modules/.pnpm/@puppeteer+browsers@2.10.10/node_modules/@puppeteer/browsers/lib/esm/browser-data/types.js
 var Browser3;
-(function(Browser4) {
-  Browser4["CHROME"] = "chrome";
-  Browser4["CHROMEHEADLESSSHELL"] = "chrome-headless-shell";
-  Browser4["CHROMIUM"] = "chromium";
-  Browser4["FIREFOX"] = "firefox";
-  Browser4["CHROMEDRIVER"] = "chromedriver";
+(function(Browser5) {
+  Browser5["CHROME"] = "chrome";
+  Browser5["CHROMEHEADLESSSHELL"] = "chrome-headless-shell";
+  Browser5["CHROMIUM"] = "chromium";
+  Browser5["FIREFOX"] = "firefox";
+  Browser5["CHROMEDRIVER"] = "chromedriver";
 })(Browser3 || (Browser3 = {}));
 var BrowserPlatform;
 (function(BrowserPlatform2) {
@@ -1685759,7 +1687863,7 @@ var CliContext = class {
     if (false) {
       this.logger.error("CLI_VERSION is not defined");
     }
-    return "3.54.0";
+    return "3.55.0-1-g14779898708";
   }
   getCliName() {
     if (false) {
@@ -1688872,7 +1690976,7 @@ var import_path54 = __toESM(require("path"), 1);
 var LOCAL_STORAGE_FOLDER4 = ".fern-dev";
 var LOGS_FOLDER_NAME = "logs";
 function getCliSource() {
-  const version7 = "3.54.0";
+  const version7 = "3.55.0-1-g14779898708";
   return `cli@${version7}`;
 }
 var DebugLogger = class {
@@ -1704391,7 +1706495,7 @@ var MDX_NODE_TYPES = [
   "mdxTextExpression",
   "mdxjsEsm"
 ];
-function collectLinksAndSources({ readFile: readFile88 = (path86) => (0, import_node_fs27.readFileSync)(path86, "utf-8"), ...opts }) {
+function collectLinksAndSources({ readFile: readFile89 = (path86) => (0, import_node_fs27.readFileSync)(path86, "utf-8"), ...opts }) {
   const visitedAbsoluteFilepaths = /* @__PURE__ */ new Set();
   const contentQueue = [opts];
   const links = [];
@@ -1704429,7 +1706533,7 @@ function collectLinksAndSources({ readFile: readFile88 = (path86) => (0, import_
                 const resolvedImportPath = resolve5(dirname4(absoluteFilepath), importPath);
                 if (resolvedImportPath.endsWith(".mdx") || resolvedImportPath.endsWith(".md")) {
                   contentQueue.push({
-                    content: readFile88(resolvedImportPath),
+                    content: readFile89(resolvedImportPath),
                     absoluteFilepath: resolvedImportPath
                   });
                 }
@@ -1704472,7 +1706576,7 @@ function collectLinksAndSources({ readFile: readFile88 = (path86) => (0, import_
           if (absoluteFilepath && typeof src === "string") {
             const resolvedImportPath = resolve5(dirname4(absoluteFilepath), src);
             contentQueue.push({
-              content: readFile88(resolvedImportPath),
+              content: readFile89(resolvedImportPath),
               absoluteFilepath: resolvedImportPath
             });
           }
@@ -1705853,6 +1707957,395 @@ async function previewDocsWorkspace({
   return;
 }
 
+// src/commands/docs-diff/docsDiff.ts
+var import_promises110 = require("fs/promises");
+var import_pngjs = __toESM(require_png2(), 1);
+async function getSlugForFiles({
+  previewUrl,
+  files,
+  token
+}) {
+  const filesParam = files.join(",");
+  const url3 = `https://${previewUrl}/api/fern-docs/get-slug-for-file?files=${encodeURIComponent(filesParam)}`;
+  const response = await fetch(url3, {
+    method: "GET",
+    headers: {
+      FERN_TOKEN: token
+    }
+  });
+  if (!response.ok) {
+    const errorText = await response.text();
+    throw new Error(`Failed to get slugs for files: ${response.status} ${response.statusText} - ${errorText}`);
+  }
+  return await response.json();
+}
+async function captureScreenshot({
+  browser,
+  url: url3,
+  outputPath,
+  token
+}) {
+  const page = await browser.newPage();
+  try {
+    await page.setViewport({
+      width: 1440,
+      height: 900,
+      deviceScaleFactor: 2
+    });
+    if (token) {
+      await page.setExtraHTTPHeaders({
+        FERN_TOKEN: token
+      });
+    }
+    const response = await page.goto(url3, {
+      waitUntil: "networkidle2",
+      timeout: 3e4
+    });
+    if (!response || response.status() === 404) {
+      await page.close();
+      return false;
+    }
+    await page.screenshot({
+      path: outputPath,
+      fullPage: true
+    });
+    await page.close();
+    return true;
+  } catch (error49) {
+    await page.close();
+    return false;
+  }
+}
+function slugToFilename(slug) {
+  return slug.replace(/\//g, "-");
+}
+function findChangedRegions(beforeData, afterData, width, height3, threshold = 0.1, minArea = 5e3, gapRows = 200) {
+  const thresholdValue = Math.floor(threshold * 255);
+  const rowHasDiff = new Array(height3).fill(false);
+  for (let y24 = 0; y24 < height3; y24++) {
+    let has3 = false;
+    for (let x15 = 0; x15 < width; x15++) {
+      const idx = (y24 * width + x15) * 4;
+      const rDiff = Math.abs((beforeData[idx] ?? 0) - (afterData[idx] ?? 0));
+      const gDiff = Math.abs((beforeData[idx + 1] ?? 0) - (afterData[idx + 1] ?? 0));
+      const bDiff = Math.abs((beforeData[idx + 2] ?? 0) - (afterData[idx + 2] ?? 0));
+      if (rDiff > thresholdValue || gDiff > thresholdValue || bDiff > thresholdValue) {
+        has3 = true;
+        break;
+      }
+    }
+    rowHasDiff[y24] = has3;
+  }
+  const boxes = [];
+  let y23 = 0;
+  while (y23 < height3) {
+    while (y23 < height3 && !rowHasDiff[y23]) {
+      y23++;
+    }
+    if (y23 >= height3) {
+      break;
+    }
+    let startY = y23;
+    let lastDiffY = y23;
+    y23++;
+    while (y23 < height3) {
+      if (rowHasDiff[y23]) {
+        lastDiffY = y23;
+        y23++;
+      } else {
+        let gap = 0;
+        while (y23 < height3 && !rowHasDiff[y23] && gap < gapRows) {
+          gap++;
+          y23++;
+        }
+        if (y23 < height3 && rowHasDiff[y23]) {
+          lastDiffY = y23;
+          y23++;
+        } else {
+          break;
+        }
+      }
+    }
+    const endY = lastDiffY;
+    let minX = width;
+    let maxX = 0;
+    for (let yy = startY; yy <= endY; yy++) {
+      for (let xx = 0; xx < width; xx++) {
+        const idx = (yy * width + xx) * 4;
+        const rDiff = Math.abs((beforeData[idx] ?? 0) - (afterData[idx] ?? 0));
+        const gDiff = Math.abs((beforeData[idx + 1] ?? 0) - (afterData[idx + 1] ?? 0));
+        const bDiff = Math.abs((beforeData[idx + 2] ?? 0) - (afterData[idx + 2] ?? 0));
+        if (rDiff > thresholdValue || gDiff > thresholdValue || bDiff > thresholdValue) {
+          if (xx < minX) {
+            minX = xx;
+          }
+          if (xx > maxX) {
+            maxX = xx;
+          }
+        }
+      }
+    }
+    if (minX <= maxX) {
+      const box = { minX, minY: startY, maxX, maxY: endY };
+      const area = (box.maxX - box.minX) * (box.maxY - box.minY);
+      if (area >= minArea) {
+        boxes.push(box);
+      }
+    }
+  }
+  return boxes;
+}
+function cropPng(png, box, padding = 50) {
+  const x1 = Math.max(0, box.minX - padding);
+  const y1 = Math.max(0, box.minY - padding);
+  const x23 = Math.min(png.width, box.maxX + padding);
+  const y23 = Math.min(png.height, box.maxY + padding);
+  const croppedWidth = x23 - x1;
+  const croppedHeight = y23 - y1;
+  const cropped = new import_pngjs.PNG({ width: croppedWidth, height: croppedHeight });
+  import_pngjs.PNG.bitblt(png, cropped, x1, y1, croppedWidth, croppedHeight, 0, 0);
+  return cropped;
+}
+function drawBorder(png, x15, y23, w19, h14, color3, thickness) {
+  const [r23, g18, b18, a10] = color3;
+  for (let t2 = 0; t2 < thickness; t2++) {
+    for (let xx = x15; xx < x15 + w19; xx++) {
+      const topIdx = ((y23 + t2) * png.width + xx) * 4;
+      const botIdx = ((y23 + h14 - 1 - t2) * png.width + xx) * 4;
+      png.data[topIdx] = r23;
+      png.data[topIdx + 1] = g18;
+      png.data[topIdx + 2] = b18;
+      png.data[topIdx + 3] = a10;
+      png.data[botIdx] = r23;
+      png.data[botIdx + 1] = g18;
+      png.data[botIdx + 2] = b18;
+      png.data[botIdx + 3] = a10;
+    }
+    for (let yy = y23; yy < y23 + h14; yy++) {
+      const leftIdx = (yy * png.width + (x15 + t2)) * 4;
+      const rightIdx = (yy * png.width + (x15 + w19 - 1 - t2)) * 4;
+      png.data[leftIdx] = r23;
+      png.data[leftIdx + 1] = g18;
+      png.data[leftIdx + 2] = b18;
+      png.data[leftIdx + 3] = a10;
+      png.data[rightIdx] = r23;
+      png.data[rightIdx + 1] = g18;
+      png.data[rightIdx + 2] = b18;
+      png.data[rightIdx + 3] = a10;
+    }
+  }
+}
+function createSideBySideComparison(beforePng, afterPng, gap = 20, highlight = true) {
+  const totalWidth = beforePng.width + gap + afterPng.width;
+  const totalHeight = Math.max(beforePng.height, afterPng.height);
+  const combined = new import_pngjs.PNG({ width: totalWidth, height: totalHeight });
+  combined.data.fill(255);
+  import_pngjs.PNG.bitblt(beforePng, combined, 0, 0, beforePng.width, beforePng.height, 0, 0);
+  import_pngjs.PNG.bitblt(afterPng, combined, 0, 0, afterPng.width, afterPng.height, beforePng.width + gap, 0);
+  if (highlight) {
+    const color3 = [255, 196, 0, 255];
+    const thickness = 3;
+    drawBorder(combined, 0, 0, beforePng.width, beforePng.height, color3, thickness);
+    drawBorder(combined, beforePng.width + gap, 0, afterPng.width, afterPng.height, color3, thickness);
+  }
+  return combined;
+}
+async function generateComparisons({
+  beforePath,
+  afterPath,
+  comparisonBasePath
+}) {
+  const beforePng = import_pngjs.PNG.sync.read(await (0, import_promises110.readFile)(beforePath));
+  const afterPng = import_pngjs.PNG.sync.read(await (0, import_promises110.readFile)(afterPath));
+  const width = Math.max(beforePng.width, afterPng.width);
+  const height3 = Math.max(beforePng.height, afterPng.height);
+  const resizedBefore = new import_pngjs.PNG({ width, height: height3 });
+  const resizedAfter = new import_pngjs.PNG({ width, height: height3 });
+  resizedBefore.data.fill(255);
+  resizedAfter.data.fill(255);
+  import_pngjs.PNG.bitblt(beforePng, resizedBefore, 0, 0, beforePng.width, beforePng.height, 0, 0);
+  import_pngjs.PNG.bitblt(afterPng, resizedAfter, 0, 0, afterPng.width, afterPng.height, 0, 0);
+  const beforeData = new Uint8Array(
+    resizedBefore.data.buffer,
+    resizedBefore.data.byteOffset,
+    resizedBefore.data.length
+  );
+  const afterData = new Uint8Array(resizedAfter.data.buffer, resizedAfter.data.byteOffset, resizedAfter.data.length);
+  const regions = findChangedRegions(beforeData, afterData, width, height3);
+  const results = [];
+  if (regions.length === 0) {
+    return results;
+  }
+  const base4 = comparisonBasePath.endsWith(".png") ? comparisonBasePath.slice(0, comparisonBasePath.length - 4) : comparisonBasePath;
+  for (let i11 = 0; i11 < regions.length; i11++) {
+    const boundingBox = regions[i11];
+    if (boundingBox == null) {
+      continue;
+    }
+    const boxWidth = boundingBox.maxX - boundingBox.minX;
+    const boxHeight = boundingBox.maxY - boundingBox.minY;
+    const changedPixels = boxWidth * boxHeight;
+    const totalPixels = width * height3;
+    const changePercent = changedPixels / totalPixels * 100;
+    const croppedBefore = cropPng(resizedBefore, boundingBox);
+    const croppedAfter = cropPng(resizedAfter, boundingBox);
+    const sideBySide = createSideBySideComparison(croppedBefore, croppedAfter, 20, true);
+    const outPath = `${base4}-region-${i11 + 1}.png`;
+    const pngBuffer = import_pngjs.PNG.sync.write(sideBySide);
+    await (0, import_promises110.writeFile)(outPath, new Uint8Array(pngBuffer));
+    results.push({ changePercent, boundingBox, comparisonPath: outPath });
+  }
+  return results;
+}
+function getProductionUrl(docsConfig) {
+  if (docsConfig.instances == null || docsConfig.instances.length === 0) {
+    throw new Error("No docs instances configured in docs.yml");
+  }
+  const firstInstance = docsConfig.instances[0];
+  if (firstInstance == null) {
+    throw new Error("No docs instances configured in docs.yml");
+  }
+  const instanceUrl = firstInstance.url;
+  if (instanceUrl.startsWith("https://") || instanceUrl.startsWith("http://")) {
+    return instanceUrl;
+  }
+  return `https://${instanceUrl}`;
+}
+async function docsDiff({
+  cliContext,
+  project,
+  previewUrl,
+  files,
+  outputDir
+}) {
+  const docsWorkspace = project.docsWorkspaces;
+  if (docsWorkspace == null) {
+    cliContext.failAndThrow("No docs workspace found. Make sure you have a docs.yml file.");
+    return { diffs: [] };
+  }
+  const token = await cliContext.runTask(async (context2) => {
+    return askToLogin(context2);
+  });
+  if (token == null) {
+    cliContext.failAndThrow("Failed to authenticate. Please run 'fern login' first.");
+    return { diffs: [] };
+  }
+  const fernToken = process.env.FERN_TOKEN ?? token.value;
+  const productionBaseUrl = getProductionUrl(docsWorkspace.config);
+  let normalizedPreviewUrl = previewUrl;
+  if (normalizedPreviewUrl.startsWith("https://")) {
+    normalizedPreviewUrl = normalizedPreviewUrl.slice(8);
+  } else if (normalizedPreviewUrl.startsWith("http://")) {
+    normalizedPreviewUrl = normalizedPreviewUrl.slice(7);
+  }
+  const slashIndex = normalizedPreviewUrl.indexOf("/");
+  if (slashIndex !== -1) {
+    normalizedPreviewUrl = normalizedPreviewUrl.slice(0, slashIndex);
+  }
+  const slugResponse = await cliContext.runTask(async (context2) => {
+    context2.logger.info(`Resolving slugs for ${files.length} file(s)...`);
+    return getSlugForFiles({
+      previewUrl: normalizedPreviewUrl,
+      files,
+      token: fernToken
+    });
+  });
+  if (slugResponse.authed) {
+    cliContext.logger.warn(
+      "The docs require authentication. Screenshots may not capture the full content without proper auth."
+    );
+  }
+  const outputPath = AbsoluteFilePath2.of(
+    outputDir.startsWith("/") ? outputDir : join4(cwd(), RelativeFilePath2.of(outputDir))
+  );
+  if (!await doesPathExist(outputPath)) {
+    await (0, import_promises110.mkdir)(outputPath, { recursive: true });
+  }
+  const results = [];
+  await cliContext.runTask(async (context2) => {
+    context2.logger.info("Starting browser for screenshot capture...");
+    const browser = await launch3({
+      headless: true,
+      args: ["--ignore-certificate-errors", "--no-sandbox", "--disable-setuid-sandbox"]
+    });
+    try {
+      for (const mapping of slugResponse.mappings) {
+        if (mapping.slug == null) {
+          context2.logger.warn(`Could not find slug for file: ${mapping.filePath}`);
+          continue;
+        }
+        const slug = mapping.slug;
+        const filename = slugToFilename(slug);
+        const beforePath = join4(outputPath, RelativeFilePath2.of(`${filename}-before.png`));
+        const afterPath = join4(outputPath, RelativeFilePath2.of(`${filename}-after.png`));
+        const comparisonBasePath = join4(outputPath, RelativeFilePath2.of(`${filename}-comparison.png`));
+        const productionUrl = `${productionBaseUrl}/${slug}`;
+        const previewPageUrl = `https://${normalizedPreviewUrl}/${slug}`;
+        context2.logger.info(`Capturing screenshots for: ${slug}`);
+        const beforeExists = await captureScreenshot({
+          browser,
+          url: productionUrl,
+          outputPath: beforePath,
+          token: fernToken
+        });
+        const afterExists = await captureScreenshot({
+          browser,
+          url: previewPageUrl,
+          outputPath: afterPath,
+          token: fernToken
+        });
+        if (!afterExists) {
+          context2.logger.warn(`Could not capture preview page for: ${slug}`);
+          continue;
+        }
+        const isNewPage = !beforeExists;
+        if (beforeExists) {
+          const regions = await generateComparisons({
+            beforePath,
+            afterPath,
+            comparisonBasePath
+          });
+          if (regions.length === 0) {
+            context2.logger.info(`  No visual changes detected`);
+            results.push({
+              file: mapping.filePath,
+              slug,
+              comparison: null,
+              changePercent: 0,
+              isNewPage
+            });
+          } else {
+            regions.forEach((region, idx) => {
+              context2.logger.info(
+                `  Region ${idx + 1}: ${region.changePercent.toFixed(2)}% (split & cropped)`
+              );
+              results.push({
+                file: mapping.filePath,
+                slug,
+                comparison: region.comparisonPath,
+                changePercent: region.changePercent,
+                isNewPage
+              });
+            });
+          }
+        } else {
+          context2.logger.info(`  New page (no production version)`);
+          results.push({
+            file: mapping.filePath,
+            slug,
+            comparison: null,
+            changePercent: null,
+            isNewPage
+          });
+        }
+      }
+    } finally {
+      await browser.close();
+    }
+  });
+  return { diffs: results };
+}
+
 // src/commands/docs-preview/deleteDocsPreview.ts
 var PREVIEW_URL_PATTERN = /^[a-z0-9-]+-preview-[a-z0-9-]+\.docs\.buildwithfern\.com$/i;
 function isPreviewUrl(url3) {
@@ -1705958,7 +1708451,7 @@ Found ${previewDeployments.length} preview deployment(s):
 }
 
 // src/commands/downgrade/downgrade.ts
-var import_promises110 = require("fs/promises");
+var import_promises111 = require("fs/promises");
 
 // ../../../node_modules/.pnpm/immer@10.1.3/node_modules/immer/dist/immer.mjs
 var NOTHING = Symbol.for("immer-nothing");
@@ -1706647,12 +1709140,12 @@ async function downgrade({
   const newProjectConfig = produce(projectConfig.rawConfig, (draft) => {
     draft.version = targetVersion;
   });
-  await (0, import_promises110.writeFile)(projectConfig._absolutePath, ensureFinalNewline(JSON.stringify(newProjectConfig, void 0, 2)));
+  await (0, import_promises111.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_promises111 = require("fs/promises");
+var import_promises112 = require("fs/promises");
 
 // src/commands/export/converters/servicesConverter.ts
 var import_openapi_types3 = __toESM(require_dist10(), 1);
@@ -1707905,8 +1710398,8 @@ async function generateOpenAPIForWorkspaces({
           ir: ir14,
           mode: "openapi"
         });
-        await (0, import_promises111.mkdir)(dirname4(outputPath), { recursive: true });
-        await (0, import_promises111.writeFile)(
+        await (0, import_promises112.mkdir)(dirname4(outputPath), { recursive: true });
+        await (0, import_promises112.writeFile)(
           outputPath,
           outputPath.endsWith(".json") ? JSON.stringify(openapi, void 0, indent3) : jsYaml.dump(openapi, { indent: indent3 })
         );
@@ -1707945,10 +1710438,10 @@ var APPROVED_DIRECTORIES_FILENAME = "approved-output-directories";
 var LOCAL_STORAGE_FOLDER6 = ".fern-dev";
 
 // src/commands/generate/checkOutputDirectory.ts
-var import_promises114 = require("fs/promises");
+var import_promises115 = require("fs/promises");
 
 // src/persistence/output-directories/getOutputDirectories.ts
-var import_promises112 = require("fs/promises");
+var import_promises113 = require("fs/promises");
 
 // src/persistence/output-directories/getPathToOutputDirectoriesFile.ts
 var import_os9 = require("os");
@@ -1707967,17 +1710460,17 @@ async function getOutputDirectories() {
   if (!doesOutputDirectoriesFileExist) {
     return [];
   }
-  const outputDirectoriesFileContents = await (0, import_promises112.readFile)(pathToOutputDirectoriesFile, { encoding: "utf-8" });
+  const outputDirectoriesFileContents = await (0, import_promises113.readFile)(pathToOutputDirectoriesFile, { encoding: "utf-8" });
   const outputDirectories = JSON.parse(outputDirectoriesFileContents);
   return outputDirectories;
 }
 
 // src/persistence/output-directories/storeOutputDirectories.ts
-var import_promises113 = require("fs/promises");
+var import_promises114 = require("fs/promises");
 var import_path60 = __toESM(require("path"), 1);
 async function storeOutputDirectories(outputDirectories) {
-  await (0, import_promises113.mkdir)(import_path60.default.dirname(getPathToOutputDirectoriesFile()), { recursive: true });
-  await (0, import_promises113.writeFile)(getPathToOutputDirectoriesFile(), JSON.stringify(outputDirectories, null, 2));
+  await (0, import_promises114.mkdir)(import_path60.default.dirname(getPathToOutputDirectoriesFile()), { recursive: true });
+  await (0, import_promises114.writeFile)(getPathToOutputDirectoriesFile(), JSON.stringify(outputDirectories, null, 2));
 }
 
 // src/commands/generate/checkOutputDirectory.ts
@@ -1707999,7 +1710492,7 @@ async function checkOutputDirectory(outputPath, cliContext, force) {
       shouldProceed: true
     };
   }
-  const files = await (0, import_promises114.readdir)(outputPath);
+  const files = await (0, import_promises115.readdir)(outputPath);
   if (files.length === 0) {
     return {
       shouldProceed: true
@@ -1713741,14 +1716234,14 @@ async function validateGeneratorsYmlFile({ contents, allRuleVisitors, cliVersion
 }
 
 // ../workspace/oss-validator/lib/rules/no-duplicate-overrides/no-duplicate-overrides.js
-var import_promises115 = require("fs/promises");
+var import_promises116 = 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_promises115.readFile)(spec.absoluteFilepath)).toString();
+      const contents = (await (0, import_promises116.readFile)(spec.absoluteFilepath)).toString();
       if (contents.includes("openapi") || contents.includes("swagger")) {
         const openAPI = await loadOpenAPI({
           absolutePathToOpenAPI: spec.absoluteFilepath,
@@ -1714575,7 +1717068,7 @@ async function generateOpenAPIIrForWorkspaces({
 }
 
 // src/commands/generate-overrides/compareOpenAPISpecs.ts
-var import_promises116 = require("fs/promises");
+var import_promises117 = require("fs/promises");
 async function compareOpenAPISpecs({
   originalPath,
   modifiedPath,
@@ -1714612,12 +1717105,12 @@ async function compareOpenAPISpecs({
       }
       outputPath = join4(dirname4(originalPath), RelativeFilePath2.of(overridesFilename));
     }
-    await (0, import_promises116.writeFile)(outputPath, jsYaml.dump(overrides, { lineWidth: -1, noRefs: true }));
+    await (0, import_promises117.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_promises116.readFile)(filepath, "utf8");
+  const contents = await (0, import_promises117.readFile)(filepath, "utf8");
   try {
     return JSON.parse(contents);
   } catch {
@@ -1714718,7 +1717211,7 @@ function deepEqual(a10, b18) {
 }
 
 // src/commands/generate-overrides/writeOverridesForWorkspaces.ts
-var import_promises117 = require("fs/promises");
+var import_promises118 = require("fs/promises");
 async function writeOverridesForWorkspaces({
   project,
   includeModels,
@@ -1714743,7 +1717236,7 @@ async function writeOverridesForWorkspaces({
 async function readExistingOverrides(overridesFilepath, context2) {
   let parsedOverrides = null;
   try {
-    const contents = (await (0, import_promises117.readFile)(overridesFilepath, "utf8")).toString();
+    const contents = (await (0, import_promises118.readFile)(overridesFilepath, "utf8")).toString();
     try {
       parsedOverrides = JSON.parse(contents);
     } catch (err) {
@@ -1714807,7 +1717300,7 @@ async function writeDefinitionForOpenAPIWorkspace({
         overridesFilename = `${nameWithoutExt}-overrides${extension3}`;
       }
     }
-    await (0, import_promises117.writeFile)(
+    await (0, import_promises118.writeFile)(
       join4(dirname4(spec.absoluteFilepath), RelativeFilePath2.of(overridesFilename)),
       jsYaml.dump({ paths, components })
     );
@@ -1715172,7 +1717665,7 @@ function convertIRtoJsonSchema(args) {
 }
 
 // src/commands/jsonschema/generateJsonschemaForWorkspace.ts
-var import_promises118 = require("fs/promises");
+var import_promises119 = require("fs/promises");
 async function generateJsonschemaForWorkspaces({
   typeLocator,
   project,
@@ -1715220,9 +1717713,9 @@ async function generateJsonschemaForWorkspaces({
           context: context2
         });
         if (!await doesPathExist(dirname4(jsonschemaFilepath))) {
-          await (0, import_promises118.mkdir)(dirname4(jsonschemaFilepath), { recursive: true });
+          await (0, import_promises119.mkdir)(dirname4(jsonschemaFilepath), { recursive: true });
         }
-        await (0, import_promises118.writeFile)(jsonschemaFilepath, JSON.stringify(jsonSchema, null, 2));
+        await (0, import_promises119.writeFile)(jsonschemaFilepath, JSON.stringify(jsonSchema, null, 2));
         context2.logger.info(source_default2.green(`Wrote JSON Schema to ${jsonschemaFilepath}`));
       });
     })
@@ -1715579,7 +1718072,7 @@ async function mockServer({
 
 // src/commands/register/registerWorkspacesV1.ts
 var import_fiddle_sdk8 = __toESM(require_fiddle_sdk(), 1);
-var import_promises119 = require("fs/promises");
+var import_promises120 = require("fs/promises");
 var import_path68 = __toESM(require("path"), 1);
 var import_tmp_promise17 = __toESM(require_tmp_promise(), 1);
 async function registerWorkspacesV1({
@@ -1715628,7 +1718121,7 @@ async function registerWorkspacesV1({
         context2.logger.debug(`Compressing definition at ${tmpDir.path}`);
         await create2({ file: tarPath, cwd: resolvedWorkspace.absoluteFilePath }, ["."]);
         context2.logger.info("Uploading definition...");
-        await axios_default.put(registerApiResponse.body.definitionS3UploadUrl, await (0, import_promises119.readFile)(tarPath));
+        await axios_default.put(registerApiResponse.body.definitionS3UploadUrl, await (0, import_promises120.readFile)(tarPath));
         context2.logger.info(
           `Registered @${project.config.organization}/${resolvedWorkspace.definition.rootApiFile.contents.name}:${registerApiResponse.body.version}`
         );
@@ -1715766,7 +1718259,7 @@ async function generateDiff({
 }
 
 // src/commands/self-update/selfUpdate.ts
-var import_promises120 = require("fs/promises");
+var import_promises121 = require("fs/promises");
 var import_path69 = require("path");
 async function getPackageManagerBinDir(logger, pm) {
   let command3;
@@ -1715812,7 +1718305,7 @@ async function detectInstallationMethod(logger) {
   logger.debug(`Found fern at: ${fernPath}`);
   let resolvedPath;
   try {
-    resolvedPath = await (0, import_promises120.realpath)(fernPath);
+    resolvedPath = await (0, import_promises121.realpath)(fernPath);
     logger.debug(`Resolved to: ${resolvedPath}`);
   } catch (error49) {
     logger.debug(`Failed to resolve symlink: ${error49}`);
@@ -1716093,20 +1718586,20 @@ async function generateToken({
 
 // src/commands/upgrade/updateApiSpec.ts
 var fs32 = __toESM(require("fs"), 1);
-var import_promises121 = require("fs/promises");
+var import_promises122 = require("fs/promises");
 var import_stream9 = require("stream");
-var import_promises122 = require("stream/promises");
+var import_promises123 = require("stream/promises");
 async function fetchAndWriteFile(url3, path86, logger, indent3) {
   const resp = await fetch(url3);
   if (resp.ok && resp.body) {
     logger.debug("Origin successfully fetched, writing to file");
     const fileStream = fs32.createWriteStream(path86);
-    await (0, import_promises122.finished)(import_stream9.Readable.fromWeb(resp.body).pipe(fileStream));
-    const fileContents = await (0, import_promises121.readFile)(path86, "utf8");
+    await (0, import_promises123.finished)(import_stream9.Readable.fromWeb(resp.body).pipe(fileStream));
+    const fileContents = await (0, import_promises122.readFile)(path86, "utf8");
     try {
-      await (0, import_promises121.writeFile)(path86, JSON.stringify(JSON.parse(fileContents), void 0, indent3), "utf8");
+      await (0, import_promises122.writeFile)(path86, JSON.stringify(JSON.parse(fileContents), void 0, indent3), "utf8");
     } catch (e6) {
-      await (0, import_promises121.writeFile)(path86, jsYaml.dump(jsYaml.load(fileContents), { indent: indent3 }), "utf8");
+      await (0, import_promises122.writeFile)(path86, jsYaml.dump(jsYaml.load(fileContents), { indent: indent3 }), "utf8");
     }
     logger.debug("File written successfully");
   }
@@ -1716202,7 +1718695,7 @@ async function processDefinitions({
 }
 
 // ../cli-migrations/lib/migrations/0.0.191/discriminant/migration.js
-var import_promises123 = require("fs/promises");
+var import_promises124 = require("fs/promises");
 
 // ../cli-migrations/lib/migrations/0.0.191/discriminant/getAllYamlFiles.js
 var FERN_DIRECTORY2 = "fern";
@@ -1716236,7 +1718729,7 @@ var migration = {
       try {
         const fileContents = await getFileContents(yamlFilepath);
         const newContents = addDiscriminantToFile(fileContents);
-        await (0, import_promises123.writeFile)(yamlFilepath, newContents);
+        await (0, import_promises124.writeFile)(yamlFilepath, newContents);
       } catch (error49) {
         context2.failAndThrow("Failed to migrate " + yamlFilepath, error49);
       }
@@ -1716244,7 +1718737,7 @@ var migration = {
   }
 };
 async function getFileContents(filepath) {
-  const buffer = await (0, import_promises123.readFile)(filepath);
+  const buffer = await (0, import_promises124.readFile)(filepath);
   return buffer.toString();
 }
 var UNION_REGEX = /^(\s{2,})union:\s*$/gm;
@@ -1716273,7 +1718766,7 @@ var versionMigrations = {
 var __default = versionMigrations;
 
 // ../cli-migrations/lib/migrations/0.0.203/union-single-property-key/migration.js
-var import_promises124 = require("fs/promises");
+var import_promises125 = require("fs/promises");
 var import_yaml6 = __toESM(require_dist2(), 1);
 
 // ../cli-migrations/lib/migrations/0.0.203/union-single-property-key/getAllYamlFiles.js
@@ -1716314,7 +1718807,7 @@ var migration2 = {
   }
 };
 async function migrateFile(filepath, context2) {
-  const contents = await (0, import_promises124.readFile)(filepath);
+  const contents = await (0, import_promises125.readFile)(filepath);
   const parsedDocument = import_yaml6.default.parseDocument(contents.toString());
   const types4 = parsedDocument.get("types");
   if (types4 == null) {
@@ -1716346,7 +1718839,7 @@ async function migrateFile(filepath, context2) {
       }
     }
   }
-  await (0, import_promises124.writeFile)(filepath, parsedDocument.toString());
+  await (0, import_promises125.writeFile)(filepath, parsedDocument.toString());
 }
 
 // ../cli-migrations/lib/migrations/0.0.203/index.js
@@ -1716357,7 +1718850,7 @@ var versionMigrations2 = {
 var __default2 = versionMigrations2;
 
 // ../cli-migrations/lib/migrations/0.0.207/add-mode-to-draft-generators/migration.js
-var import_promises125 = require("fs/promises");
+var import_promises126 = require("fs/promises");
 var import_yaml7 = __toESM(require_dist2(), 1);
 
 // ../cli-migrations/lib/migrations/0.0.207/add-mode-to-draft-generators/getAllGeneratorYamlFiles.js
@@ -1716398,7 +1718891,7 @@ var migration3 = {
   }
 };
 async function migrateGeneratorsYml(filepath, context2) {
-  const contents = await (0, import_promises125.readFile)(filepath);
+  const contents = await (0, import_promises126.readFile)(filepath);
   const parsedDocument = import_yaml7.default.parseDocument(contents.toString());
   const draftGenerators = parsedDocument.get("draft");
   if (draftGenerators == null) {
@@ -1716425,7 +1718918,7 @@ async function migrateGeneratorsYml(filepath, context2) {
       draftGenerator.set("output-path", name3.value.includes("openapi") ? "./generated-openapi" : name3.value.includes("postman") ? "./generated-postman" : localOutput);
     }
   });
-  await (0, import_promises125.writeFile)(filepath, parsedDocument.toString());
+  await (0, import_promises126.writeFile)(filepath, parsedDocument.toString());
 }
 
 // ../cli-migrations/lib/migrations/0.0.207/index.js
@@ -1716436,7 +1718929,7 @@ var versionMigrations3 = {
 var __default3 = versionMigrations3;
 
 // ../cli-migrations/lib/migrations/0.0.210/remove-inline-error-declarations/migration.js
-var import_promises126 = require("fs/promises");
+var import_promises127 = require("fs/promises");
 var import_yaml8 = __toESM(require_dist2(), 1);
 
 // ../cli-migrations/lib/migrations/0.0.210/remove-inline-error-declarations/getAllYamlFiles.js
@@ -1716477,7 +1718970,7 @@ var migration4 = {
   }
 };
 async function migrateFile2(filepath, context2) {
-  const contents = await (0, import_promises126.readFile)(filepath);
+  const contents = await (0, import_promises127.readFile)(filepath);
   const parsedDocument = import_yaml8.default.parseDocument(contents.toString());
   const addType = (typeName, typeDeclaration2) => {
     const types4 = parsedDocument.get("types");
@@ -1716521,7 +1719014,7 @@ async function migrateFile2(filepath, context2) {
       }
     }
   }
-  await (0, import_promises126.writeFile)(filepath, parsedDocument.toString());
+  await (0, import_promises127.writeFile)(filepath, parsedDocument.toString());
 }
 
 // ../cli-migrations/lib/migrations/0.0.210/index.js
@@ -1716532,7 +1719025,7 @@ var versionMigrations4 = {
 var __default4 = versionMigrations4;
 
 // ../cli-migrations/lib/migrations/0.0.212/add-publishing-to-release-generators/migration.js
-var import_promises127 = require("fs/promises");
+var import_promises128 = require("fs/promises");
 var import_yaml9 = __toESM(require_dist2(), 1);
 
 // ../cli-migrations/lib/migrations/0.0.212/add-publishing-to-release-generators/getAllGeneratorYamlFiles.js
@@ -1716573,7 +1719066,7 @@ var migration5 = {
   }
 };
 async function migrateGeneratorsYml2(filepath, context2) {
-  const contents = await (0, import_promises127.readFile)(filepath);
+  const contents = await (0, import_promises128.readFile)(filepath);
   const parsedDocument = import_yaml9.default.parseDocument(contents.toString());
   const releaseGenerators = parsedDocument.get("release");
   if (releaseGenerators == null) {
@@ -1716611,7 +1719104,7 @@ async function migrateGeneratorsYml2(filepath, context2) {
     }
     releaseGenerator.delete("outputs");
   });
-  await (0, import_promises127.writeFile)(filepath, parsedDocument.toString());
+  await (0, import_promises128.writeFile)(filepath, parsedDocument.toString());
 }
 
 // ../cli-migrations/lib/migrations/0.0.212/index.js
@@ -1716622,7 +1719115,7 @@ var versionMigrations5 = {
 var __default5 = versionMigrations5;
 
 // ../cli-migrations/lib/migrations/0.0.220/rename-alias-key-to-type/migration.js
-var import_promises128 = require("fs/promises");
+var import_promises129 = require("fs/promises");
 
 // ../cli-migrations/lib/migrations/0.0.220/rename-alias-key-to-type/getAllYamlFiles.js
 var FERN_DIRECTORY7 = "fern";
@@ -1716653,9 +1719146,9 @@ var migration6 = {
   run: async ({ context: context2 }) => {
     const yamlFiles = await getAllYamlFiles4(context2);
     for (const filepath of yamlFiles) {
-      const contents = await (0, import_promises128.readFile)(filepath);
+      const contents = await (0, import_promises129.readFile)(filepath);
       const newContents = contents.toString().replaceAll(" alias:", " type:");
-      await (0, import_promises128.writeFile)(filepath, newContents);
+      await (0, import_promises129.writeFile)(filepath, newContents);
     }
   }
 };
@@ -1716668,7 +1719161,7 @@ var versionMigrations6 = {
 var __default6 = versionMigrations6;
 
 // ../cli-migrations/lib/migrations/0.0.221/add-error-discriminant/migration.js
-var import_promises129 = require("fs/promises");
+var import_promises130 = require("fs/promises");
 
 // ../cli-migrations/lib/migrations/0.0.221/add-error-discriminant/getAllRootApiYamlFiles.js
 var FERN_DIRECTORY8 = "fern";
@@ -1716699,9 +1719192,9 @@ var migration7 = {
   run: async ({ context: context2 }) => {
     const yamlFiles = await getAllRootApiYamlFiles(context2);
     for (const filepath of yamlFiles) {
-      const contents = await (0, import_promises129.readFile)(filepath);
+      const contents = await (0, import_promises130.readFile)(filepath);
       const newContents = contents.toString() + "\nerror-discriminant: error";
-      await (0, import_promises129.writeFile)(filepath, newContents);
+      await (0, import_promises130.writeFile)(filepath, newContents);
     }
   }
 };
@@ -1716714,7 +1719207,7 @@ var versionMigrations7 = {
 var __default7 = versionMigrations7;
 
 // ../cli-migrations/lib/migrations/0.0.241/add-generator-groups/migration.js
-var import_promises130 = require("fs/promises");
+var import_promises131 = require("fs/promises");
 
 // ../cli-migrations/lib/migrations/0.0.241/add-generator-groups/getAllGeneratorYamlFiles.js
 var FERN_DIRECTORY9 = "fern";
@@ -1716821,7 +1719314,7 @@ var migration8 = {
   }
 };
 async function migrateGeneratorsYml3(filepath) {
-  const contentsStr = await (0, import_promises130.readFile)(filepath);
+  const contentsStr = await (0, import_promises131.readFile)(filepath);
   const contents = jsYaml.load(contentsStr.toString());
   const oldGeneratorsConfiguration = GeneratorsConfigurationSchema2.parse(contents);
   let newGeneratorsConfiguration = {};
@@ -1716839,7 +1719332,7 @@ async function migrateGeneratorsYml3(filepath) {
       generators: oldGeneratorsConfiguration.release.map((releaseGeneratorInvocation) => convertReleaseGeneratorInvocation(releaseGeneratorInvocation))
     };
   }
-  await (0, import_promises130.writeFile)(filepath, jsYaml.dump(newGeneratorsConfiguration));
+  await (0, import_promises131.writeFile)(filepath, jsYaml.dump(newGeneratorsConfiguration));
 }
 function convertDraftGeneratorInvocation(draftGeneratorInvocation) {
   const newSchema = {
@@ -1716914,7 +1719407,7 @@ var versionMigrations8 = {
 var __default8 = versionMigrations8;
 
 // ../cli-migrations/lib/migrations/0.0.248/add-error-discrimination-config/migration.js
-var import_promises131 = require("fs/promises");
+var import_promises132 = require("fs/promises");
 var import_yaml10 = __toESM(require_dist2(), 1);
 
 // ../cli-migrations/lib/migrations/0.0.248/add-error-discrimination-config/getAllRootApiYamlFiles.js
@@ -1716955,7 +1719448,7 @@ var migration9 = {
   }
 };
 async function migrateRootApiFile(filepath) {
-  const contents = await (0, import_promises131.readFile)(filepath);
+  const contents = await (0, import_promises132.readFile)(filepath);
   const parsedDocument = import_yaml10.default.parseDocument(contents.toString());
   const errorDiscriminant = parsedDocument.get("error-discriminant", true);
   if (errorDiscriminant == null || !import_yaml10.default.isScalar(errorDiscriminant) || typeof errorDiscriminant.value !== "string") {
@@ -1716966,7 +1719459,7 @@ async function migrateRootApiFile(filepath) {
     "property-name": errorDiscriminant.value
   });
   parsedDocument.delete("error-discriminant");
-  await (0, import_promises131.writeFile)(filepath, parsedDocument.toString());
+  await (0, import_promises132.writeFile)(filepath, parsedDocument.toString());
 }
 
 // ../cli-migrations/lib/migrations/0.0.248/index.js
@@ -1716977,7 +1719470,7 @@ var versionMigrations9 = {
 var __default9 = versionMigrations9;
 
 // ../cli-migrations/lib/migrations/0.1.3-rc3/add-inline-requests/migration.js
-var import_promises132 = require("fs/promises");
+var import_promises133 = require("fs/promises");
 var import_yaml11 = __toESM(require_dist2(), 1);
 
 // ../cli-migrations/lib/migrations/0.1.3-rc3/add-inline-requests/getAllYamlFiles.js
@@ -1717018,7 +1719511,7 @@ var migration10 = {
   }
 };
 async function migrateYamlFile(filepath, context2) {
-  const contents = await (0, import_promises132.readFile)(filepath);
+  const contents = await (0, import_promises133.readFile)(filepath);
   const parsedDocument = import_yaml11.default.parseDocument(contents.toString());
   const services = parsedDocument.get("services");
   if (services == null) {
@@ -1717058,7 +1719551,7 @@ async function migrateYamlFile(filepath, context2) {
         context2.failWithoutThrowing("Failed to convert endpoint", e6);
       }
     }
-    await (0, import_promises132.writeFile)(filepath, parsedDocument.toString());
+    await (0, import_promises133.writeFile)(filepath, parsedDocument.toString());
   }
 }
 function convertEndpoint21({ document: document4, endpoint: endpoint3 }) {
@@ -1717137,7 +1719630,7 @@ var versionMigrations10 = {
 var __default10 = versionMigrations10;
 
 // ../cli-migrations/lib/migrations/0.3.0-rc12/add-value-key-to-type-examples/migration.js
-var import_promises133 = require("fs/promises");
+var import_promises134 = require("fs/promises");
 var import_yaml12 = __toESM(require_dist2(), 1);
 
 // ../cli-migrations/lib/migrations/0.3.0-rc12/add-value-key-to-type-examples/getAllYamlFiles.js
@@ -1717178,7 +1719671,7 @@ var migration11 = {
   }
 };
 async function migrateYamlFile2(filepath, context2) {
-  const contents = await (0, import_promises133.readFile)(filepath);
+  const contents = await (0, import_promises134.readFile)(filepath);
   const parsedDocument = import_yaml12.default.parseDocument(contents.toString());
   const types4 = parsedDocument.get("types");
   if (types4 == null) {
@@ -1717204,7 +1719697,7 @@ async function migrateYamlFile2(filepath, context2) {
       examples.set(i11, { value });
     }
   }
-  await (0, import_promises133.writeFile)(filepath, parsedDocument.toString());
+  await (0, import_promises134.writeFile)(filepath, parsedDocument.toString());
 }
 
 // ../cli-migrations/lib/migrations/0.3.0-rc12/index.js
@@ -1717215,7 +1719708,7 @@ var versionMigrations11 = {
 var __default11 = versionMigrations11;
 
 // ../cli-migrations/lib/migrations/0.3.23/change-services-key-to-service/migration.js
-var import_promises134 = require("fs/promises");
+var import_promises135 = require("fs/promises");
 var import_yaml13 = __toESM(require_dist2(), 1);
 
 // ../cli-migrations/lib/migrations/0.3.23/change-services-key-to-service/getAllYamlFiles.js
@@ -1717256,7 +1719749,7 @@ var migration12 = {
   }
 };
 async function migrateYamlFile3(filepath, context2) {
-  const contents = await (0, import_promises134.readFile)(filepath);
+  const contents = await (0, import_promises135.readFile)(filepath);
   const parsedDocument = import_yaml13.default.parseDocument(contents.toString());
   if (!import_yaml13.default.isMap(parsedDocument.contents)) {
     return context2.failAndThrow("File is not a map");
@@ -1717286,7 +1719779,7 @@ async function migrateYamlFile3(filepath, context2) {
       pair.value = firstService.value;
     }
   }
-  await (0, import_promises134.writeFile)(filepath, parsedDocument.toString());
+  await (0, import_promises135.writeFile)(filepath, parsedDocument.toString());
 }
 
 // ../cli-migrations/lib/migrations/0.3.23/index.js
@@ -1717297,7 +1719790,7 @@ var versionMigrations12 = {
 var __default12 = versionMigrations12;
 
 // ../cli-migrations/lib/migrations/0.5.4/move-service-docs-to-top-level/migration.js
-var import_promises135 = require("fs/promises");
+var import_promises136 = require("fs/promises");
 var import_yaml14 = __toESM(require_dist2(), 1);
 
 // ../cli-migrations/lib/migrations/0.5.4/move-service-docs-to-top-level/getAllYamlFiles.js
@@ -1717338,7 +1719831,7 @@ var migration13 = {
   }
 };
 async function migrateYamlFile4(filepath, context2) {
-  const contents = await (0, import_promises135.readFile)(filepath);
+  const contents = await (0, import_promises136.readFile)(filepath);
   const parsedDocument = import_yaml14.default.parseDocument(contents.toString());
   if (!import_yaml14.default.isMap(parsedDocument.contents)) {
     return context2.failAndThrow("File is not a map");
@@ -1717357,7 +1719850,7 @@ async function migrateYamlFile4(filepath, context2) {
   }
   service.items.splice(indexOfServiceDocsPair, 1);
   parsedDocument.contents.items.unshift(docsPair);
-  await (0, import_promises135.writeFile)(filepath, parsedDocument.toString());
+  await (0, import_promises136.writeFile)(filepath, parsedDocument.toString());
 }
 
 // ../cli-migrations/lib/migrations/0.5.4/index.js
@@ -1717368,7 +1719861,7 @@ var versionMigrations13 = {
 var __default13 = versionMigrations13;
 
 // ../cli-migrations/lib/migrations/0.9.10/add-suffix-to-docs-domain/migration.js
-var import_promises136 = require("fs/promises");
+var import_promises137 = require("fs/promises");
 
 // ../cli-migrations/lib/migrations/0.9.10/add-suffix-to-docs-domain/getAllGeneratorYamlFiles.js
 var FERN_DIRECTORY15 = "fern";
@@ -1717408,14 +1719901,14 @@ var migration14 = {
   }
 };
 async function migrateYamlFile5(filepath) {
-  const contents = await (0, import_promises136.readFile)(filepath);
+  const contents = await (0, import_promises137.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, domain3) => {
     return `docs:
       domain: "${domain3}.${domainSuffix}"`;
   });
-  await (0, import_promises136.writeFile)(filepath, updatedSnapshot.toString());
+  await (0, import_promises137.writeFile)(filepath, updatedSnapshot.toString());
 }
 
 // ../cli-migrations/lib/migrations/0.9.10/index.js
@@ -1717431,10 +1719924,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_promises137 = require("fs/promises");
+var import_promises138 = require("fs/promises");
 async function loadRawDocsConfiguration2({ absolutePathToWorkspace }) {
   const filepath = getAbsolutePathToDocsYaml({ absolutePathToWorkspace });
-  const contentsStr = await (0, import_promises137.readFile)(filepath);
+  const contentsStr = await (0, import_promises138.readFile)(filepath);
   const contentsParsed = jsYaml.load(contentsStr.toString());
   const result = await LegacyDocsSerializers.DocsConfiguration.parse(contentsParsed);
   if (result.ok) {
@@ -1717452,7 +1719945,7 @@ function getAbsolutePathToDocsFolder({ absolutePathToWorkspace }) {
 }
 
 // ../cli-migrations/lib/migrations/0.15.0-rc0/update-directory-structure/migrateDocsAndMultipleAPIs.js
-var import_promises139 = require("fs/promises");
+var import_promises140 = require("fs/promises");
 
 // ../cli-migrations/lib/migrations/0.15.0-rc0/update-directory-structure/docs-config/convertLegacyDocsConfig.js
 function convertLegacyDocsConfig({ docsConfiguration, docsURLs, apiName }) {
@@ -1717630,10 +1720123,10 @@ __export(legacy_exports, {
 });
 
 // ../cli-migrations/lib/migrations/0.15.0-rc0/update-directory-structure/generators-configuration/loadRawGeneratorsConfiguration.js
-var import_promises138 = require("fs/promises");
+var import_promises139 = require("fs/promises");
 async function loadRawGeneratorsConfiguration2({ absolutePathToWorkspace }) {
   const filepath = getAbsolutePathToGeneratorsConfiguration({ absolutePathToWorkspace });
-  const contentsStr = await (0, import_promises138.readFile)(filepath);
+  const contentsStr = await (0, import_promises139.readFile)(filepath);
   const contentsParsed = jsYaml.load(contentsStr.toString());
   const result = await legacy_exports.GeneratorsConfigurationSchema.safeParseAsync(contentsParsed);
   if (result.success) {
@@ -1717663,7 +1720156,7 @@ function migrateDocsInstances(docsURLs) {
 var APIS_DIRECTORY2 = "apis";
 async function migrateDocsAndMultipleAPIs({ absolutePathToFernDirectory, workspaces, workspaceContainingDocs }) {
   const absolutePathToApisDirectory = join4(absolutePathToFernDirectory, RelativeFilePath2.of(APIS_DIRECTORY2));
-  await (0, import_promises139.mkdir)(absolutePathToApisDirectory);
+  await (0, import_promises140.mkdir)(absolutePathToApisDirectory);
   for (const workspace of workspaces) {
     const absolutePathToWorkspace = join4(absolutePathToFernDirectory, RelativeFilePath2.of(workspace));
     const docsURLs = await migrateAndWriteGeneratorsYml({ absolutePathToWorkspace });
@@ -1717671,11 +1720164,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_promises139.rm)(absolutePathToDocsFolder, { recursive: true });
+      await (0, import_promises140.rm)(absolutePathToDocsFolder, { recursive: true });
     }
     const absolutePathToNestedWorkspace = join4(absolutePathToApisDirectory, RelativeFilePath2.of(workspace));
     await moveFolder({ src: absolutePathToWorkspace, dest: absolutePathToNestedWorkspace });
-    await (0, import_promises139.rm)(absolutePathToWorkspace, { recursive: true });
+    await (0, import_promises140.rm)(absolutePathToWorkspace, { recursive: true });
   }
 }
 async function migrateAndWriteGeneratorsYml({ absolutePathToWorkspace }) {
@@ -1717688,7 +1720181,7 @@ async function migrateAndWriteGeneratorsYml({ absolutePathToWorkspace }) {
     generatorsConfiguration,
     pathModificationStrategy: PathModificationStrategy.Nest
   });
-  await (0, import_promises139.writeFile)(absolutePathToGeneratorsConfiguration, jsYaml.dump(convertedResponse.value));
+  await (0, import_promises140.writeFile)(absolutePathToGeneratorsConfiguration, jsYaml.dump(convertedResponse.value));
   return convertedResponse.docsURLs;
 }
 async function migrateAndWriteDocsYml({ absolutePathToWorkspace, docsURLs, apiName }) {
@@ -1717702,19 +1720195,19 @@ async function migrateAndWriteDocsYml({ absolutePathToWorkspace, docsURLs, apiNa
     apiName
   });
   const absolutePathToDocsConfig = getAbsolutePathToDocsYaml({ absolutePathToWorkspace });
-  await (0, import_promises139.writeFile)(absolutePathToDocsConfig, jsYaml.dump(convertedDocsConfig));
+  await (0, import_promises140.writeFile)(absolutePathToDocsConfig, jsYaml.dump(convertedDocsConfig));
 }
 
 // ../cli-migrations/lib/migrations/0.15.0-rc0/update-directory-structure/migrateDocsAndSingleAPI.js
-var import_promises140 = require("fs/promises");
+var import_promises141 = 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_promises140.rm)(absolutePathToDocsFolder, { recursive: true });
-  await (0, import_promises140.rm)(absolutePathToWorkspace, { recursive: true });
+  await (0, import_promises141.rm)(absolutePathToDocsFolder, { recursive: true });
+  await (0, import_promises141.rm)(absolutePathToWorkspace, { recursive: true });
 }
 async function migrateAndWriteDocsYml2({ absolutePathToWorkspace, docsURLs }) {
   const docsConfiguration = await loadRawDocsConfiguration2({ absolutePathToWorkspace });
@@ -1717727,7 +1720220,7 @@ async function migrateAndWriteDocsYml2({ absolutePathToWorkspace, docsURLs }) {
     apiName: void 0
   });
   const absolutePathToDocsConfig = getAbsolutePathToDocsYaml({ absolutePathToWorkspace });
-  await (0, import_promises140.writeFile)(absolutePathToDocsConfig, jsYaml.dump(convertedDocsConfig));
+  await (0, import_promises141.writeFile)(absolutePathToDocsConfig, jsYaml.dump(convertedDocsConfig));
 }
 async function migrateAndWriteGeneratorsYml2({ absolutePathToWorkspace }) {
   const generatorsConfiguration = await loadRawGeneratorsConfiguration2({ absolutePathToWorkspace });
@@ -1717739,22 +1720232,22 @@ async function migrateAndWriteGeneratorsYml2({ absolutePathToWorkspace }) {
     generatorsConfiguration,
     pathModificationStrategy: "MoveUp"
   });
-  await (0, import_promises140.writeFile)(absolutePathToGeneratorsConfiguration, jsYaml.dump(convertedResponse.value));
+  await (0, import_promises141.writeFile)(absolutePathToGeneratorsConfiguration, jsYaml.dump(convertedResponse.value));
   return convertedResponse.docsURLs;
 }
 
 // ../cli-migrations/lib/migrations/0.15.0-rc0/update-directory-structure/migrateOnlyMultipleAPIs.js
-var import_promises141 = require("fs/promises");
+var import_promises142 = require("fs/promises");
 var APIS_DIRECTORY3 = "apis";
 async function migrateOnlyMultipleAPIs({ absolutePathToFernDirectory, workspaces }) {
   const absolutePathToApisDirectory = join4(absolutePathToFernDirectory, RelativeFilePath2.of(APIS_DIRECTORY3));
-  await (0, import_promises141.mkdir)(absolutePathToApisDirectory);
+  await (0, import_promises142.mkdir)(absolutePathToApisDirectory);
   for (const workspace of workspaces) {
     const absolutePathToWorkspace = join4(absolutePathToFernDirectory, RelativeFilePath2.of(workspace));
     await migrateAndWriteGeneratorsYml3({ absolutePathToWorkspace });
     const absolutePathToNestedWorkspace = join4(absolutePathToApisDirectory, RelativeFilePath2.of(workspace));
     await moveFolder({ src: absolutePathToWorkspace, dest: absolutePathToNestedWorkspace });
-    await (0, import_promises141.rm)(absolutePathToWorkspace, { recursive: true });
+    await (0, import_promises142.rm)(absolutePathToWorkspace, { recursive: true });
   }
 }
 async function migrateAndWriteGeneratorsYml3({ absolutePathToWorkspace }) {
@@ -1717767,15 +1720260,15 @@ async function migrateAndWriteGeneratorsYml3({ absolutePathToWorkspace }) {
     generatorsConfiguration,
     pathModificationStrategy: PathModificationStrategy.Nest
   });
-  await (0, import_promises141.writeFile)(absolutePathToGeneratorsConfiguration, jsYaml.dump(convertedResponse.value));
+  await (0, import_promises142.writeFile)(absolutePathToGeneratorsConfiguration, jsYaml.dump(convertedResponse.value));
 }
 
 // ../cli-migrations/lib/migrations/0.15.0-rc0/update-directory-structure/migrateOnlySingleAPI.js
-var import_promises142 = require("fs/promises");
+var import_promises143 = require("fs/promises");
 async function migrateOnlySingleAPI({ absolutePathToFernDirectory, absolutePathToWorkspace }) {
   await migrateAndWriteGeneratorsYml4({ absolutePathToWorkspace });
   await moveFolder({ src: absolutePathToWorkspace, dest: absolutePathToFernDirectory });
-  await (0, import_promises142.rm)(absolutePathToWorkspace, { recursive: true });
+  await (0, import_promises143.rm)(absolutePathToWorkspace, { recursive: true });
 }
 async function migrateAndWriteGeneratorsYml4({ absolutePathToWorkspace }) {
   const generatorsConfiguration = await loadRawGeneratorsConfiguration2({ absolutePathToWorkspace });
@@ -1717787,7 +1720280,7 @@ async function migrateAndWriteGeneratorsYml4({ absolutePathToWorkspace }) {
     generatorsConfiguration,
     pathModificationStrategy: "MoveUp"
   });
-  await (0, import_promises142.writeFile)(absolutePathToGeneratorsConfiguration, jsYaml.dump(convertedResponse.value));
+  await (0, import_promises143.writeFile)(absolutePathToGeneratorsConfiguration, jsYaml.dump(convertedResponse.value));
 }
 
 // ../cli-migrations/lib/migrations/0.15.0-rc0/update-directory-structure/migration.js
@@ -1717864,7 +1720357,7 @@ var versionMigrations15 = {
 var __default15 = versionMigrations15;
 
 // ../cli-migrations/lib/migrations/0.41.0-rc0/require-generators-yml/migration.js
-var import_promises143 = require("fs/promises");
+var import_promises144 = require("fs/promises");
 var import_yaml15 = __toESM(require_dist2(), 1);
 var migration16 = {
   name: "require-generators-yml",
@@ -1717907,7 +1720400,7 @@ async function addApiConfigurationToSingleWorkspace({ absolutePathToFernDirector
   if (existingGeneratorsYml == null) {
     if (openapiDirectory != null && openapiDirectory.contents[0] != null) {
       const absolutePathToGeneratorsYml = join4(absoluteFilepathToWorkspace, RelativeFilePath2.of("generators.yml"));
-      await (0, import_promises143.writeFile)(absolutePathToGeneratorsYml, jsYaml.dump({
+      await (0, import_promises144.writeFile)(absolutePathToGeneratorsYml, jsYaml.dump({
         api: {
           path: join4(relativize(absolutePathToFernDirectory, absoluteFilepathToWorkspace), RelativeFilePath2.of(openapiDirectory.name), RelativeFilePath2.of(openapiDirectory.contents[0]?.name))
         }
@@ -1717922,7 +1720415,7 @@ async function addApiConfigurationToSingleWorkspace({ absolutePathToFernDirector
       parsedDocument.set("api", {
         path: join4(relativize(absolutePathToFernDirectory, absoluteFilepathToWorkspace), RelativeFilePath2.of(openapiDirectory.name), RelativeFilePath2.of(openapiDirectory.contents[0]?.name))
       });
-      await (0, import_promises143.writeFile)(existingGeneratorsYml.absolutePath, parsedDocument.toString());
+      await (0, import_promises144.writeFile)(existingGeneratorsYml.absolutePath, parsedDocument.toString());
       context2.logger.info(source_default2.green(`Updated ${existingGeneratorsYml.absolutePath}`));
     }
   }
@@ -1717949,7 +1720442,7 @@ var versionMigrations16 = {
 var __default16 = versionMigrations16;
 
 // ../cli-migrations/lib/migrations/0.54.0-rc0/use-generators-yml-specs/migration.js
-var import_promises144 = require("fs/promises");
+var import_promises145 = require("fs/promises");
 var import_yaml16 = __toESM(require_dist2(), 1);
 var migration17 = {
   name: "generators-yml-use-api-specs",
@@ -1718129,7 +1720622,7 @@ async function addApiConfigurationToSingleWorkspace2({ absoluteFilepathToWorkspa
   if (schemaComment && documentToWrite.indexOf(schemaComment) === -1) {
     documentToWrite = `${schemaComment}${documentToWrite}`;
   }
-  await (0, import_promises144.writeFile)(generatorsYmlFile.absolutePath, documentToWrite);
+  await (0, import_promises145.writeFile)(generatorsYmlFile.absolutePath, documentToWrite);
   context2.logger.info(source_default2.green(`Updated ${generatorsYmlFile.absolutePath}`));
 }
 async function parseApiSpec({ oldSpec, absoluteFilepathToWorkspace, files, directories, context: context2, namespace }) {
@@ -1718176,7 +1720669,7 @@ async function parseApiSpec({ oldSpec, absoluteFilepathToWorkspace, files, direc
   }
   let specContent;
   try {
-    const fileContents = await (0, import_promises144.readFile)(absoluteSpecPath, { encoding: "utf-8" });
+    const fileContents = await (0, import_promises145.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...`);
@@ -1718279,7 +1720772,7 @@ var versionMigrations17 = {
 var __default17 = versionMigrations17;
 
 // ../cli-migrations/lib/migrations/0.82.1/add-path-parameter-order-setting/migration.js
-var import_promises145 = require("fs/promises");
+var import_promises146 = 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.
@@ -1718367,7 +1720860,7 @@ async function updateGeneratorsYml({ context: context2, files }) {
     documentToWrite = `${schemaComment}
 ${documentToWrite}`;
   }
-  await (0, import_promises145.writeFile)(generatorsYmlFile.absolutePath, documentToWrite);
+  await (0, import_promises146.writeFile)(generatorsYmlFile.absolutePath, documentToWrite);
   context2.logger.info(source_default2.green(`Updated ${generatorsYmlFile.absolutePath}`));
 }
 async function getFilesAndDirectories3(absoluteFilepath) {
@@ -1718403,7 +1720896,7 @@ var versionMigrations18 = {
 var __default18 = versionMigrations18;
 
 // ../cli-migrations/lib/migrations/1.0.0/update-settings-defaults/migration.js
-var import_promises146 = require("fs/promises");
+var import_promises147 = require("fs/promises");
 var migration19 = {
   name: "update-1_0_0-defaults",
   summary: `The defaults of the API spec settings have changed. 
@@ -1718578,7 +1721071,7 @@ async function updateGeneratorsYml2({ context: context2, files }) {
     documentToWrite = `${schemaComment}
 ${documentToWrite}`;
   }
-  await (0, import_promises146.writeFile)(generatorsYmlFile.absolutePath, documentToWrite);
+  await (0, import_promises147.writeFile)(generatorsYmlFile.absolutePath, documentToWrite);
   context2.logger.info(source_default2.green(`Updated ${generatorsYmlFile.absolutePath}`));
 }
 async function getFilesAndDirectories4(absoluteFilepath) {
@@ -1718647,7 +1721140,7 @@ var versionMigrations19 = {
 var __default19 = versionMigrations19;
 
 // ../cli-migrations/lib/migrations/2.0.0-rc0/update-settings-defaults/migration.js
-var import_promises147 = require("fs/promises");
+var import_promises148 = 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. 
@@ -1718822,7 +1721315,7 @@ async function updateGeneratorsYml3({ context: context2, files }) {
     documentToWrite = `${schemaComment}
 ${documentToWrite}`;
   }
-  await (0, import_promises147.writeFile)(generatorsYmlFile.absolutePath, documentToWrite);
+  await (0, import_promises148.writeFile)(generatorsYmlFile.absolutePath, documentToWrite);
   context2.logger.info(source_default2.green(`Updated ${generatorsYmlFile.absolutePath}`));
 }
 async function getFilesAndDirectories5(absoluteFilepath) {
@@ -1718868,7 +1721361,7 @@ var versionMigrations20 = {
 var __default20 = versionMigrations20;
 
 // ../cli-migrations/lib/migrations/2.13.0/migrate-deprecated-generator-api-settings/migration.js
-var import_promises148 = require("fs/promises");
+var import_promises149 = require("fs/promises");
 var migration21 = {
   name: "migrate-deprecated-generator-api-settings",
   summary: `Migrates deprecated generator-level API settings keys to their new equivalents:
@@ -1718959,7 +1721452,7 @@ async function updateGeneratorsYml4({ context: context2, files }) {
     documentToWrite = `${schemaComment}
 ${documentToWrite}`;
   }
-  await (0, import_promises148.writeFile)(generatorsYmlFile.absolutePath, documentToWrite);
+  await (0, import_promises149.writeFile)(generatorsYmlFile.absolutePath, documentToWrite);
   context2.logger.info(source_default2.green(`Updated ${generatorsYmlFile.absolutePath}`));
 }
 function migrateDeprecatedSettings(settings, context2) {
@@ -1719005,7 +1721498,7 @@ var versionMigrations21 = {
 var __default21 = versionMigrations21;
 
 // ../cli-migrations/lib/migrations/3.0.0/enable-smart-casing/migration.js
-var import_promises149 = require("fs/promises");
+var import_promises150 = require("fs/promises");
 var migration22 = {
   name: "enable-smart-casing",
   summary: `Sets 'smart-casing: false' for existing generators to preserve backwards compatibility.
@@ -1719089,7 +1721582,7 @@ async function updateGeneratorsYml5({ context: context2, files }) {
     documentToWrite = `${schemaComment}
 ${documentToWrite}`;
   }
-  await (0, import_promises149.writeFile)(generatorsYmlFile.absolutePath, documentToWrite);
+  await (0, import_promises150.writeFile)(generatorsYmlFile.absolutePath, documentToWrite);
   context2.logger.info(source_default2.green(`Updated ${generatorsYmlFile.absolutePath}`));
 }
 function setSmartCasingFalseIfNotConfigured(generator, context2) {
@@ -1719230,7 +1721723,7 @@ ${source_default2.dim(migration23.summary)}`
 }
 
 // src/commands/upgrade/upgrade.ts
-var import_promises150 = require("fs/promises");
+var import_promises151 = require("fs/promises");
 
 // src/cwd.ts
 var FERN_CWD_ENV_VAR = "FERN_CWD";
@@ -1719547,7 +1722040,7 @@ async function upgrade({
     const newProjectConfig = produce(projectConfig2.rawConfig, (draft) => {
       draft.version = resolvedTargetVersion;
     });
-    await (0, import_promises150.writeFile)(
+    await (0, import_promises151.writeFile)(
       projectConfig2._absolutePath,
       ensureFinalNewline2(JSON.stringify(newProjectConfig, void 0, 2))
     );
@@ -1719973,7 +1722466,7 @@ async function validateWorkspaces({
 }
 
 // src/commands/write-definition/writeDefinitionForWorkspaces.ts
-var import_promises151 = require("fs/promises");
+var import_promises152 = require("fs/promises");
 var import_path70 = __toESM(require("path"), 1);
 async function writeDefinitionForWorkspaces({
   project,
@@ -1720054,27 +1722547,27 @@ async function writeFernDefinition({
     return a10.localeCompare(b18);
   };
   if (await doesPathExist(absolutePathToOutputDirectory)) {
-    await (0, import_promises151.rm)(absolutePathToOutputDirectory, { recursive: true });
+    await (0, import_promises152.rm)(absolutePathToOutputDirectory, { recursive: true });
   }
-  await (0, import_promises151.mkdir)(absolutePathToOutputDirectory, { recursive: true });
-  await (0, import_promises151.writeFile)(
+  await (0, import_promises152.mkdir)(absolutePathToOutputDirectory, { recursive: true });
+  await (0, import_promises152.writeFile)(
     join4(absolutePathToOutputDirectory, RelativeFilePath2.of(ROOT_API_FILENAME)),
     jsYaml.dump(definition3.rootApiFile.contents, { sortKeys })
   );
   for (const [relativePath, packageMarker] of Object.entries(definition3.packageMarkers)) {
     const absoluteFilepath = join4(absolutePathToOutputDirectory, RelativeFilePath2.of(relativePath));
-    await (0, import_promises151.mkdir)(dirname4(absoluteFilepath), { recursive: true });
-    await (0, import_promises151.writeFile)(absoluteFilepath, jsYaml.dump(packageMarker.contents, { sortKeys }));
+    await (0, import_promises152.mkdir)(dirname4(absoluteFilepath), { recursive: true });
+    await (0, import_promises152.writeFile)(absoluteFilepath, jsYaml.dump(packageMarker.contents, { sortKeys }));
   }
   for (const [relativePath, definitionFile] of Object.entries(definition3.namedDefinitionFiles)) {
     const absoluteFilepath = join4(absolutePathToOutputDirectory, RelativeFilePath2.of(relativePath));
-    await (0, import_promises151.mkdir)(dirname4(absoluteFilepath), { recursive: true });
-    await (0, import_promises151.writeFile)(absoluteFilepath, jsYaml.dump(definitionFile.contents, { sortKeys }));
+    await (0, import_promises152.mkdir)(dirname4(absoluteFilepath), { recursive: true });
+    await (0, import_promises152.writeFile)(absoluteFilepath, jsYaml.dump(definitionFile.contents, { sortKeys }));
   }
 }
 
 // src/commands/write-docs-definition/writeDocsDefinitionForProject.ts
-var import_promises152 = require("fs/promises");
+var import_promises153 = require("fs/promises");
 async function writeDocsDefinitionForProject({
   project,
   outputPath,
@@ -1720106,7 +1722599,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_promises152.writeFile)(AbsoluteFilePath2.of(outputPath), JSON.stringify(docsDefinition, null, 2));
+    await (0, import_promises153.writeFile)(AbsoluteFilePath2.of(outputPath), JSON.stringify(docsDefinition, null, 2));
     context2.logger.info(source_default2.green(`Docs definition written to ${outputPath}`));
   });
 }
@@ -1720114,7 +1722607,7 @@ async function writeDocsDefinitionForProject({
 // src/commands/write-translation/writeTranslationForProject.ts
 var import_cli_progress2 = __toESM(require_cli_progress(), 1);
 var import_fs26 = require("fs");
-var import_promises156 = require("fs/promises");
+var import_promises157 = require("fs/promises");
 var import_is_ci2 = __toESM(require_is_ci(), 1);
 var import_path73 = __toESM(require("path"), 1);
 
@@ -1720599,7 +1723092,7 @@ function shouldProcessFile(filePath, stub) {
 }
 
 // src/commands/write-translation/docs-config-utils.ts
-var import_promises153 = require("fs/promises");
+var import_promises154 = require("fs/promises");
 
 // src/commands/write-translation/url-utils.ts
 function addLanguageSuffixToUrl(url3, language) {
@@ -1720756,7 +1723249,7 @@ async function createLanguageSpecificDocsConfig({
   stub = false
 }) {
   try {
-    const originalConfigContent = await (0, import_promises153.readFile)(originalDocsConfigPath, "utf-8");
+    const originalConfigContent = await (0, import_promises154.readFile)(originalDocsConfigPath, "utf-8");
     const transformation = {
       filePath: DOCS_CONFIGURATION_FILENAME,
       language,
@@ -1720770,7 +1723263,7 @@ async function createLanguageSpecificDocsConfig({
     const modifiedConfigContent = jsYaml.dump(modifiedConfig, {
       sortKeys: false
     });
-    await (0, import_promises153.writeFile)(modifiedConfigPath, modifiedConfigContent, "utf-8");
+    await (0, import_promises154.writeFile)(modifiedConfigPath, modifiedConfigContent, "utf-8");
     context2.logger.debug(`Created language-specific docs config: ${modifiedConfigPath}`);
   } catch (error49) {
     if (error49 instanceof Error && error49.message.includes("403")) {
@@ -1720782,11 +1723275,11 @@ async function createLanguageSpecificDocsConfig({
 
 // src/commands/write-translation/file-collection-utils.ts
 var import_fs24 = require("fs");
-var import_promises154 = require("fs/promises");
+var import_promises155 = require("fs/promises");
 var import_path71 = __toESM(require("path"), 1);
 async function collectFiles(baseDirectory, relativeBase) {
   const discoveredFiles = {};
-  const entries10 = await (0, import_promises154.readdir)(baseDirectory);
+  const entries10 = await (0, import_promises155.readdir)(baseDirectory);
   for (const entry of entries10) {
     if (entry === "translations") {
       continue;
@@ -1720809,7 +1723302,7 @@ async function collectFiles(baseDirectory, relativeBase) {
 // src/commands/write-translation/hash-utils.ts
 var import_crypto10 = require("crypto");
 var import_fs25 = require("fs");
-var import_promises155 = require("fs/promises");
+var import_promises156 = require("fs/promises");
 var import_path72 = __toESM(require("path"), 1);
 function calculateContentHash(content5) {
   return (0, import_crypto10.createHash)("sha256").update(content5, "utf-8").digest("hex");
@@ -1720820,7 +1723313,7 @@ async function loadHashMappings(translationsDirectory) {
     return {};
   }
   try {
-    const hashesContent = await (0, import_promises155.readFile)(hashesFilePath, "utf-8");
+    const hashesContent = await (0, import_promises156.readFile)(hashesFilePath, "utf-8");
     const parsed = JSON.parse(hashesContent);
     const { _comment, ...hashMappings } = parsed;
     return hashMappings;
@@ -1720841,11 +1723334,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_promises155.writeFile)(hashesFilePath, JSON.stringify(fileContent, null, 2), "utf-8");
+  await (0, import_promises156.writeFile)(hashesFilePath, JSON.stringify(fileContent, null, 2), "utf-8");
 }
 async function hasFileChanged(filePath, relativePath, previousHashes) {
   try {
-    const content5 = await (0, import_promises155.readFile)(filePath, "utf-8");
+    const content5 = await (0, import_promises156.readFile)(filePath, "utf-8");
     const currentHash = calculateContentHash(content5);
     const previousHash = previousHashes[relativePath];
     return currentHash !== previousHash;
@@ -1720898,7 +1723391,7 @@ async function writeTranslationForProject({
     }
     if (!(0, import_fs26.existsSync)(translationsDirectory)) {
       context2.logger.debug(`Creating translations directory at: ${translationsDirectory}`);
-      await (0, import_promises156.mkdir)(translationsDirectory, { recursive: true });
+      await (0, import_promises157.mkdir)(translationsDirectory, { recursive: true });
     }
     const languageStats = {};
     const targetLanguages = languages.filter((lang) => lang !== sourceLanguage);
@@ -1720911,7 +1723404,7 @@ async function writeTranslationForProject({
         RelativeFilePath2.of("fern")
       );
       if (!(0, import_fs26.existsSync)(languageDirectory)) {
-        await (0, import_promises156.mkdir)(languageDirectory, { recursive: true });
+        await (0, import_promises157.mkdir)(languageDirectory, { recursive: true });
       }
       languageStats[language] = {
         filesProcessed: 0,
@@ -1721013,7 +1723506,7 @@ async function writeTranslationForProject({
                 `[COMPLETED] ${DOCS_CONFIGURATION_FILENAME} -> ${language}/${DOCS_CONFIGURATION_FILENAME}`
               );
             }
-            const originalConfigContent = await (0, import_promises156.readFile)(originalDocsConfigPath, "utf-8");
+            const originalConfigContent = await (0, import_promises157.readFile)(originalDocsConfigPath, "utf-8");
             await updateAndSaveHashForFile(
               translationsDirectory,
               hashMappings,
@@ -1721058,7 +1723551,7 @@ async function writeTranslationForProject({
             continue;
           }
           cliContext.logger.debug(`[PROCESSING] ${relativePath} (detected changes)`);
-          const originalContent = await (0, import_promises156.readFile)(filePath, "utf-8");
+          const originalContent = await (0, import_promises157.readFile)(filePath, "utf-8");
           await updateAndSaveHashForFile(translationsDirectory, hashMappings, relativePath, originalContent);
           const sourceStats = languageStats[sourceLanguage];
           if (sourceStats) {
@@ -1721083,7 +1723576,7 @@ async function writeTranslationForProject({
             const destPath = join4(languageDirectory, relativePath);
             const destDir = import_path73.default.dirname(destPath);
             if (!(0, import_fs26.existsSync)(destDir)) {
-              await (0, import_promises156.mkdir)(destDir, { recursive: true });
+              await (0, import_promises157.mkdir)(destDir, { recursive: true });
             }
             const transformation = {
               filePath: relativePath,
@@ -1721096,7 +1723589,7 @@ async function writeTranslationForProject({
               cliContext,
               stub
             });
-            await (0, import_promises156.writeFile)(destPath, transformedContent, "utf-8");
+            await (0, import_promises157.writeFile)(destPath, transformedContent, "utf-8");
             const languageStatsForLang = languageStats[language];
             if (languageStatsForLang) {
               languageStatsForLang.filesProcessed++;
@@ -1721127,9 +1723620,9 @@ async function writeTranslationForProject({
             const destPath = join4(languageDirectory, relativePath);
             const destDir = import_path73.default.dirname(destPath);
             if (!(0, import_fs26.existsSync)(destDir)) {
-              await (0, import_promises156.mkdir)(destDir, { recursive: true });
+              await (0, import_promises157.mkdir)(destDir, { recursive: true });
             }
-            await (0, import_promises156.copyFile)(filePath, destPath);
+            await (0, import_promises157.copyFile)(filePath, destPath);
             assetsCopied++;
             cliContext.logger.debug(`[ASSET COPIED] ${relativePath} -> ${language}/${relativePath}`);
           }
@@ -1722513,9 +1725006,47 @@ function addDocsCommand(cli, cliContext) {
     addDocsDevCommand(yargs, cliContext);
     addDocsBrokenLinksCommand(yargs, cliContext);
     addDocsPreviewCommand(yargs, cliContext);
+    addDocsDiffCommand(yargs, cliContext);
     return yargs;
   });
 }
+function addDocsDiffCommand(cli, cliContext) {
+  cli.command(
+    "diff <preview-url> <files..>",
+    "Generate visual diffs between preview and production docs pages",
+    (yargs) => yargs.positional("preview-url", {
+      type: "string",
+      description: "The preview deployment URL (e.g. acme-preview-abc123.docs.buildwithfern.com)",
+      demandOption: true
+    }).positional("files", {
+      type: "string",
+      array: true,
+      description: "File paths to generate diffs for (e.g. fern/pages/intro.mdx)",
+      demandOption: true
+    }).option("output", {
+      type: "string",
+      default: ".fern/diff",
+      description: "Output directory for diff images"
+    }),
+    async (argv) => {
+      await cliContext.instrumentPostHogEvent({
+        command: "fern docs diff"
+      });
+      const project = await loadProjectAndRegisterWorkspacesWithContext(cliContext, {
+        commandLineApiWorkspace: void 0,
+        defaultToAllApiWorkspaces: true
+      });
+      const result = await docsDiff({
+        cliContext,
+        project,
+        previewUrl: argv.previewUrl,
+        files: argv.files ?? [],
+        outputDir: argv.output
+      });
+      cliContext.logger.info(JSON.stringify(result, null, 2));
+    }
+  );
+}
 function addDocsPreviewCommand(cli, cliContext) {
   cli.command("preview", "Commands for managing preview deployments", (yargs) => {
     addDocsPreviewListCommand(yargs, cliContext);