@fern-api/fern-api-dev 3.64.2 → 3.64.3

package/cli.cjs

@@ -1273516,11 +1273516,11 @@ var require_yauzl = __commonJS({
           var fileNameLength = buffer.readUInt16LE(26);
           var extraFieldLength = buffer.readUInt16LE(28);
           var localFileHeaderEnd = entry.relativeOffsetOfLocalHeader + buffer.length + fileNameLength + extraFieldLength;
-          var decompress4;
+          var decompress3;
           if (entry.compressionMethod === 0) {
-            decompress4 = false;
+            decompress3 = false;
           } else if (entry.compressionMethod === 8) {
-            decompress4 = options2.decompress != null ? options2.decompress : true;
+            decompress3 = options2.decompress != null ? options2.decompress : true;
           } else {
             return callback(new Error("unsupported compression method: " + entry.compressionMethod));
           }
@@ -1273536,7 +1273536,7 @@ var require_yauzl = __commonJS({
             end: fileDataStart + relativeEnd
           });
           var endpointStream = readStream2;
-          if (decompress4) {
+          if (decompress3) {
             var destroyed = false;
             var inflateFilter = zlib4.createInflateRaw();
             readStream2.on("error", function(err2) {
@@ -1273769,7 +1273769,7 @@ var require_decompress_unzip = __commonJS({
     var fileType = require_file_type3();
     var getStream = require_get_stream2();
     var pify = require_pify();
-    var yauzl = require_yauzl();
+    var yauzl2 = require_yauzl();
     var getType3 = (entry, mode) => {
       const IFMT2 = 61440;
       const IFDIR2 = 16384;
@@ -1273826,7 +1273826,7 @@ var require_decompress_unzip = __commonJS({
       if (!fileType(buf) || fileType(buf).ext !== "zip") {
         return Promise.resolve([]);
       }
-      return pify(yauzl.fromBuffer)(buf, { lazyEntries: true }).then(extractFile2);
+      return pify(yauzl2.fromBuffer)(buf, { lazyEntries: true }).then(extractFile2);
     };
   }
 });
@@ -1274252,6 +1274252,1019 @@ var require_supports_hyperlinks = __commonJS({
   }
 });
 
+// ../../../node_modules/.pnpm/yauzl@3.2.0/node_modules/yauzl/fd-slicer.js
+var require_fd_slicer2 = __commonJS({
+  "../../../node_modules/.pnpm/yauzl@3.2.0/node_modules/yauzl/fd-slicer.js"(exports2) {
+    "use strict";
+    var fs33 = require("fs");
+    var util4 = require("util");
+    var stream5 = require("stream");
+    var Readable6 = stream5.Readable;
+    var Writable2 = stream5.Writable;
+    var PassThrough5 = stream5.PassThrough;
+    var Pend = require_pend();
+    var EventEmitter8 = require("events").EventEmitter;
+    exports2.createFromBuffer = createFromBuffer;
+    exports2.createFromFd = createFromFd;
+    exports2.BufferSlicer = BufferSlicer;
+    exports2.FdSlicer = FdSlicer;
+    util4.inherits(FdSlicer, EventEmitter8);
+    function FdSlicer(fd, options2) {
+      options2 = options2 || {};
+      EventEmitter8.call(this);
+      this.fd = fd;
+      this.pend = new Pend();
+      this.pend.max = 1;
+      this.refCount = 0;
+      this.autoClose = !!options2.autoClose;
+    }
+    FdSlicer.prototype.read = function(buffer, offset2, length, position4, callback) {
+      var self2 = this;
+      self2.pend.go(function(cb2) {
+        fs33.read(self2.fd, buffer, offset2, length, position4, function(err, bytesRead, buffer2) {
+          cb2();
+          callback(err, bytesRead, buffer2);
+        });
+      });
+    };
+    FdSlicer.prototype.write = function(buffer, offset2, length, position4, callback) {
+      var self2 = this;
+      self2.pend.go(function(cb2) {
+        fs33.write(self2.fd, buffer, offset2, length, position4, function(err, written, buffer2) {
+          cb2();
+          callback(err, written, buffer2);
+        });
+      });
+    };
+    FdSlicer.prototype.createReadStream = function(options2) {
+      return new ReadStream2(this, options2);
+    };
+    FdSlicer.prototype.createWriteStream = function(options2) {
+      return new WriteStream2(this, options2);
+    };
+    FdSlicer.prototype.ref = function() {
+      this.refCount += 1;
+    };
+    FdSlicer.prototype.unref = function() {
+      var self2 = this;
+      self2.refCount -= 1;
+      if (self2.refCount > 0) return;
+      if (self2.refCount < 0) throw new Error("invalid unref");
+      if (self2.autoClose) {
+        fs33.close(self2.fd, onCloseDone);
+      }
+      function onCloseDone(err) {
+        if (err) {
+          self2.emit("error", err);
+        } else {
+          self2.emit("close");
+        }
+      }
+    };
+    util4.inherits(ReadStream2, Readable6);
+    function ReadStream2(context2, options2) {
+      options2 = options2 || {};
+      Readable6.call(this, options2);
+      this.context = context2;
+      this.context.ref();
+      this.start = options2.start || 0;
+      this.endOffset = options2.end;
+      this.pos = this.start;
+      this.destroyed = false;
+    }
+    ReadStream2.prototype._read = function(n6) {
+      var self2 = this;
+      if (self2.destroyed) return;
+      var toRead = Math.min(self2._readableState.highWaterMark, n6);
+      if (self2.endOffset != null) {
+        toRead = Math.min(toRead, self2.endOffset - self2.pos);
+      }
+      if (toRead <= 0) {
+        self2.destroyed = true;
+        self2.push(null);
+        self2.context.unref();
+        return;
+      }
+      self2.context.pend.go(function(cb2) {
+        if (self2.destroyed) return cb2();
+        var buffer = Buffer.allocUnsafe(toRead);
+        fs33.read(self2.context.fd, buffer, 0, toRead, self2.pos, function(err, bytesRead) {
+          if (err) {
+            self2.destroy(err);
+          } else if (bytesRead === 0) {
+            self2.destroyed = true;
+            self2.push(null);
+            self2.context.unref();
+          } else {
+            self2.pos += bytesRead;
+            self2.push(buffer.slice(0, bytesRead));
+          }
+          cb2();
+        });
+      });
+    };
+    ReadStream2.prototype.destroy = function(err) {
+      if (this.destroyed) return;
+      err = err || new Error("stream destroyed");
+      this.destroyed = true;
+      this.emit("error", err);
+      this.context.unref();
+    };
+    util4.inherits(WriteStream2, Writable2);
+    function WriteStream2(context2, options2) {
+      options2 = options2 || {};
+      Writable2.call(this, options2);
+      this.context = context2;
+      this.context.ref();
+      this.start = options2.start || 0;
+      this.endOffset = options2.end == null ? Infinity : +options2.end;
+      this.bytesWritten = 0;
+      this.pos = this.start;
+      this.destroyed = false;
+      this.on("finish", this.destroy.bind(this));
+    }
+    WriteStream2.prototype._write = function(buffer, encoding, callback) {
+      var self2 = this;
+      if (self2.destroyed) return;
+      if (self2.pos + buffer.length > self2.endOffset) {
+        var err = new Error("maximum file length exceeded");
+        err.code = "ETOOBIG";
+        self2.destroy();
+        callback(err);
+        return;
+      }
+      self2.context.pend.go(function(cb2) {
+        if (self2.destroyed) return cb2();
+        fs33.write(self2.context.fd, buffer, 0, buffer.length, self2.pos, function(err2, bytes) {
+          if (err2) {
+            self2.destroy();
+            cb2();
+            callback(err2);
+          } else {
+            self2.bytesWritten += bytes;
+            self2.pos += bytes;
+            self2.emit("progress");
+            cb2();
+            callback();
+          }
+        });
+      });
+    };
+    WriteStream2.prototype.destroy = function() {
+      if (this.destroyed) return;
+      this.destroyed = true;
+      this.context.unref();
+    };
+    util4.inherits(BufferSlicer, EventEmitter8);
+    function BufferSlicer(buffer, options2) {
+      EventEmitter8.call(this);
+      options2 = options2 || {};
+      this.refCount = 0;
+      this.buffer = buffer;
+      this.maxChunkSize = options2.maxChunkSize || Number.MAX_SAFE_INTEGER;
+    }
+    BufferSlicer.prototype.read = function(buffer, offset2, length, position4, callback) {
+      if (!(0 <= offset2 && offset2 <= buffer.length)) throw new RangeError("offset outside buffer: 0 <= " + offset2 + " <= " + buffer.length);
+      if (position4 < 0) throw new RangeError("position is negative: " + position4);
+      if (offset2 + length > buffer.length) {
+        length = buffer.length - offset2;
+      }
+      if (position4 + length > this.buffer.length) {
+        length = this.buffer.length - position4;
+      }
+      if (length <= 0) {
+        setImmediate(function() {
+          callback(null, 0);
+        });
+        return;
+      }
+      this.buffer.copy(buffer, offset2, position4, position4 + length);
+      setImmediate(function() {
+        callback(null, length);
+      });
+    };
+    BufferSlicer.prototype.write = function(buffer, offset2, length, position4, callback) {
+      buffer.copy(this.buffer, position4, offset2, offset2 + length);
+      setImmediate(function() {
+        callback(null, length, buffer);
+      });
+    };
+    BufferSlicer.prototype.createReadStream = function(options2) {
+      options2 = options2 || {};
+      var readStream2 = new PassThrough5(options2);
+      readStream2.destroyed = false;
+      readStream2.start = options2.start || 0;
+      readStream2.endOffset = options2.end;
+      readStream2.pos = readStream2.endOffset || this.buffer.length;
+      var entireSlice = this.buffer.slice(readStream2.start, readStream2.pos);
+      var offset2 = 0;
+      while (true) {
+        var nextOffset = offset2 + this.maxChunkSize;
+        if (nextOffset >= entireSlice.length) {
+          if (offset2 < entireSlice.length) {
+            readStream2.write(entireSlice.slice(offset2, entireSlice.length));
+          }
+          break;
+        }
+        readStream2.write(entireSlice.slice(offset2, nextOffset));
+        offset2 = nextOffset;
+      }
+      readStream2.end();
+      readStream2.destroy = function() {
+        readStream2.destroyed = true;
+      };
+      return readStream2;
+    };
+    BufferSlicer.prototype.createWriteStream = function(options2) {
+      var bufferSlicer = this;
+      options2 = options2 || {};
+      var writeStream = new Writable2(options2);
+      writeStream.start = options2.start || 0;
+      writeStream.endOffset = options2.end == null ? this.buffer.length : +options2.end;
+      writeStream.bytesWritten = 0;
+      writeStream.pos = writeStream.start;
+      writeStream.destroyed = false;
+      writeStream._write = function(buffer, encoding, callback) {
+        if (writeStream.destroyed) return;
+        var end = writeStream.pos + buffer.length;
+        if (end > writeStream.endOffset) {
+          var err = new Error("maximum file length exceeded");
+          err.code = "ETOOBIG";
+          writeStream.destroyed = true;
+          callback(err);
+          return;
+        }
+        buffer.copy(bufferSlicer.buffer, writeStream.pos, 0, buffer.length);
+        writeStream.bytesWritten += buffer.length;
+        writeStream.pos = end;
+        writeStream.emit("progress");
+        callback();
+      };
+      writeStream.destroy = function() {
+        writeStream.destroyed = true;
+      };
+      return writeStream;
+    };
+    BufferSlicer.prototype.ref = function() {
+      this.refCount += 1;
+    };
+    BufferSlicer.prototype.unref = function() {
+      this.refCount -= 1;
+      if (this.refCount < 0) {
+        throw new Error("invalid unref");
+      }
+    };
+    function createFromBuffer(buffer, options2) {
+      return new BufferSlicer(buffer, options2);
+    }
+    function createFromFd(fd, options2) {
+      return new FdSlicer(fd, options2);
+    }
+  }
+});
+
+// ../../../node_modules/.pnpm/yauzl@3.2.0/node_modules/yauzl/index.js
+var require_yauzl2 = __commonJS({
+  "../../../node_modules/.pnpm/yauzl@3.2.0/node_modules/yauzl/index.js"(exports2) {
+    "use strict";
+    var fs33 = require("fs");
+    var zlib4 = require("zlib");
+    var fd_slicer = require_fd_slicer2();
+    var crc32 = require_buffer_crc32();
+    var util4 = require("util");
+    var EventEmitter8 = require("events").EventEmitter;
+    var Transform = require("stream").Transform;
+    var PassThrough5 = require("stream").PassThrough;
+    var Writable2 = require("stream").Writable;
+    exports2.open = open5;
+    exports2.fromFd = fromFd;
+    exports2.fromBuffer = fromBuffer2;
+    exports2.fromRandomAccessReader = fromRandomAccessReader;
+    exports2.dosDateTimeToDate = dosDateTimeToDate;
+    exports2.getFileNameLowLevel = getFileNameLowLevel;
+    exports2.validateFileName = validateFileName;
+    exports2.parseExtraFields = parseExtraFields;
+    exports2.ZipFile = ZipFile;
+    exports2.Entry = Entry;
+    exports2.LocalFileHeader = LocalFileHeader;
+    exports2.RandomAccessReader = RandomAccessReader;
+    function open5(path86, options2, callback) {
+      if (typeof options2 === "function") {
+        callback = options2;
+        options2 = null;
+      }
+      if (options2 == null) options2 = {};
+      if (options2.autoClose == null) options2.autoClose = true;
+      if (options2.lazyEntries == null) options2.lazyEntries = false;
+      if (options2.decodeStrings == null) options2.decodeStrings = true;
+      if (options2.validateEntrySizes == null) options2.validateEntrySizes = true;
+      if (options2.strictFileNames == null) options2.strictFileNames = false;
+      if (callback == null) callback = defaultCallback;
+      fs33.open(path86, "r", function(err, fd) {
+        if (err) return callback(err);
+        fromFd(fd, options2, function(err2, zipfile) {
+          if (err2) fs33.close(fd, defaultCallback);
+          callback(err2, zipfile);
+        });
+      });
+    }
+    function fromFd(fd, options2, callback) {
+      if (typeof options2 === "function") {
+        callback = options2;
+        options2 = null;
+      }
+      if (options2 == null) options2 = {};
+      if (options2.autoClose == null) options2.autoClose = false;
+      if (options2.lazyEntries == null) options2.lazyEntries = false;
+      if (options2.decodeStrings == null) options2.decodeStrings = true;
+      if (options2.validateEntrySizes == null) options2.validateEntrySizes = true;
+      if (options2.strictFileNames == null) options2.strictFileNames = false;
+      if (callback == null) callback = defaultCallback;
+      fs33.fstat(fd, function(err, stats) {
+        if (err) return callback(err);
+        var reader = fd_slicer.createFromFd(fd, { autoClose: true });
+        fromRandomAccessReader(reader, stats.size, options2, callback);
+      });
+    }
+    function fromBuffer2(buffer, options2, callback) {
+      if (typeof options2 === "function") {
+        callback = options2;
+        options2 = null;
+      }
+      if (options2 == null) options2 = {};
+      options2.autoClose = false;
+      if (options2.lazyEntries == null) options2.lazyEntries = false;
+      if (options2.decodeStrings == null) options2.decodeStrings = true;
+      if (options2.validateEntrySizes == null) options2.validateEntrySizes = true;
+      if (options2.strictFileNames == null) options2.strictFileNames = false;
+      var reader = fd_slicer.createFromBuffer(buffer, { maxChunkSize: 65536 });
+      fromRandomAccessReader(reader, buffer.length, options2, callback);
+    }
+    function fromRandomAccessReader(reader, totalSize, options2, callback) {
+      if (typeof options2 === "function") {
+        callback = options2;
+        options2 = null;
+      }
+      if (options2 == null) options2 = {};
+      if (options2.autoClose == null) options2.autoClose = true;
+      if (options2.lazyEntries == null) options2.lazyEntries = false;
+      if (options2.decodeStrings == null) options2.decodeStrings = true;
+      var decodeStrings = !!options2.decodeStrings;
+      if (options2.validateEntrySizes == null) options2.validateEntrySizes = true;
+      if (options2.strictFileNames == null) options2.strictFileNames = false;
+      if (callback == null) callback = defaultCallback;
+      if (typeof totalSize !== "number") throw new Error("expected totalSize parameter to be a number");
+      if (totalSize > Number.MAX_SAFE_INTEGER) {
+        throw new Error("zip file too large. only file sizes up to 2^52 are supported due to JavaScript's Number type being an IEEE 754 double.");
+      }
+      reader.ref();
+      var eocdrWithoutCommentSize = 22;
+      var zip64EocdlSize = 20;
+      var maxCommentSize = 65535;
+      var bufferSize = Math.min(zip64EocdlSize + eocdrWithoutCommentSize + maxCommentSize, totalSize);
+      var buffer = newBuffer(bufferSize);
+      var bufferReadStart = totalSize - buffer.length;
+      readAndAssertNoEof(reader, buffer, 0, bufferSize, bufferReadStart, function(err) {
+        if (err) return callback(err);
+        for (var i11 = bufferSize - eocdrWithoutCommentSize; i11 >= 0; i11 -= 1) {
+          if (buffer.readUInt32LE(i11) !== 101010256) continue;
+          var eocdrBuffer = buffer.subarray(i11);
+          var diskNumber = eocdrBuffer.readUInt16LE(4);
+          var entryCount = eocdrBuffer.readUInt16LE(10);
+          var centralDirectoryOffset = eocdrBuffer.readUInt32LE(16);
+          var commentLength = eocdrBuffer.readUInt16LE(20);
+          var expectedCommentLength = eocdrBuffer.length - eocdrWithoutCommentSize;
+          if (commentLength !== expectedCommentLength) {
+            return callback(new Error("Invalid comment length. Expected: " + expectedCommentLength + ". Found: " + commentLength + ". Are there extra bytes at the end of the file? Or is the end of central dir signature `PK\u263A\u263B` in the comment?"));
+          }
+          var comment6 = decodeStrings ? decodeBuffer(eocdrBuffer.subarray(22), false) : eocdrBuffer.subarray(22);
+          if (i11 - zip64EocdlSize >= 0 && buffer.readUInt32LE(i11 - zip64EocdlSize) === 117853008) {
+            var zip64EocdlBuffer = buffer.subarray(i11 - zip64EocdlSize, i11 - zip64EocdlSize + zip64EocdlSize);
+            var zip64EocdrOffset = readUInt64LE(zip64EocdlBuffer, 8);
+            var zip64EocdrBuffer = newBuffer(56);
+            return readAndAssertNoEof(reader, zip64EocdrBuffer, 0, zip64EocdrBuffer.length, zip64EocdrOffset, function(err2) {
+              if (err2) return callback(err2);
+              if (zip64EocdrBuffer.readUInt32LE(0) !== 101075792) {
+                return callback(new Error("invalid zip64 end of central directory record signature"));
+              }
+              diskNumber = zip64EocdrBuffer.readUInt32LE(16);
+              if (diskNumber !== 0) {
+                return callback(new Error("multi-disk zip files are not supported: found disk number: " + diskNumber));
+              }
+              entryCount = readUInt64LE(zip64EocdrBuffer, 32);
+              centralDirectoryOffset = readUInt64LE(zip64EocdrBuffer, 48);
+              return callback(null, new ZipFile(reader, centralDirectoryOffset, totalSize, entryCount, comment6, options2.autoClose, options2.lazyEntries, decodeStrings, options2.validateEntrySizes, options2.strictFileNames));
+            });
+          }
+          if (diskNumber !== 0) {
+            return callback(new Error("multi-disk zip files are not supported: found disk number: " + diskNumber));
+          }
+          return callback(null, new ZipFile(reader, centralDirectoryOffset, totalSize, entryCount, comment6, options2.autoClose, options2.lazyEntries, decodeStrings, options2.validateEntrySizes, options2.strictFileNames));
+        }
+        callback(new Error("End of central directory record signature not found. Either not a zip file, or file is truncated."));
+      });
+    }
+    util4.inherits(ZipFile, EventEmitter8);
+    function ZipFile(reader, centralDirectoryOffset, fileSize, entryCount, comment6, autoClose, lazyEntries, decodeStrings, validateEntrySizes, strictFileNames) {
+      var self2 = this;
+      EventEmitter8.call(self2);
+      self2.reader = reader;
+      self2.reader.on("error", function(err) {
+        emitError(self2, err);
+      });
+      self2.reader.once("close", function() {
+        self2.emit("close");
+      });
+      self2.readEntryCursor = centralDirectoryOffset;
+      self2.fileSize = fileSize;
+      self2.entryCount = entryCount;
+      self2.comment = comment6;
+      self2.entriesRead = 0;
+      self2.autoClose = !!autoClose;
+      self2.lazyEntries = !!lazyEntries;
+      self2.decodeStrings = !!decodeStrings;
+      self2.validateEntrySizes = !!validateEntrySizes;
+      self2.strictFileNames = !!strictFileNames;
+      self2.isOpen = true;
+      self2.emittedError = false;
+      if (!self2.lazyEntries) self2._readEntry();
+    }
+    ZipFile.prototype.close = function() {
+      if (!this.isOpen) return;
+      this.isOpen = false;
+      this.reader.unref();
+    };
+    function emitErrorAndAutoClose(self2, err) {
+      if (self2.autoClose) self2.close();
+      emitError(self2, err);
+    }
+    function emitError(self2, err) {
+      if (self2.emittedError) return;
+      self2.emittedError = true;
+      self2.emit("error", err);
+    }
+    ZipFile.prototype.readEntry = function() {
+      if (!this.lazyEntries) throw new Error("readEntry() called without lazyEntries:true");
+      this._readEntry();
+    };
+    ZipFile.prototype._readEntry = function() {
+      var self2 = this;
+      if (self2.entryCount === self2.entriesRead) {
+        setImmediate(function() {
+          if (self2.autoClose) self2.close();
+          if (self2.emittedError) return;
+          self2.emit("end");
+        });
+        return;
+      }
+      if (self2.emittedError) return;
+      var buffer = newBuffer(46);
+      readAndAssertNoEof(self2.reader, buffer, 0, buffer.length, self2.readEntryCursor, function(err) {
+        if (err) return emitErrorAndAutoClose(self2, err);
+        if (self2.emittedError) return;
+        var entry = new Entry();
+        var signature = buffer.readUInt32LE(0);
+        if (signature !== 33639248) return emitErrorAndAutoClose(self2, new Error("invalid central directory file header signature: 0x" + signature.toString(16)));
+        entry.versionMadeBy = buffer.readUInt16LE(4);
+        entry.versionNeededToExtract = buffer.readUInt16LE(6);
+        entry.generalPurposeBitFlag = buffer.readUInt16LE(8);
+        entry.compressionMethod = buffer.readUInt16LE(10);
+        entry.lastModFileTime = buffer.readUInt16LE(12);
+        entry.lastModFileDate = buffer.readUInt16LE(14);
+        entry.crc32 = buffer.readUInt32LE(16);
+        entry.compressedSize = buffer.readUInt32LE(20);
+        entry.uncompressedSize = buffer.readUInt32LE(24);
+        entry.fileNameLength = buffer.readUInt16LE(28);
+        entry.extraFieldLength = buffer.readUInt16LE(30);
+        entry.fileCommentLength = buffer.readUInt16LE(32);
+        entry.internalFileAttributes = buffer.readUInt16LE(36);
+        entry.externalFileAttributes = buffer.readUInt32LE(38);
+        entry.relativeOffsetOfLocalHeader = buffer.readUInt32LE(42);
+        if (entry.generalPurposeBitFlag & 64) return emitErrorAndAutoClose(self2, new Error("strong encryption is not supported"));
+        self2.readEntryCursor += 46;
+        buffer = newBuffer(entry.fileNameLength + entry.extraFieldLength + entry.fileCommentLength);
+        readAndAssertNoEof(self2.reader, buffer, 0, buffer.length, self2.readEntryCursor, function(err2) {
+          if (err2) return emitErrorAndAutoClose(self2, err2);
+          if (self2.emittedError) return;
+          entry.fileNameRaw = buffer.subarray(0, entry.fileNameLength);
+          var fileCommentStart = entry.fileNameLength + entry.extraFieldLength;
+          entry.extraFieldRaw = buffer.subarray(entry.fileNameLength, fileCommentStart);
+          entry.fileCommentRaw = buffer.subarray(fileCommentStart, fileCommentStart + entry.fileCommentLength);
+          try {
+            entry.extraFields = parseExtraFields(entry.extraFieldRaw);
+          } catch (err3) {
+            return emitErrorAndAutoClose(self2, err3);
+          }
+          if (self2.decodeStrings) {
+            var isUtf8 = (entry.generalPurposeBitFlag & 2048) !== 0;
+            entry.fileComment = decodeBuffer(entry.fileCommentRaw, isUtf8);
+            entry.fileName = getFileNameLowLevel(entry.generalPurposeBitFlag, entry.fileNameRaw, entry.extraFields, self2.strictFileNames);
+            var errorMessage = validateFileName(entry.fileName);
+            if (errorMessage != null) return emitErrorAndAutoClose(self2, new Error(errorMessage));
+          } else {
+            entry.fileComment = entry.fileCommentRaw;
+            entry.fileName = entry.fileNameRaw;
+          }
+          entry.comment = entry.fileComment;
+          self2.readEntryCursor += buffer.length;
+          self2.entriesRead += 1;
+          for (var i11 = 0; i11 < entry.extraFields.length; i11++) {
+            var extraField = entry.extraFields[i11];
+            if (extraField.id !== 1) continue;
+            var zip64EiefBuffer = extraField.data;
+            var index3 = 0;
+            if (entry.uncompressedSize === 4294967295) {
+              if (index3 + 8 > zip64EiefBuffer.length) {
+                return emitErrorAndAutoClose(self2, new Error("zip64 extended information extra field does not include uncompressed size"));
+              }
+              entry.uncompressedSize = readUInt64LE(zip64EiefBuffer, index3);
+              index3 += 8;
+            }
+            if (entry.compressedSize === 4294967295) {
+              if (index3 + 8 > zip64EiefBuffer.length) {
+                return emitErrorAndAutoClose(self2, new Error("zip64 extended information extra field does not include compressed size"));
+              }
+              entry.compressedSize = readUInt64LE(zip64EiefBuffer, index3);
+              index3 += 8;
+            }
+            if (entry.relativeOffsetOfLocalHeader === 4294967295) {
+              if (index3 + 8 > zip64EiefBuffer.length) {
+                return emitErrorAndAutoClose(self2, new Error("zip64 extended information extra field does not include relative header offset"));
+              }
+              entry.relativeOffsetOfLocalHeader = readUInt64LE(zip64EiefBuffer, index3);
+              index3 += 8;
+            }
+            break;
+          }
+          if (self2.validateEntrySizes && entry.compressionMethod === 0) {
+            var expectedCompressedSize = entry.uncompressedSize;
+            if (entry.isEncrypted()) {
+              expectedCompressedSize += 12;
+            }
+            if (entry.compressedSize !== expectedCompressedSize) {
+              var msg = "compressed/uncompressed size mismatch for stored file: " + entry.compressedSize + " != " + entry.uncompressedSize;
+              return emitErrorAndAutoClose(self2, new Error(msg));
+            }
+          }
+          self2.emit("entry", entry);
+          if (!self2.lazyEntries) self2._readEntry();
+        });
+      });
+    };
+    ZipFile.prototype.openReadStream = function(entry, options2, callback) {
+      var self2 = this;
+      var relativeStart = 0;
+      var relativeEnd = entry.compressedSize;
+      if (callback == null) {
+        callback = options2;
+        options2 = null;
+      }
+      if (options2 == null) {
+        options2 = {};
+      } else {
+        if (options2.decrypt != null) {
+          if (!entry.isEncrypted()) {
+            throw new Error("options.decrypt can only be specified for encrypted entries");
+          }
+          if (options2.decrypt !== false) throw new Error("invalid options.decrypt value: " + options2.decrypt);
+          if (entry.isCompressed()) {
+            if (options2.decompress !== false) throw new Error("entry is encrypted and compressed, and options.decompress !== false");
+          }
+        }
+        if (options2.decompress != null) {
+          if (!entry.isCompressed()) {
+            throw new Error("options.decompress can only be specified for compressed entries");
+          }
+          if (!(options2.decompress === false || options2.decompress === true)) {
+            throw new Error("invalid options.decompress value: " + options2.decompress);
+          }
+        }
+        if (options2.start != null || options2.end != null) {
+          if (entry.isCompressed() && options2.decompress !== false) {
+            throw new Error("start/end range not allowed for compressed entry without options.decompress === false");
+          }
+          if (entry.isEncrypted() && options2.decrypt !== false) {
+            throw new Error("start/end range not allowed for encrypted entry without options.decrypt === false");
+          }
+        }
+        if (options2.start != null) {
+          relativeStart = options2.start;
+          if (relativeStart < 0) throw new Error("options.start < 0");
+          if (relativeStart > entry.compressedSize) throw new Error("options.start > entry.compressedSize");
+        }
+        if (options2.end != null) {
+          relativeEnd = options2.end;
+          if (relativeEnd < 0) throw new Error("options.end < 0");
+          if (relativeEnd > entry.compressedSize) throw new Error("options.end > entry.compressedSize");
+          if (relativeEnd < relativeStart) throw new Error("options.end < options.start");
+        }
+      }
+      if (!self2.isOpen) return callback(new Error("closed"));
+      if (entry.isEncrypted()) {
+        if (options2.decrypt !== false) return callback(new Error("entry is encrypted, and options.decrypt !== false"));
+      }
+      var decompress3;
+      if (entry.compressionMethod === 0) {
+        decompress3 = false;
+      } else if (entry.compressionMethod === 8) {
+        decompress3 = options2.decompress != null ? options2.decompress : true;
+      } else {
+        return callback(new Error("unsupported compression method: " + entry.compressionMethod));
+      }
+      self2.readLocalFileHeader(entry, { minimal: true }, function(err, localFileHeader) {
+        if (err) return callback(err);
+        self2.openReadStreamLowLevel(
+          localFileHeader.fileDataStart,
+          entry.compressedSize,
+          relativeStart,
+          relativeEnd,
+          decompress3,
+          entry.uncompressedSize,
+          callback
+        );
+      });
+    };
+    ZipFile.prototype.openReadStreamLowLevel = function(fileDataStart, compressedSize, relativeStart, relativeEnd, decompress3, uncompressedSize, callback) {
+      var self2 = this;
+      var fileDataEnd = fileDataStart + compressedSize;
+      var readStream2 = self2.reader.createReadStream({
+        start: fileDataStart + relativeStart,
+        end: fileDataStart + relativeEnd
+      });
+      var endpointStream = readStream2;
+      if (decompress3) {
+        var destroyed = false;
+        var inflateFilter = zlib4.createInflateRaw();
+        readStream2.on("error", function(err) {
+          setImmediate(function() {
+            if (!destroyed) inflateFilter.emit("error", err);
+          });
+        });
+        readStream2.pipe(inflateFilter);
+        if (self2.validateEntrySizes) {
+          endpointStream = new AssertByteCountStream(uncompressedSize);
+          inflateFilter.on("error", function(err) {
+            setImmediate(function() {
+              if (!destroyed) endpointStream.emit("error", err);
+            });
+          });
+          inflateFilter.pipe(endpointStream);
+        } else {
+          endpointStream = inflateFilter;
+        }
+        installDestroyFn(endpointStream, function() {
+          destroyed = true;
+          if (inflateFilter !== endpointStream) inflateFilter.unpipe(endpointStream);
+          readStream2.unpipe(inflateFilter);
+          readStream2.destroy();
+        });
+      }
+      callback(null, endpointStream);
+    };
+    ZipFile.prototype.readLocalFileHeader = function(entry, options2, callback) {
+      var self2 = this;
+      if (callback == null) {
+        callback = options2;
+        options2 = null;
+      }
+      if (options2 == null) options2 = {};
+      self2.reader.ref();
+      var buffer = newBuffer(30);
+      readAndAssertNoEof(self2.reader, buffer, 0, buffer.length, entry.relativeOffsetOfLocalHeader, function(err) {
+        try {
+          if (err) return callback(err);
+          var signature = buffer.readUInt32LE(0);
+          if (signature !== 67324752) {
+            return callback(new Error("invalid local file header signature: 0x" + signature.toString(16)));
+          }
+          var fileNameLength = buffer.readUInt16LE(26);
+          var extraFieldLength = buffer.readUInt16LE(28);
+          var fileDataStart = entry.relativeOffsetOfLocalHeader + 30 + fileNameLength + extraFieldLength;
+          if (fileDataStart + entry.compressedSize > self2.fileSize) {
+            return callback(new Error("file data overflows file bounds: " + fileDataStart + " + " + entry.compressedSize + " > " + self2.fileSize));
+          }
+          if (options2.minimal) {
+            return callback(null, { fileDataStart });
+          }
+          var localFileHeader = new LocalFileHeader();
+          localFileHeader.fileDataStart = fileDataStart;
+          localFileHeader.versionNeededToExtract = buffer.readUInt16LE(4);
+          localFileHeader.generalPurposeBitFlag = buffer.readUInt16LE(6);
+          localFileHeader.compressionMethod = buffer.readUInt16LE(8);
+          localFileHeader.lastModFileTime = buffer.readUInt16LE(10);
+          localFileHeader.lastModFileDate = buffer.readUInt16LE(12);
+          localFileHeader.crc32 = buffer.readUInt32LE(14);
+          localFileHeader.compressedSize = buffer.readUInt32LE(18);
+          localFileHeader.uncompressedSize = buffer.readUInt32LE(22);
+          localFileHeader.fileNameLength = fileNameLength;
+          localFileHeader.extraFieldLength = extraFieldLength;
+          buffer = newBuffer(fileNameLength + extraFieldLength);
+          self2.reader.ref();
+          readAndAssertNoEof(self2.reader, buffer, 0, buffer.length, entry.relativeOffsetOfLocalHeader + 30, function(err2) {
+            try {
+              if (err2) return callback(err2);
+              localFileHeader.fileName = buffer.subarray(0, fileNameLength);
+              localFileHeader.extraField = buffer.subarray(fileNameLength);
+              return callback(null, localFileHeader);
+            } finally {
+              self2.reader.unref();
+            }
+          });
+        } finally {
+          self2.reader.unref();
+        }
+      });
+    };
+    function Entry() {
+    }
+    Entry.prototype.getLastModDate = function(options2) {
+      if (options2 == null) options2 = {};
+      if (!options2.forceDosFormat) {
+        for (var i11 = 0; i11 < this.extraFields.length; i11++) {
+          var extraField = this.extraFields[i11];
+          if (extraField.id === 21589) {
+            var data2 = extraField.data;
+            if (data2.length < 5) continue;
+            var flags2 = data2[0];
+            var HAS_MTIME = 1;
+            if (!(flags2 & HAS_MTIME)) continue;
+            var posixTimestamp = data2.readInt32LE(1);
+            return new Date(posixTimestamp * 1e3);
+          } else if (extraField.id === 10) {
+            var data2 = extraField.data;
+            var cursor = 4;
+            while (cursor < data2.length + 4) {
+              var tag2 = data2.readUInt16LE(cursor);
+              cursor += 2;
+              var size2 = data2.readUInt16LE(cursor);
+              cursor += 2;
+              if (tag2 !== 1) {
+                cursor += size2;
+                continue;
+              }
+              if (size2 < 8 || cursor + size2 > data2.length) break;
+              var hundredNanoSecondsSince1601 = 4294967296 * data2.readInt32LE(cursor + 4) + data2.readUInt32LE(cursor);
+              var millisecondsSince1970 = hundredNanoSecondsSince1601 / 1e4 - 116444736e5;
+              return new Date(millisecondsSince1970);
+            }
+          }
+        }
+      }
+      return dosDateTimeToDate(this.lastModFileDate, this.lastModFileTime, options2.timezone);
+    };
+    Entry.prototype.isEncrypted = function() {
+      return (this.generalPurposeBitFlag & 1) !== 0;
+    };
+    Entry.prototype.isCompressed = function() {
+      return this.compressionMethod === 8;
+    };
+    function LocalFileHeader() {
+    }
+    function dosDateTimeToDate(date12, time3, timezone) {
+      var day = date12 & 31;
+      var month = (date12 >> 5 & 15) - 1;
+      var year = (date12 >> 9 & 127) + 1980;
+      var millisecond = 0;
+      var second = (time3 & 31) * 2;
+      var minute = time3 >> 5 & 63;
+      var hour = time3 >> 11 & 31;
+      if (timezone == null || timezone === "local") {
+        return new Date(year, month, day, hour, minute, second, millisecond);
+      } else if (timezone === "UTC") {
+        return new Date(Date.UTC(year, month, day, hour, minute, second, millisecond));
+      } else {
+        throw new Error("unrecognized options.timezone: " + options.timezone);
+      }
+    }
+    function getFileNameLowLevel(generalPurposeBitFlag, fileNameBuffer, extraFields, strictFileNames) {
+      var fileName = null;
+      for (var i11 = 0; i11 < extraFields.length; i11++) {
+        var extraField = extraFields[i11];
+        if (extraField.id === 28789) {
+          if (extraField.data.length < 6) {
+            continue;
+          }
+          if (extraField.data.readUInt8(0) !== 1) {
+            continue;
+          }
+          var oldNameCrc32 = extraField.data.readUInt32LE(1);
+          if (crc32.unsigned(fileNameBuffer) !== oldNameCrc32) {
+            continue;
+          }
+          fileName = decodeBuffer(extraField.data.subarray(5), true);
+          break;
+        }
+      }
+      if (fileName == null) {
+        var isUtf8 = (generalPurposeBitFlag & 2048) !== 0;
+        fileName = decodeBuffer(fileNameBuffer, isUtf8);
+      }
+      if (!strictFileNames) {
+        fileName = fileName.replace(/\\/g, "/");
+      }
+      return fileName;
+    }
+    function validateFileName(fileName) {
+      if (fileName.indexOf("\\") !== -1) {
+        return "invalid characters in fileName: " + fileName;
+      }
+      if (/^[a-zA-Z]:/.test(fileName) || /^\//.test(fileName)) {
+        return "absolute path: " + fileName;
+      }
+      if (fileName.split("/").indexOf("..") !== -1) {
+        return "invalid relative path: " + fileName;
+      }
+      return null;
+    }
+    function parseExtraFields(extraFieldBuffer) {
+      var extraFields = [];
+      var i11 = 0;
+      while (i11 < extraFieldBuffer.length - 3) {
+        var headerId = extraFieldBuffer.readUInt16LE(i11 + 0);
+        var dataSize = extraFieldBuffer.readUInt16LE(i11 + 2);
+        var dataStart = i11 + 4;
+        var dataEnd = dataStart + dataSize;
+        if (dataEnd > extraFieldBuffer.length) throw new Error("extra field length exceeds extra field buffer size");
+        var dataBuffer = extraFieldBuffer.subarray(dataStart, dataEnd);
+        extraFields.push({
+          id: headerId,
+          data: dataBuffer
+        });
+        i11 = dataEnd;
+      }
+      return extraFields;
+    }
+    function readAndAssertNoEof(reader, buffer, offset2, length, position4, callback) {
+      if (length === 0) {
+        return setImmediate(function() {
+          callback(null, newBuffer(0));
+        });
+      }
+      reader.read(buffer, offset2, length, position4, function(err, bytesRead) {
+        if (err) return callback(err);
+        if (bytesRead < length) {
+          return callback(new Error("unexpected EOF"));
+        }
+        callback();
+      });
+    }
+    util4.inherits(AssertByteCountStream, Transform);
+    function AssertByteCountStream(byteCount) {
+      Transform.call(this);
+      this.actualByteCount = 0;
+      this.expectedByteCount = byteCount;
+    }
+    AssertByteCountStream.prototype._transform = function(chunk2, encoding, cb2) {
+      this.actualByteCount += chunk2.length;
+      if (this.actualByteCount > this.expectedByteCount) {
+        var msg = "too many bytes in the stream. expected " + this.expectedByteCount + ". got at least " + this.actualByteCount;
+        return cb2(new Error(msg));
+      }
+      cb2(null, chunk2);
+    };
+    AssertByteCountStream.prototype._flush = function(cb2) {
+      if (this.actualByteCount < this.expectedByteCount) {
+        var msg = "not enough bytes in the stream. expected " + this.expectedByteCount + ". got only " + this.actualByteCount;
+        return cb2(new Error(msg));
+      }
+      cb2();
+    };
+    util4.inherits(RandomAccessReader, EventEmitter8);
+    function RandomAccessReader() {
+      EventEmitter8.call(this);
+      this.refCount = 0;
+    }
+    RandomAccessReader.prototype.ref = function() {
+      this.refCount += 1;
+    };
+    RandomAccessReader.prototype.unref = function() {
+      var self2 = this;
+      self2.refCount -= 1;
+      if (self2.refCount > 0) return;
+      if (self2.refCount < 0) throw new Error("invalid unref");
+      self2.close(onCloseDone);
+      function onCloseDone(err) {
+        if (err) return self2.emit("error", err);
+        self2.emit("close");
+      }
+    };
+    RandomAccessReader.prototype.createReadStream = function(options2) {
+      if (options2 == null) options2 = {};
+      var start2 = options2.start;
+      var end = options2.end;
+      if (start2 === end) {
+        var emptyStream = new PassThrough5();
+        setImmediate(function() {
+          emptyStream.end();
+        });
+        return emptyStream;
+      }
+      var stream5 = this._readStreamForRange(start2, end);
+      var destroyed = false;
+      var refUnrefFilter = new RefUnrefFilter(this);
+      stream5.on("error", function(err) {
+        setImmediate(function() {
+          if (!destroyed) refUnrefFilter.emit("error", err);
+        });
+      });
+      installDestroyFn(refUnrefFilter, function() {
+        stream5.unpipe(refUnrefFilter);
+        refUnrefFilter.unref();
+        stream5.destroy();
+      });
+      var byteCounter = new AssertByteCountStream(end - start2);
+      refUnrefFilter.on("error", function(err) {
+        setImmediate(function() {
+          if (!destroyed) byteCounter.emit("error", err);
+        });
+      });
+      installDestroyFn(byteCounter, function() {
+        destroyed = true;
+        refUnrefFilter.unpipe(byteCounter);
+        refUnrefFilter.destroy();
+      });
+      return stream5.pipe(refUnrefFilter).pipe(byteCounter);
+    };
+    RandomAccessReader.prototype._readStreamForRange = function(start2, end) {
+      throw new Error("not implemented");
+    };
+    RandomAccessReader.prototype.read = function(buffer, offset2, length, position4, callback) {
+      var readStream2 = this.createReadStream({ start: position4, end: position4 + length });
+      var writeStream = new Writable2();
+      var written = 0;
+      writeStream._write = function(chunk2, encoding, cb2) {
+        chunk2.copy(buffer, offset2 + written, 0, chunk2.length);
+        written += chunk2.length;
+        cb2();
+      };
+      writeStream.on("finish", callback);
+      readStream2.on("error", function(error49) {
+        callback(error49);
+      });
+      readStream2.pipe(writeStream);
+    };
+    RandomAccessReader.prototype.close = function(callback) {
+      setImmediate(callback);
+    };
+    util4.inherits(RefUnrefFilter, PassThrough5);
+    function RefUnrefFilter(context2) {
+      PassThrough5.call(this);
+      this.context = context2;
+      this.context.ref();
+      this.unreffedYet = false;
+    }
+    RefUnrefFilter.prototype._flush = function(cb2) {
+      this.unref();
+      cb2();
+    };
+    RefUnrefFilter.prototype.unref = function(cb2) {
+      if (this.unreffedYet) return;
+      this.unreffedYet = true;
+      this.context.unref();
+    };
+    var cp437 = "\0\u263A\u263B\u2665\u2666\u2663\u2660\u2022\u25D8\u25CB\u25D9\u2642\u2640\u266A\u266B\u263C\u25BA\u25C4\u2195\u203C\xB6\xA7\u25AC\u21A8\u2191\u2193\u2192\u2190\u221F\u2194\u25B2\u25BC !\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~\u2302\xC7\xFC\xE9\xE2\xE4\xE0\xE5\xE7\xEA\xEB\xE8\xEF\xEE\xEC\xC4\xC5\xC9\xE6\xC6\xF4\xF6\xF2\xFB\xF9\xFF\xD6\xDC\xA2\xA3\xA5\u20A7\u0192\xE1\xED\xF3\xFA\xF1\xD1\xAA\xBA\xBF\u2310\xAC\xBD\xBC\xA1\xAB\xBB\u2591\u2592\u2593\u2502\u2524\u2561\u2562\u2556\u2555\u2563\u2551\u2557\u255D\u255C\u255B\u2510\u2514\u2534\u252C\u251C\u2500\u253C\u255E\u255F\u255A\u2554\u2569\u2566\u2560\u2550\u256C\u2567\u2568\u2564\u2565\u2559\u2558\u2552\u2553\u256B\u256A\u2518\u250C\u2588\u2584\u258C\u2590\u2580\u03B1\xDF\u0393\u03C0\u03A3\u03C3\xB5\u03C4\u03A6\u0398\u03A9\u03B4\u221E\u03C6\u03B5\u2229\u2261\xB1\u2265\u2264\u2320\u2321\xF7\u2248\xB0\u2219\xB7\u221A\u207F\xB2\u25A0\xA0";
+    function decodeBuffer(buffer, isUtf8) {
+      if (isUtf8) {
+        return buffer.toString("utf8");
+      } else {
+        var result = "";
+        for (var i11 = 0; i11 < buffer.length; i11++) {
+          result += cp437[buffer[i11]];
+        }
+        return result;
+      }
+    }
+    function readUInt64LE(buffer, offset2) {
+      var lower32 = buffer.readUInt32LE(offset2);
+      var upper32 = buffer.readUInt32LE(offset2 + 4);
+      return upper32 * 4294967296 + lower32;
+    }
+    var newBuffer;
+    if (typeof Buffer.allocUnsafe === "function") {
+      newBuffer = function(len) {
+        return Buffer.allocUnsafe(len);
+      };
+    } else {
+      newBuffer = function(len) {
+        return new Buffer(len);
+      };
+    }
+    function installDestroyFn(stream5, fn4) {
+      if (typeof stream5.destroy === "function") {
+        stream5._destroy = function(err, cb2) {
+          fn4();
+          if (cb2 != null) cb2(err);
+        };
+      } else {
+        stream5.destroy = fn4;
+      }
+    }
+    function defaultCallback(err) {
+      if (err) throw err;
+    }
+  }
+});
+
 // ../../../node_modules/.pnpm/acorn-jsx@5.3.2_acorn@8.15.0/node_modules/acorn-jsx/xhtml.js
 var require_xhtml = __commonJS({
   "../../../node_modules/.pnpm/acorn-jsx@5.3.2_acorn@8.15.0/node_modules/acorn-jsx/xhtml.js"(exports2, module4) {
@@ -1347190,8 +1348203,8 @@ var require_extract_zip = __commonJS({
     var path86 = require("path");
     var { promisify: promisify4 } = require("util");
     var stream5 = require("stream");
-    var yauzl = require_yauzl();
-    var openZip = promisify4(yauzl.open);
+    var yauzl2 = require_yauzl();
+    var openZip = promisify4(yauzl2.open);
     var pipeline5 = promisify4(stream5.pipeline);
     var Extractor = class {
       constructor(zipPath, opts) {
@@ -1426227,7 +1427240,7 @@ var AccessTokenPosthogManager = class {
         properties: {
           ...event,
           ...event.properties,
-          version: "3.64.2",
+          version: "3.64.3",
           usingAccessToken: true
         }
       });
@@ -1426326,7 +1427339,7 @@ var UserPosthogManager = class {
       distinctId: this.userId ?? await this.getPersistedDistinctId(),
       event: "CLI",
       properties: {
-        version: "3.64.2",
+        version: "3.64.3",
         ...event,
         ...event.properties,
         usingAccessToken: false,
@@ -1628012,7 +1629025,6 @@ function pollJobAndReportStatus({ job, taskId, taskHandler, context: context2 })
 }
 
 // ../generation/remote-generation/remote-workspace-runner/lib/RemoteTaskHandler.js
-var import_decompress2 = __toESM(require_decompress(), 1);
 var import_fs20 = require("fs");
 var import_promises65 = require("fs/promises");
 var import_path48 = __toESM(require("path"), 1);
@@ -1628035,6 +1629047,7 @@ terminalLink.stderr.isSupported = import_supports_hyperlinks.default.stderr;
 
 // ../generation/remote-generation/remote-workspace-runner/lib/RemoteTaskHandler.js
 var import_tmp_promise11 = __toESM(require_tmp_promise(), 1);
+var import_yauzl = __toESM(require_yauzl2(), 1);
 var RemoteTaskHandler = class {
   context;
   generatorInvocation;
@@ -1628187,7 +1629200,7 @@ async function downloadZipForTask({ s3PreSignedReadUrl, absolutePathToLocalOutpu
   await (0, import_promises66.pipeline)(request6.data, (0, import_fs20.createWriteStream)(outputZipPath));
   await forceRemoveDirectory(absolutePathToLocalOutput);
   await (0, import_promises65.mkdir)(absolutePathToLocalOutput, { recursive: true });
-  await (0, import_decompress2.default)(outputZipPath, absolutePathToLocalOutput);
+  await extractZipToDirectory(outputZipPath, absolutePathToLocalOutput);
 }
 async function forceRemoveDirectory(dirPath) {
   if (!await doesPathExist(dirPath)) {
@@ -1628285,7 +1629298,36 @@ async function downloadAndExtractZipToDirectory({ s3PreSignedReadUrl, outputPath
   const tmpDir = await import_tmp_promise11.default.dir({ prefix: "fern", unsafeCleanup: true });
   const outputZipPath = import_path48.default.join(tmpDir.path, "output.zip");
   await (0, import_promises66.pipeline)(request6.data, (0, import_fs20.createWriteStream)(outputZipPath));
-  await (0, import_decompress2.default)(outputZipPath, outputPath);
+  await extractZipToDirectory(outputZipPath, outputPath);
+}
+async function extractZipToDirectory(zipPath, outputDir) {
+  return new Promise((resolve10, reject) => {
+    import_yauzl.default.open(zipPath, { lazyEntries: true }, (err, zipFile) => {
+      if (err || !zipFile) {
+        reject(err ?? new Error("Failed to open zip file"));
+        return;
+      }
+      zipFile.on("error", reject);
+      zipFile.on("end", resolve10);
+      zipFile.on("entry", (entry) => {
+        const outputPath = import_path48.default.join(outputDir, entry.fileName);
+        if (entry.fileName.endsWith("/")) {
+          (0, import_promises65.mkdir)(outputPath, { recursive: true }).then(() => zipFile.readEntry()).catch(reject);
+          return;
+        }
+        (0, import_promises65.mkdir)(import_path48.default.dirname(outputPath), { recursive: true }).then(() => {
+          zipFile.openReadStream(entry, (streamErr, readStream2) => {
+            if (streamErr || !readStream2) {
+              reject(streamErr ?? new Error("Failed to open read stream"));
+              return;
+            }
+            readStream2.pipe((0, import_fs20.createWriteStream)(outputPath)).on("finish", () => zipFile.readEntry()).on("error", reject);
+          });
+        }).catch(reject);
+      });
+      zipFile.readEntry();
+    });
+  });
 }
 
 // ../generation/remote-generation/remote-workspace-runner/lib/SourceUploader.js
@@ -1712562,7 +1713604,7 @@ var CliContext = class {
     if (false) {
       this.logger.error("CLI_VERSION is not defined");
     }
-    return "3.64.2";
+    return "3.64.3";
   }
   getCliName() {
     if (false) {
@@ -1715676,7 +1716718,7 @@ var import_path56 = __toESM(require("path"), 1);
 var LOCAL_STORAGE_FOLDER4 = ".fern-dev";
 var LOGS_FOLDER_NAME = "logs";
 function getCliSource() {
-  const version7 = "3.64.2";
+  const version7 = "3.64.3";
   return `cli@${version7}`;
 }
 var DebugLogger = class {
@@ -1715850,7 +1716892,7 @@ var DebugLogger = class {
 
 // ../docs-preview/lib/downloadLocalDocsBundle.js
 var import_cli_progress = __toESM(require_cli_progress(), 1);
-var import_decompress3 = __toESM(require_decompress(), 1);
+var import_decompress2 = __toESM(require_decompress(), 1);
 var import_promises98 = require("fs/promises");
 var import_os9 = require("os");
 var import_tmp_promise16 = __toESM(require_tmp_promise(), 1);
@@ -1716035,7 +1717077,7 @@ async function downloadBundle({ bucketUrl, logger, preferCached, app = false, tr
       }, 50);
     }
     try {
-      await (0, import_decompress3.default)(outputZipPath, absolutePathToBundleFolder, {
+      await (0, import_decompress2.default)(outputZipPath, absolutePathToBundleFolder, {
         filter: (file4) => !(PLATFORM_IS_WINDOWS && file4.type === "symlink")
       });
     } finally {

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "3.64.2",
+  "version": "3.64.3",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/fern-api/fern.git",