chatlab-cli 0.27.2 → 0.28.0

package/dist/{chunk-DHRSLYUM.mjs → chunk-GPF34WXV.mjs}

@@ -51,6 +51,8 @@ import {
   deriveParentId,
   detectConflictsInMessages,
   estimateTokens,
+  extractErrorInfo,
+  extractErrorStack,
   extractFtsKeywords,
   formatEvidenceMessages,
   generateMessageKey,
@@ -82,7 +84,7 @@ import {
   vecTableName,
   vecTableSchema,
   writeConfigField
-} from "./chunk-B2VLK3FB.mjs";
+} from "./chunk-55WR6WKW.mjs";
 import {
   __commonJS,
   __export,
@@ -97,8 +99,8 @@ var require_Utf8Stream = __commonJS({
     var { Transform } = __require("stream");
     var { StringDecoder } = __require("string_decoder");
     var Utf8Stream = class extends Transform {
-      constructor(options) {
-        super(Object.assign({}, options, { writableObjectMode: false }));
+      constructor(options2) {
+        super(Object.assign({}, options2, { writableObjectMode: false }));
         this._buffer = "";
       }
       _transform(chunk, encoding, callback) {
@@ -178,22 +180,22 @@ var require_Parser = __commonJS({
     var fromHex = (s) => String.fromCharCode(parseInt(s.slice(2), 16));
     var codes = { b: "\b", f: "\f", n: "\n", r: "\r", t: "	", '"': '"', "\\": "\\", "/": "/" };
     var Parser = class _Parser extends Utf8Stream {
-      static make(options) {
-        return new _Parser(options);
+      static make(options2) {
+        return new _Parser(options2);
       }
-      constructor(options) {
-        super(Object.assign({}, options, { readableObjectMode: true }));
+      constructor(options2) {
+        super(Object.assign({}, options2, { readableObjectMode: true }));
         this._packKeys = this._packStrings = this._packNumbers = this._streamKeys = this._streamStrings = this._streamNumbers = true;
-        if (options) {
-          "packValues" in options && (this._packKeys = this._packStrings = this._packNumbers = options.packValues);
-          "packKeys" in options && (this._packKeys = options.packKeys);
-          "packStrings" in options && (this._packStrings = options.packStrings);
-          "packNumbers" in options && (this._packNumbers = options.packNumbers);
-          "streamValues" in options && (this._streamKeys = this._streamStrings = this._streamNumbers = options.streamValues);
-          "streamKeys" in options && (this._streamKeys = options.streamKeys);
-          "streamStrings" in options && (this._streamStrings = options.streamStrings);
-          "streamNumbers" in options && (this._streamNumbers = options.streamNumbers);
-          this._jsonStreaming = options.jsonStreaming;
+        if (options2) {
+          "packValues" in options2 && (this._packKeys = this._packStrings = this._packNumbers = options2.packValues);
+          "packKeys" in options2 && (this._packKeys = options2.packKeys);
+          "packStrings" in options2 && (this._packStrings = options2.packStrings);
+          "packNumbers" in options2 && (this._packNumbers = options2.packNumbers);
+          "streamValues" in options2 && (this._streamKeys = this._streamStrings = this._streamNumbers = options2.streamValues);
+          "streamKeys" in options2 && (this._streamKeys = options2.streamKeys);
+          "streamStrings" in options2 && (this._streamStrings = options2.streamStrings);
+          "streamNumbers" in options2 && (this._streamNumbers = options2.streamNumbers);
+          this._jsonStreaming = options2.jsonStreaming;
         }
         !this._packKeys && (this._streamKeys = true);
         !this._packStrings && (this._streamStrings = true);
@@ -683,7 +685,7 @@ var require_stream_json = __commonJS({
     "use strict";
     var Parser = require_Parser();
     var emit = require_emit();
-    var make = (options) => emit(new Parser(options));
+    var make = (options2) => emit(new Parser(options2));
     make.Parser = Parser;
     make.parser = Parser.parser;
     module.exports = make;
@@ -698,8 +700,8 @@ var require_FilterBase = __commonJS({
     var FilterBase = class _FilterBase extends Transform {
       static stringFilter(string, separator) {
         return (stack) => {
-          const path19 = stack.join(separator);
-          return path19.length === string.length && path19 === string || path19.length > string.length && path19.substr(0, string.length) === string && path19.substr(string.length, separator.length) === separator;
+          const path24 = stack.join(separator);
+          return path24.length === string.length && path24 === string || path24.length > string.length && path24.substr(0, string.length) === string && path24.substr(string.length, separator.length) === separator;
         };
       }
       static regExpFilter(regExp, separator) {
@@ -708,11 +710,11 @@ var require_FilterBase = __commonJS({
       static arrayReplacement(array) {
         return () => array;
       }
-      constructor(options) {
-        super(Object.assign({}, options, { writableObjectMode: true, readableObjectMode: true }));
+      constructor(options2) {
+        super(Object.assign({}, options2, { writableObjectMode: true, readableObjectMode: true }));
         this._transform = this._check;
         this._stack = [];
-        const filter = options && options.filter, separator = options && options.pathSeparator || ".";
+        const filter = options2 && options2.filter, separator = options2 && options2.pathSeparator || ".";
         if (typeof filter == "string") {
           this._filter = _FilterBase.stringFilter(filter, separator);
         } else if (typeof filter == "function") {
@@ -720,19 +722,19 @@ var require_FilterBase = __commonJS({
         } else if (filter instanceof RegExp) {
           this._filter = _FilterBase.regExpFilter(filter, separator);
         }
-        const replacement = options && options.replacement;
+        const replacement = options2 && options2.replacement;
         if (typeof replacement == "function") {
           this._replacement = replacement;
         } else {
           this._replacement = _FilterBase.arrayReplacement(replacement || _FilterBase.defaultReplacement);
         }
-        this._allowEmptyReplacement = options && options.allowEmptyReplacement;
+        this._allowEmptyReplacement = options2 && options2.allowEmptyReplacement;
         this._streamKeys = true;
-        if (options) {
-          "streamValues" in options && (this._streamKeys = options.streamValues);
-          "streamKeys" in options && (this._streamKeys = options.streamKeys);
+        if (options2) {
+          "streamValues" in options2 && (this._streamKeys = options2.streamValues);
+          "streamKeys" in options2 && (this._streamKeys = options2.streamKeys);
         }
-        this._once = options && options.once;
+        this._once = options2 && options2.once;
         this._previousToken = "";
       }
       _check(chunk, _, callback) {
@@ -950,8 +952,8 @@ var require_stream_chain = __commonJS({
     var isWritableNodeStream = (obj) => obj && typeof obj.write === "function" && typeof obj.on === "function" && (!obj._readableState || (typeof obj._writableState === "object" ? obj._writableState.writable : null) !== false);
     var isDuplexNodeStream = (obj) => obj && typeof obj.pipe === "function" && obj._readableState && typeof obj.on === "function" && typeof obj.write === "function";
     var Chain = class _Chain extends Duplex {
-      constructor(fns, options) {
-        super(options || { writableObjectMode: true, readableObjectMode: true });
+      constructor(fns, options2) {
+        super(options2 || { writableObjectMode: true, readableObjectMode: true });
         if (!(fns instanceof Array) || !fns.length) {
           throw Error("Chain's argument should be a non-empty array.");
         }
@@ -978,7 +980,7 @@ var require_stream_chain = __commonJS({
           this.resume();
           this.output.on("finish", () => this.push(null));
         }
-        if (!options || !options.skipEvents) {
+        if (!options2 || !options2.skipEvents) {
           this.streams.forEach((stream) => stream.on("error", (error) => this.emit("error", error)));
         }
       }
@@ -1001,8 +1003,8 @@ var require_stream_chain = __commonJS({
       _read() {
         this.output.resume();
       }
-      static make(fns, options) {
-        return new _Chain(fns, options);
+      static make(fns, options2) {
+        return new _Chain(fns, options2);
       }
       static sanitize(result, stream) {
         if (_Chain.isFinal(result)) {
@@ -1041,9 +1043,9 @@ var require_stream_chain = __commonJS({
 var require_withParser = __commonJS({
   "../../node_modules/stream-json/utils/withParser.js"(exports, module) {
     "use strict";
-    var { chain: chain8 } = require_stream_chain();
+    var { chain: chain10 } = require_stream_chain();
     var Parser = require_Parser();
-    var withParser = (fn, options) => chain8([new Parser(options), fn(options)], Object.assign({}, options, { writableObjectMode: false, readableObjectMode: true }));
+    var withParser = (fn, options2) => chain10([new Parser(options2), fn(options2)], Object.assign({}, options2, { writableObjectMode: false, readableObjectMode: true }));
     module.exports = withParser;
   }
 });
@@ -1055,11 +1057,11 @@ var require_Pick = __commonJS({
     var FilterBase = require_FilterBase();
     var withParser = require_withParser();
     var Pick = class _Pick extends FilterBase {
-      static make(options) {
-        return new _Pick(options);
+      static make(options2) {
+        return new _Pick(options2);
       }
-      static withParser(options) {
-        return withParser(_Pick.make, options);
+      static withParser(options2) {
+        return withParser(_Pick.make, options2);
       }
       _checkChunk(chunk) {
         switch (chunk.name) {
@@ -1122,20 +1124,20 @@ var require_Assembler = __commonJS({
       this.key = null;
     };
     var Assembler = class _Assembler extends EventEmitter {
-      static connectTo(stream, options) {
-        return new _Assembler(options).connectTo(stream);
+      static connectTo(stream, options2) {
+        return new _Assembler(options2).connectTo(stream);
       }
-      constructor(options) {
+      constructor(options2) {
         super();
         this.stack = [];
         this.current = this.key = null;
         this.done = true;
-        if (options) {
-          this.reviver = typeof options.reviver == "function" && options.reviver;
+        if (options2) {
+          this.reviver = typeof options2.reviver == "function" && options2.reviver;
           if (this.reviver) {
             this.stringValue = this._saveValue = this._saveValueWithReviver;
           }
-          if (options.numberAsString) {
+          if (options2.numberAsString) {
             this.numberValue = this.stringValue;
           }
         }
@@ -1153,12 +1155,12 @@ var require_Assembler = __commonJS({
         return (this.stack.length >> 1) + (this.done ? 0 : 1);
       }
       get path() {
-        const path19 = [];
+        const path24 = [];
         for (let i = 0; i < this.stack.length; i += 2) {
           const key = this.stack[i + 1];
-          path19.push(key === null ? this.stack[i].length : key);
+          path24.push(key === null ? this.stack[i].length : key);
         }
-        return path19;
+        return path24;
       }
       dropToLevel(level) {
         if (level < this.depth) {
@@ -1272,17 +1274,17 @@ var require_StreamBase = __commonJS({
       }
     };
     var StreamBase = class extends Transform {
-      constructor(options) {
-        super(Object.assign({}, options, { writableObjectMode: true, readableObjectMode: true }));
-        if (options) {
-          this.objectFilter = options.objectFilter;
-          this.includeUndecided = options.includeUndecided;
+      constructor(options2) {
+        super(Object.assign({}, options2, { writableObjectMode: true, readableObjectMode: true }));
+        if (options2) {
+          this.objectFilter = options2.objectFilter;
+          this.includeUndecided = options2.includeUndecided;
         }
         if (typeof this.objectFilter != "function") {
           this._filter = this._transform;
         }
         this._transform = this._wait || this._filter;
-        this._assembler = new Assembler(options);
+        this._assembler = new Assembler(options2);
       }
       _transform(chunk, encoding, callback) {
         if (this._assembler[chunk.name]) {
@@ -1354,14 +1356,14 @@ var require_StreamValues = __commonJS({
     var StreamBase = require_StreamBase();
     var withParser = require_withParser();
     var StreamValues = class _StreamValues extends StreamBase {
-      static make(options) {
-        return new _StreamValues(options);
+      static make(options2) {
+        return new _StreamValues(options2);
       }
-      static withParser(options) {
-        return withParser(_StreamValues.make, Object.assign({}, options, { jsonStreaming: true }));
+      static withParser(options2) {
+        return withParser(_StreamValues.make, Object.assign({}, options2, { jsonStreaming: true }));
       }
-      constructor(options) {
-        super(options);
+      constructor(options2) {
+        super(options2);
         this._counter = 0;
         this._level = 0;
       }
@@ -1380,6 +1382,1353 @@ var require_StreamValues = __commonJS({
   }
 });
 
+// ../../node_modules/pend/index.js
+var require_pend = __commonJS({
+  "../../node_modules/pend/index.js"(exports, module) {
+    "use strict";
+    module.exports = Pend;
+    function Pend() {
+      this.pending = 0;
+      this.max = Infinity;
+      this.listeners = [];
+      this.waiting = [];
+      this.error = null;
+    }
+    Pend.prototype.go = function(fn) {
+      if (this.pending < this.max) {
+        pendGo(this, fn);
+      } else {
+        this.waiting.push(fn);
+      }
+    };
+    Pend.prototype.wait = function(cb) {
+      if (this.pending === 0) {
+        cb(this.error);
+      } else {
+        this.listeners.push(cb);
+      }
+    };
+    Pend.prototype.hold = function() {
+      return pendHold(this);
+    };
+    function pendHold(self) {
+      self.pending += 1;
+      var called = false;
+      return onCb;
+      function onCb(err) {
+        if (called) throw new Error("callback called twice");
+        called = true;
+        self.error = self.error || err;
+        self.pending -= 1;
+        if (self.waiting.length > 0 && self.pending < self.max) {
+          pendGo(self, self.waiting.shift());
+        } else if (self.pending === 0) {
+          var listeners = self.listeners;
+          self.listeners = [];
+          listeners.forEach(cbListener);
+        }
+      }
+      function cbListener(listener) {
+        listener(self.error);
+      }
+    }
+    function pendGo(self, fn) {
+      fn(pendHold(self));
+    }
+  }
+});
+
+// ../../packages/node-runtime/node_modules/yauzl/fd-slicer.js
+var require_fd_slicer = __commonJS({
+  "../../packages/node-runtime/node_modules/yauzl/fd-slicer.js"(exports) {
+    "use strict";
+    var fs29 = __require("fs");
+    var util = __require("util");
+    var stream = __require("stream");
+    var Readable = stream.Readable;
+    var PassThrough = stream.PassThrough;
+    var Pend = require_pend();
+    var EventEmitter = __require("events").EventEmitter;
+    exports.BufferSlicer = BufferSlicer;
+    exports.FdSlicer = FdSlicer;
+    util.inherits(FdSlicer, EventEmitter);
+    function FdSlicer(fd) {
+      EventEmitter.call(this);
+      this.fd = fd;
+      this.pend = new Pend();
+      this.pend.max = 1;
+      this.refCount = 0;
+    }
+    FdSlicer.prototype.read = function(buffer, offset, length, position, callback) {
+      var self = this;
+      self.pend.go(function(cb) {
+        fs29.read(self.fd, buffer, offset, length, position, function(err, bytesRead, buffer2) {
+          cb();
+          callback(err, bytesRead, buffer2);
+        });
+      });
+    };
+    FdSlicer.prototype.createReadStream = function(options2) {
+      return new ReadStream(this, options2);
+    };
+    FdSlicer.prototype.ref = function() {
+      this.refCount += 1;
+    };
+    FdSlicer.prototype.unref = function() {
+      var self = this;
+      self.refCount -= 1;
+      if (self.refCount < 0) throw new Error("invalid unref");
+      if (self.refCount > 0) return;
+      fs29.close(self.fd, onCloseDone);
+      function onCloseDone(err) {
+        if (err) {
+          self.emit("error", err);
+        } else {
+          self.emit("close");
+        }
+      }
+    };
+    util.inherits(ReadStream, Readable);
+    function ReadStream(context, options2) {
+      options2 = options2 || {};
+      Readable.call(this, options2);
+      this.context = context;
+      this.context.ref();
+      this.start = options2.start || 0;
+      this.endOffset = options2.end;
+      this.pos = this.start;
+    }
+    ReadStream.prototype._read = function(n) {
+      var self = this;
+      var toRead = Math.min(self._readableState.highWaterMark, n);
+      if (self.endOffset != null) {
+        toRead = Math.min(toRead, self.endOffset - self.pos);
+      }
+      if (toRead <= 0) {
+        self.push(null);
+        this._cleanup();
+        return;
+      }
+      self.context.pend.go(function(cb) {
+        var buffer = Buffer.allocUnsafe(toRead);
+        fs29.read(self.context.fd, buffer, 0, toRead, self.pos, function(err, bytesRead) {
+          if (err) {
+            self.destroy(err);
+          } else if (bytesRead === 0) {
+            self.push(null);
+            self._cleanup();
+          } else {
+            self.pos += bytesRead;
+            self.push(buffer.slice(0, bytesRead));
+          }
+          cb();
+        });
+      });
+    };
+    ReadStream.prototype._destroy = function(err, cb) {
+      this._cleanup();
+      cb(err);
+    };
+    ReadStream.prototype._cleanup = function() {
+      if (this.context != null) {
+        this.context.unref();
+        this.context = null;
+      }
+    };
+    util.inherits(BufferSlicer, EventEmitter);
+    function BufferSlicer(buffer) {
+      EventEmitter.call(this);
+      this.refCount = 0;
+      this.buffer = buffer;
+    }
+    BufferSlicer.prototype.read = function(buffer, offset, length, position, callback) {
+      if (!(0 <= offset && offset <= buffer.length)) throw new RangeError("offset outside buffer: 0 <= " + offset + " <= " + buffer.length);
+      if (position < 0) throw new RangeError("position is negative: " + position);
+      if (offset + length > buffer.length) {
+        length = buffer.length - offset;
+      }
+      if (position + length > this.buffer.length) {
+        length = this.buffer.length - position;
+      }
+      if (length <= 0) {
+        setImmediate(function() {
+          callback(null, 0);
+        });
+        return;
+      }
+      this.buffer.copy(buffer, offset, position, position + length);
+      setImmediate(function() {
+        callback(null, length);
+      });
+    };
+    BufferSlicer.prototype.createReadStream = function(options2) {
+      options2 = options2 || {};
+      var readStream = new PassThrough(options2);
+      readStream.start = options2.start || 0;
+      readStream.endOffset = options2.end;
+      readStream.pos = readStream.endOffset || this.buffer.length;
+      var entireSlice = this.buffer.slice(readStream.start, readStream.pos);
+      var maxChunkSize = 65536;
+      var offset = 0;
+      while (true) {
+        var nextOffset = offset + maxChunkSize;
+        if (nextOffset >= entireSlice.length) {
+          if (offset < entireSlice.length) {
+            readStream.write(entireSlice.slice(offset, entireSlice.length));
+          }
+          break;
+        }
+        readStream.write(entireSlice.slice(offset, nextOffset));
+        offset = nextOffset;
+      }
+      readStream.end();
+      return readStream;
+    };
+    BufferSlicer.prototype.ref = function() {
+      this.refCount += 1;
+    };
+    BufferSlicer.prototype.unref = function() {
+      this.refCount -= 1;
+      if (this.refCount < 0) {
+        throw new Error("invalid unref");
+      }
+    };
+  }
+});
+
+// ../../packages/node-runtime/node_modules/yauzl/crc32.js
+var require_crc32 = __commonJS({
+  "../../packages/node-runtime/node_modules/yauzl/crc32.js"(exports, module) {
+    "use strict";
+    var CRC_TABLE = new Int32Array([
+      0,
+      1996959894,
+      3993919788,
+      2567524794,
+      124634137,
+      1886057615,
+      3915621685,
+      2657392035,
+      249268274,
+      2044508324,
+      3772115230,
+      2547177864,
+      162941995,
+      2125561021,
+      3887607047,
+      2428444049,
+      498536548,
+      1789927666,
+      4089016648,
+      2227061214,
+      450548861,
+      1843258603,
+      4107580753,
+      2211677639,
+      325883990,
+      1684777152,
+      4251122042,
+      2321926636,
+      335633487,
+      1661365465,
+      4195302755,
+      2366115317,
+      997073096,
+      1281953886,
+      3579855332,
+      2724688242,
+      1006888145,
+      1258607687,
+      3524101629,
+      2768942443,
+      901097722,
+      1119000684,
+      3686517206,
+      2898065728,
+      853044451,
+      1172266101,
+      3705015759,
+      2882616665,
+      651767980,
+      1373503546,
+      3369554304,
+      3218104598,
+      565507253,
+      1454621731,
+      3485111705,
+      3099436303,
+      671266974,
+      1594198024,
+      3322730930,
+      2970347812,
+      795835527,
+      1483230225,
+      3244367275,
+      3060149565,
+      1994146192,
+      31158534,
+      2563907772,
+      4023717930,
+      1907459465,
+      112637215,
+      2680153253,
+      3904427059,
+      2013776290,
+      251722036,
+      2517215374,
+      3775830040,
+      2137656763,
+      141376813,
+      2439277719,
+      3865271297,
+      1802195444,
+      476864866,
+      2238001368,
+      4066508878,
+      1812370925,
+      453092731,
+      2181625025,
+      4111451223,
+      1706088902,
+      314042704,
+      2344532202,
+      4240017532,
+      1658658271,
+      366619977,
+      2362670323,
+      4224994405,
+      1303535960,
+      984961486,
+      2747007092,
+      3569037538,
+      1256170817,
+      1037604311,
+      2765210733,
+      3554079995,
+      1131014506,
+      879679996,
+      2909243462,
+      3663771856,
+      1141124467,
+      855842277,
+      2852801631,
+      3708648649,
+      1342533948,
+      654459306,
+      3188396048,
+      3373015174,
+      1466479909,
+      544179635,
+      3110523913,
+      3462522015,
+      1591671054,
+      702138776,
+      2966460450,
+      3352799412,
+      1504918807,
+      783551873,
+      3082640443,
+      3233442989,
+      3988292384,
+      2596254646,
+      62317068,
+      1957810842,
+      3939845945,
+      2647816111,
+      81470997,
+      1943803523,
+      3814918930,
+      2489596804,
+      225274430,
+      2053790376,
+      3826175755,
+      2466906013,
+      167816743,
+      2097651377,
+      4027552580,
+      2265490386,
+      503444072,
+      1762050814,
+      4150417245,
+      2154129355,
+      426522225,
+      1852507879,
+      4275313526,
+      2312317920,
+      282753626,
+      1742555852,
+      4189708143,
+      2394877945,
+      397917763,
+      1622183637,
+      3604390888,
+      2714866558,
+      953729732,
+      1340076626,
+      3518719985,
+      2797360999,
+      1068828381,
+      1219638859,
+      3624741850,
+      2936675148,
+      906185462,
+      1090812512,
+      3747672003,
+      2825379669,
+      829329135,
+      1181335161,
+      3412177804,
+      3160834842,
+      628085408,
+      1382605366,
+      3423369109,
+      3138078467,
+      570562233,
+      1426400815,
+      3317316542,
+      2998733608,
+      733239954,
+      1555261956,
+      3268935591,
+      3050360625,
+      752459403,
+      1541320221,
+      2607071920,
+      3965973030,
+      1969922972,
+      40735498,
+      2617837225,
+      3943577151,
+      1913087877,
+      83908371,
+      2512341634,
+      3803740692,
+      2075208622,
+      213261112,
+      2463272603,
+      3855990285,
+      2094854071,
+      198958881,
+      2262029012,
+      4057260610,
+      1759359992,
+      534414190,
+      2176718541,
+      4139329115,
+      1873836001,
+      414664567,
+      2282248934,
+      4279200368,
+      1711684554,
+      285281116,
+      2405801727,
+      4167216745,
+      1634467795,
+      376229701,
+      2685067896,
+      3608007406,
+      1308918612,
+      956543938,
+      2808555105,
+      3495958263,
+      1231636301,
+      1047427035,
+      2932959818,
+      3654703836,
+      1088359270,
+      936918e3,
+      2847714899,
+      3736837829,
+      1202900863,
+      817233897,
+      3183342108,
+      3401237130,
+      1404277552,
+      615818150,
+      3134207493,
+      3453421203,
+      1423857449,
+      601450431,
+      3009837614,
+      3294710456,
+      1567103746,
+      711928724,
+      3020668471,
+      3272380065,
+      1510334235,
+      755167117
+    ]);
+    function crc32(buf) {
+      let crc = -1;
+      for (let x of buf) {
+        crc = CRC_TABLE[(crc ^ x) & 255] ^ crc >>> 8;
+      }
+      return (crc ^ -1) >>> 0;
+    }
+    module.exports = crc32;
+  }
+});
+
+// ../../packages/node-runtime/node_modules/yauzl/index.js
+var require_yauzl = __commonJS({
+  "../../packages/node-runtime/node_modules/yauzl/index.js"(exports) {
+    "use strict";
+    var fs29 = __require("fs");
+    var zlib = __require("zlib");
+    var fd_slicer = require_fd_slicer();
+    var util = __require("util");
+    var EventEmitter = __require("events").EventEmitter;
+    var Transform = __require("stream").Transform;
+    var PassThrough = __require("stream").PassThrough;
+    var Writable = __require("stream").Writable;
+    var crc32 = typeof zlib.crc32 === "function" ? zlib.crc32 : require_crc32();
+    exports.open = open;
+    exports.fromFd = fromFd;
+    exports.fromBuffer = fromBuffer;
+    exports.fromRandomAccessReader = fromRandomAccessReader;
+    exports.openPromise = openPromise2;
+    exports.fromFdPromise = fromFdPromise;
+    exports.fromBufferPromise = fromBufferPromise;
+    exports.fromRandomAccessReaderPromise = fromRandomAccessReaderPromise;
+    exports.dosDateTimeToDate = dosDateTimeToDate;
+    exports.getFileNameLowLevel = getFileNameLowLevel;
+    exports.validateFileName = validateFileName;
+    exports.parseExtraFields = parseExtraFields;
+    exports.ZipFile = ZipFile;
+    exports.Entry = Entry;
+    exports.LocalFileHeader = LocalFileHeader;
+    exports.RandomAccessReader = RandomAccessReader;
+    function openPromise2(path24, options2) {
+      return new Promise((resolve3, reject) => {
+        open(path24, { ...options2, lazyEntries: true }, function(err, zipfile) {
+          if (err) return reject(err);
+          resolve3(zipfile);
+        });
+      });
+    }
+    function fromFdPromise(fd, options2) {
+      return new Promise((resolve3, reject) => {
+        fromFd(fd, { ...options2, lazyEntries: true }, function(err, zipfile) {
+          if (err) return reject(err);
+          resolve3(zipfile);
+        });
+      });
+    }
+    function fromBufferPromise(buffer, options2) {
+      return new Promise((resolve3, reject) => {
+        fromBuffer(buffer, { ...options2, lazyEntries: true }, function(err, zipfile) {
+          if (err) return reject(err);
+          resolve3(zipfile);
+        });
+      });
+    }
+    function fromRandomAccessReaderPromise(reader, totalSize, options2) {
+      return new Promise((resolve3, reject) => {
+        fromRandomAccessReader(reader, totalSize, { ...options2, lazyEntries: true }, function(err, zipfile) {
+          if (err) return reject(err);
+          resolve3(zipfile);
+        });
+      });
+    }
+    function open(path24, 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;
+      fs29.open(path24, "r", function(err, fd) {
+        if (err) return callback(err);
+        fromFd(fd, options2, function(err2, zipfile) {
+          if (err2) fs29.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;
+      fs29.fstat(fd, function(err, stats) {
+        if (err) return callback(err);
+        var reader = new fd_slicer.FdSlicer(fd);
+        fromRandomAccessReader(reader, stats.size, options2, callback);
+      });
+    }
+    function fromBuffer(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 = new fd_slicer.BufferSlicer(buffer);
+      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 i = bufferSize - eocdrWithoutCommentSize; i >= 0; i -= 1) {
+          if (buffer.readUInt32LE(i) !== 101010256) continue;
+          var eocdrBuffer = buffer.subarray(i);
+          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 comment = decodeStrings ? decodeBuffer(eocdrBuffer.subarray(22), false) : eocdrBuffer.subarray(22);
+          if (i - zip64EocdlSize >= 0 && buffer.readUInt32LE(i - zip64EocdlSize) === 117853008) {
+            var zip64EocdlBuffer = buffer.subarray(i - zip64EocdlSize, i - 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, comment, 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, comment, 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."));
+      });
+    }
+    util.inherits(ZipFile, EventEmitter);
+    function ZipFile(reader, centralDirectoryOffset, fileSize, entryCount, comment, autoClose, lazyEntries, decodeStrings, validateEntrySizes, strictFileNames) {
+      var self = this;
+      EventEmitter.call(self);
+      self.reader = reader;
+      self.reader.on("error", function(err) {
+        emitError(self, err);
+      });
+      self.reader.once("close", function() {
+        self.emit("close");
+      });
+      self.readEntryCursor = centralDirectoryOffset;
+      self.fileSize = fileSize;
+      self.entryCount = entryCount;
+      self.comment = comment;
+      self.entriesRead = 0;
+      self.autoClose = !!autoClose;
+      self.lazyEntries = !!lazyEntries;
+      self.decodeStrings = !!decodeStrings;
+      self.validateEntrySizes = !!validateEntrySizes;
+      self.strictFileNames = !!strictFileNames;
+      self.isOpen = true;
+      self.emittedError = false;
+      self.hasEachEntryBeenCalled = false;
+      if (!self.lazyEntries) self._readEntry();
+    }
+    ZipFile.prototype.close = function() {
+      if (!this.isOpen) return;
+      this.isOpen = false;
+      this.reader.unref();
+    };
+    function emitErrorAndAutoClose(self, err) {
+      if (self.autoClose) self.close();
+      emitError(self, err);
+    }
+    function emitError(self, err) {
+      if (self.emittedError) return;
+      self.emittedError = true;
+      self.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 self = this;
+      if (self.entryCount === self.entriesRead) {
+        setImmediate(function() {
+          if (self.autoClose) self.close();
+          if (self.emittedError) return;
+          self.emit("end");
+        });
+        return;
+      }
+      if (self.emittedError) return;
+      var buffer = newBuffer(46);
+      readAndAssertNoEof(self.reader, buffer, 0, buffer.length, self.readEntryCursor, function(err) {
+        if (err) return emitErrorAndAutoClose(self, err);
+        if (self.emittedError) return;
+        var entry = new Entry();
+        var signature = buffer.readUInt32LE(0);
+        if (signature !== 33639248) return emitErrorAndAutoClose(self, 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(self, new Error("strong encryption is not supported"));
+        self.readEntryCursor += 46;
+        buffer = newBuffer(entry.fileNameLength + entry.extraFieldLength + entry.fileCommentLength);
+        readAndAssertNoEof(self.reader, buffer, 0, buffer.length, self.readEntryCursor, function(err2) {
+          if (err2) return emitErrorAndAutoClose(self, err2);
+          if (self.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(self, err3);
+          }
+          if (self.decodeStrings) {
+            var isUtf8 = (entry.generalPurposeBitFlag & 2048) !== 0;
+            entry.fileComment = decodeBuffer(entry.fileCommentRaw, isUtf8);
+            entry.fileName = getFileNameLowLevel(entry.generalPurposeBitFlag, entry.fileNameRaw, entry.extraFields, self.strictFileNames);
+            var errorMessage = validateFileName(entry.fileName);
+            if (errorMessage != null) return emitErrorAndAutoClose(self, new Error(errorMessage));
+          } else {
+            entry.fileComment = entry.fileCommentRaw;
+            entry.fileName = entry.fileNameRaw;
+          }
+          entry.comment = entry.fileComment;
+          self.readEntryCursor += buffer.length;
+          self.entriesRead += 1;
+          for (var i = 0; i < entry.extraFields.length; i++) {
+            var extraField = entry.extraFields[i];
+            if (extraField.id !== 1) continue;
+            var zip64EiefBuffer = extraField.data;
+            var index = 0;
+            if (entry.uncompressedSize === 4294967295) {
+              if (index + 8 > zip64EiefBuffer.length) {
+                return emitErrorAndAutoClose(self, new Error("zip64 extended information extra field does not include uncompressed size"));
+              }
+              entry.uncompressedSize = readUInt64LE(zip64EiefBuffer, index);
+              index += 8;
+            }
+            if (entry.compressedSize === 4294967295) {
+              if (index + 8 > zip64EiefBuffer.length) {
+                return emitErrorAndAutoClose(self, new Error("zip64 extended information extra field does not include compressed size"));
+              }
+              entry.compressedSize = readUInt64LE(zip64EiefBuffer, index);
+              index += 8;
+            }
+            if (entry.relativeOffsetOfLocalHeader === 4294967295) {
+              if (index + 8 > zip64EiefBuffer.length) {
+                return emitErrorAndAutoClose(self, new Error("zip64 extended information extra field does not include relative header offset"));
+              }
+              entry.relativeOffsetOfLocalHeader = readUInt64LE(zip64EiefBuffer, index);
+              index += 8;
+            }
+            break;
+          }
+          if (self.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(self, new Error(msg));
+            }
+          }
+          self.emit("entry", entry);
+          if (!self.lazyEntries) self._readEntry();
+        });
+      });
+    };
+    ZipFile.prototype.eachEntry = function() {
+      const self = this;
+      if (!self.lazyEntries) throw new Error("eachEntry() requires lazyEntries: true");
+      if (self.hasEachEntryBeenCalled) throw new Error("eachEntry() must only be called once per ZipFile");
+      self.hasEachEntryBeenCalled = true;
+      let pendingResolveReject = null;
+      self.on("entry", onEntry);
+      self.on("end", onEnd);
+      self.on("error", onError);
+      function cleanup() {
+        self.removeListener("entry", onEntry);
+        self.removeListener("end", onEnd);
+        self.removeListener("error", onError);
+        if (self.autoClose) self.close();
+      }
+      function onEntry(entry) {
+        let { resolve: resolve3 } = pendingResolveReject;
+        pendingResolveReject = null;
+        resolve3({ value: entry });
+      }
+      function onEnd() {
+        let { resolve: resolve3 } = pendingResolveReject;
+        pendingResolveReject = null;
+        cleanup();
+        resolve3({ done: true });
+      }
+      function onError(err) {
+        let { reject } = pendingResolveReject;
+        pendingResolveReject = null;
+        cleanup();
+        reject(err);
+      }
+      return {
+        [Symbol.asyncIterator]() {
+          return this;
+        },
+        next() {
+          const promise = new Promise((resolve3, reject) => {
+            if (pendingResolveReject != null) throw new Error("next() called before previous Promise was resolved.");
+            pendingResolveReject = { resolve: resolve3, reject };
+          });
+          self.readEntry();
+          return promise;
+        },
+        return(value) {
+          cleanup();
+          return Promise.resolve({ done: true, value });
+        },
+        throw(value) {
+          cleanup();
+          return Promise.reject(value);
+        }
+      };
+    };
+    ZipFile.prototype.openReadStream = function(entry, options2, callback) {
+      var self = this;
+      var relativeStart = 0;
+      var relativeEnd = entry.compressedSize;
+      if (callback == null) {
+        callback = options2;
+        options2 = null;
+      }
+      if (options2 == null) {
+        options2 = {};
+      } else {
+        if (options2.decodeFileData === false) {
+          if (options2.decrypt != null) {
+            throw new Error("cannot use options.decrypt when options.decodeFileData === false");
+          }
+          if (options2.decompress != null) {
+            throw new Error("cannot use options.decompress when options.decodeFileData === false");
+          }
+        } else {
+          if (options2.decrypt != null) {
+            if (!entry.isEncrypted()) {
+              throw new Error("options.decrypt can only be specified for encrypted entries. See also option decodeFileData.");
+            }
+            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. See also option decodeFileData.");
+            }
+          }
+          if (options2.decompress != null) {
+            if (!entry.isCompressed()) {
+              throw new Error("options.decompress can only be specified for compressed entries. See also option decodeFileData.");
+            }
+            if (!(options2.decompress === false || options2.decompress === true)) {
+              throw new Error("invalid options.decompress value: " + options2.decompress);
+            }
+            decompress = options2.decompress;
+          }
+        }
+        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");
+        }
+      }
+      var rawMode = options2.decodeFileData === false || // Explicitly requested raw.
+      (entry.compressionMethod === 0 || // Naturally without compression.
+      entry.compressionMethod === 8 && options2.decompress === false) && (!entry.isEncrypted() || // Naturally without encryption.
+      options2.decrypt === false);
+      if (options2.start != null || options2.end != null) {
+        if (!rawMode) throw new Error("start/end range require options.decodeFileData === false for non-trivial encoded entries.");
+      }
+      if (!self.isOpen) return callback(new Error("closed"));
+      if (entry.isEncrypted() && !rawMode) {
+        if (options2.decrypt !== false) return callback(new Error("entry is encrypted, and options.decodeFileData !== false"));
+      }
+      var decompress;
+      if (rawMode) {
+        decompress = false;
+      } else if (entry.compressionMethod === 8) {
+        decompress = options2.decodeFileData !== true;
+      } else {
+        return callback(new Error("unsupported compression method: " + entry.compressionMethod));
+      }
+      self.readLocalFileHeader(entry, { minimal: true }, function(err, localFileHeader) {
+        if (err) return callback(err);
+        self.openReadStreamLowLevel(
+          localFileHeader.fileDataStart,
+          entry.compressedSize,
+          relativeStart,
+          relativeEnd,
+          decompress,
+          entry.uncompressedSize,
+          callback
+        );
+      });
+    };
+    ZipFile.prototype.openReadStreamLowLevel = function(fileDataStart, compressedSize, relativeStart, relativeEnd, decompress, uncompressedSize, callback) {
+      var self = this;
+      var fileDataEnd = fileDataStart + compressedSize;
+      var readStream = self.reader.createReadStream({
+        start: fileDataStart + relativeStart,
+        end: fileDataStart + relativeEnd
+      });
+      var endpointStream = readStream;
+      if (decompress) {
+        var destroyed = false;
+        var inflateFilter = zlib.createInflateRaw();
+        readStream.on("error", function(err) {
+          setImmediate(function() {
+            if (!destroyed) inflateFilter.emit("error", err);
+          });
+        });
+        readStream.pipe(inflateFilter);
+        if (self.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);
+          readStream.unpipe(inflateFilter);
+          readStream.destroy();
+        });
+      }
+      callback(null, endpointStream);
+    };
+    ZipFile.prototype.readLocalFileHeader = function(entry, options2, callback) {
+      var self = this;
+      if (callback == null) {
+        callback = options2;
+        options2 = null;
+      }
+      if (options2 == null) options2 = {};
+      self.reader.ref();
+      var buffer = newBuffer(30);
+      readAndAssertNoEof(self.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 > self.fileSize) {
+            return callback(new Error("file data overflows file bounds: " + fileDataStart + " + " + entry.compressedSize + " > " + self.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);
+          self.reader.ref();
+          readAndAssertNoEof(self.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 {
+              self.reader.unref();
+            }
+          });
+        } finally {
+          self.reader.unref();
+        }
+      });
+    };
+    ZipFile.prototype.openReadStreamPromise = function(entry, options2) {
+      return new Promise((resolve3, reject) => {
+        this.openReadStream(entry, options2, function(err, readStream) {
+          if (err) return reject(err);
+          resolve3(readStream);
+        });
+      });
+    };
+    ZipFile.prototype.openReadStreamLowLevelPromise = function(fileDataStart, compressedSize, relativeStart, relativeEnd, decompress, uncompressedSize) {
+      return new Promise((resolve3, reject) => {
+        this.openReadStream(fileDataStart, compressedSize, relativeStart, relativeEnd, decompress, uncompressedSize, function(err, readStream) {
+          if (err) return reject(err);
+          resolve3(readStream);
+        });
+      });
+    };
+    ZipFile.prototype.readLocalFileHeaderPromise = function(entry, options2) {
+      return new Promise((resolve3, reject) => {
+        this.readLocalFileHeader(entry, options2, function(err, localFileHeader) {
+          if (err) return reject(err);
+          resolve3(localFileHeader);
+        });
+      });
+    };
+    function Entry() {
+    }
+    Entry.prototype.getLastModDate = function(options2) {
+      if (options2 == null) options2 = {};
+      if (!options2.forceDosFormat) {
+        for (var i = 0; i < this.extraFields.length; i++) {
+          var extraField = this.extraFields[i];
+          if (extraField.id === 21589) {
+            var data = extraField.data;
+            if (data.length < 5) continue;
+            var flags = data[0];
+            var HAS_MTIME = 1;
+            if (!(flags & HAS_MTIME)) continue;
+            var posixTimestamp = data.readInt32LE(1);
+            return new Date(posixTimestamp * 1e3);
+          } else if (extraField.id === 10) {
+            var data = extraField.data;
+            if (data.length !== 32) continue;
+            if (data.readUInt16LE(4) !== 1) continue;
+            if (data.readUInt16LE(6) !== 24) continue;
+            var hundredNanoSecondsSince1601 = data.readUInt32LE(8) + 4294967296 * data.readInt32LE(12);
+            var millisecondsSince1970 = hundredNanoSecondsSince1601 / 1e4 - 116444736e5;
+            return new Date(millisecondsSince1970);
+          }
+        }
+      }
+      return dosDateTimeToDate(this.lastModFileDate, this.lastModFileTime, options2.timezone);
+    };
+    Entry.prototype.canDecodeFileData = function() {
+      return !this.isEncrypted() && (this.compressionMethod === 0 || this.compressionMethod === 8);
+    };
+    Entry.prototype.isEncrypted = function() {
+      return (this.generalPurposeBitFlag & 1) !== 0;
+    };
+    Entry.prototype.isCompressed = function() {
+      return this.compressionMethod === 8;
+    };
+    function LocalFileHeader() {
+    }
+    function dosDateTimeToDate(date, time, timezone) {
+      var day = date & 31;
+      var month = (date >> 5 & 15) - 1;
+      var year = (date >> 9 & 127) + 1980;
+      var millisecond = 0;
+      var second = (time & 31) * 2;
+      var minute = time >> 5 & 63;
+      var hour = time >> 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 i = 0; i < extraFields.length; i++) {
+        var extraField = extraFields[i];
+        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(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 i = 0;
+      while (i < extraFieldBuffer.length - 3) {
+        var headerId = extraFieldBuffer.readUInt16LE(i + 0);
+        var dataSize = extraFieldBuffer.readUInt16LE(i + 2);
+        var dataStart = i + 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
+        });
+        i = dataEnd;
+      }
+      return extraFields;
+    }
+    function readAndAssertNoEof(reader, buffer, offset, length, position, callback) {
+      if (length === 0) {
+        return setImmediate(function() {
+          callback(null, newBuffer(0));
+        });
+      }
+      reader.read(buffer, offset, length, position, function(err, bytesRead) {
+        if (err) return callback(err);
+        if (bytesRead < length) {
+          return callback(new Error("unexpected EOF"));
+        }
+        callback();
+      });
+    }
+    util.inherits(AssertByteCountStream, Transform);
+    function AssertByteCountStream(byteCount) {
+      Transform.call(this);
+      this.actualByteCount = 0;
+      this.expectedByteCount = byteCount;
+    }
+    AssertByteCountStream.prototype._transform = function(chunk, encoding, cb) {
+      this.actualByteCount += chunk.length;
+      if (this.actualByteCount > this.expectedByteCount) {
+        var msg = "too many bytes in the stream. expected " + this.expectedByteCount + ". got at least " + this.actualByteCount;
+        return cb(new Error(msg));
+      }
+      cb(null, chunk);
+    };
+    AssertByteCountStream.prototype._flush = function(cb) {
+      if (this.actualByteCount < this.expectedByteCount) {
+        var msg = "not enough bytes in the stream. expected " + this.expectedByteCount + ". got only " + this.actualByteCount;
+        return cb(new Error(msg));
+      }
+      cb();
+    };
+    util.inherits(RandomAccessReader, EventEmitter);
+    function RandomAccessReader() {
+      EventEmitter.call(this);
+      this.refCount = 0;
+    }
+    RandomAccessReader.prototype.ref = function() {
+      this.refCount += 1;
+    };
+    RandomAccessReader.prototype.unref = function() {
+      var self = this;
+      self.refCount -= 1;
+      if (self.refCount > 0) return;
+      if (self.refCount < 0) throw new Error("invalid unref");
+      self.close(onCloseDone);
+      function onCloseDone(err) {
+        if (err) return self.emit("error", err);
+        self.emit("close");
+      }
+    };
+    RandomAccessReader.prototype.createReadStream = function(options2) {
+      if (options2 == null) options2 = {};
+      var start = options2.start;
+      var end = options2.end;
+      if (start === end) {
+        var emptyStream = new PassThrough();
+        setImmediate(function() {
+          emptyStream.end();
+        });
+        return emptyStream;
+      }
+      var stream = this._readStreamForRange(start, end);
+      var destroyed = false;
+      var refUnrefFilter = new RefUnrefFilter(this);
+      stream.on("error", function(err) {
+        setImmediate(function() {
+          if (!destroyed) refUnrefFilter.emit("error", err);
+        });
+      });
+      installDestroyFn(refUnrefFilter, function() {
+        stream.unpipe(refUnrefFilter);
+        refUnrefFilter.unref();
+        stream.destroy();
+      });
+      var byteCounter = new AssertByteCountStream(end - start);
+      refUnrefFilter.on("error", function(err) {
+        setImmediate(function() {
+          if (!destroyed) byteCounter.emit("error", err);
+        });
+      });
+      installDestroyFn(byteCounter, function() {
+        destroyed = true;
+        refUnrefFilter.unpipe(byteCounter);
+        refUnrefFilter.destroy();
+      });
+      return stream.pipe(refUnrefFilter).pipe(byteCounter);
+    };
+    RandomAccessReader.prototype._readStreamForRange = function(start, end) {
+      throw new Error("not implemented");
+    };
+    RandomAccessReader.prototype.read = function(buffer, offset, length, position, callback) {
+      var readStream = this.createReadStream({ start: position, end: position + length });
+      var writeStream = new Writable();
+      var written = 0;
+      writeStream._write = function(chunk, encoding, cb) {
+        chunk.copy(buffer, offset + written, 0, chunk.length);
+        written += chunk.length;
+        cb();
+      };
+      writeStream.on("finish", callback);
+      readStream.on("error", function(error) {
+        callback(error);
+      });
+      readStream.pipe(writeStream);
+    };
+    RandomAccessReader.prototype.close = function(callback) {
+      setImmediate(callback);
+    };
+    util.inherits(RefUnrefFilter, PassThrough);
+    function RefUnrefFilter(context) {
+      PassThrough.call(this);
+      this.context = context;
+      this.context.ref();
+      this.unreffedYet = false;
+    }
+    RefUnrefFilter.prototype._flush = function(cb) {
+      this.unref();
+      cb();
+    };
+    RefUnrefFilter.prototype.unref = function(cb) {
+      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 i = 0; i < buffer.length; i++) {
+          result += cp437[buffer[i]];
+        }
+        return result;
+      }
+    }
+    function readUInt64LE(buffer, offset) {
+      var lower32 = buffer.readUInt32LE(offset);
+      var upper32 = buffer.readUInt32LE(offset + 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(stream, fn) {
+      if (typeof stream.destroy === "function") {
+        stream._destroy = function(err, cb) {
+          fn();
+          if (cb != null) cb(err);
+        };
+      } else {
+        stream.destroy = fn;
+      }
+    }
+    function defaultCallback(err) {
+      if (err) throw err;
+    }
+  }
+});
+
 // ../../packages/node-runtime/src/import/write-parse-result.ts
 function writeParseResultToDb(db, meta, members, messages) {
   let messageCount = 0;
@@ -1592,8 +2941,8 @@ Errors: ${errorCount}
 }
 
 // ../../packages/parser/src/index.ts
-import * as fs17 from "fs";
-import * as path13 from "path";
+import * as fs18 from "fs";
+import * as path14 from "path";
 
 // ../../packages/parser/src/sniffer.ts
 import * as fs2 from "fs";
@@ -1647,9 +2996,9 @@ var FormatSniffer = class {
   sniff(filePath) {
     const ext = getExtension(filePath);
     const headContent = readFileHead(filePath);
-    for (const { feature: feature14 } of this.formats) {
-      if (this.matchFeature(feature14, ext, headContent, filePath)) {
-        return feature14;
+    for (const { feature: feature15 } of this.formats) {
+      if (this.matchFeature(feature15, ext, headContent, filePath)) {
+        return feature15;
       }
     }
     return null;
@@ -1662,9 +3011,9 @@ var FormatSniffer = class {
   getParser(filePath) {
     const ext = getExtension(filePath);
     const headContent = readFileHead(filePath);
-    for (const { feature: feature14, parser: parser9 } of this.formats) {
-      if (this.matchFeature(feature14, ext, headContent, filePath)) {
-        return parser9;
+    for (const { feature: feature15, parser: parser11 } of this.formats) {
+      if (this.matchFeature(feature15, ext, headContent, filePath)) {
+        return parser11;
       }
     }
     return null;
@@ -1679,9 +3028,9 @@ var FormatSniffer = class {
     const ext = getExtension(filePath);
     const headContent = readFileHead(filePath);
     const results = [];
-    for (const { feature: feature14 } of this.formats) {
-      if (this.matchFeature(feature14, ext, headContent, filePath)) {
-        results.push(feature14);
+    for (const { feature: feature15 } of this.formats) {
+      if (this.matchFeature(feature15, ext, headContent, filePath)) {
+        results.push(feature15);
       }
     }
     return results;
@@ -1696,9 +3045,9 @@ var FormatSniffer = class {
     const ext = getExtension(filePath);
     const headContent = readFileHead(filePath);
     const results = [];
-    for (const { feature: feature14, parser: parser9 } of this.formats) {
-      if (this.matchFeature(feature14, ext, headContent, filePath)) {
-        results.push(parser9);
+    for (const { feature: feature15, parser: parser11 } of this.formats) {
+      if (this.matchFeature(feature15, ext, headContent, filePath)) {
+        results.push(parser11);
       }
     }
     return results;
@@ -1719,11 +3068,11 @@ var FormatSniffer = class {
   /**
    * 检查特征是否匹配
    */
-  matchFeature(feature14, ext, headContent, filePath) {
-    if (!feature14.extensions.includes(ext)) {
+  matchFeature(feature15, ext, headContent, filePath) {
+    if (!feature15.extensions.includes(ext)) {
       return false;
     }
-    const { signatures } = feature14;
+    const { signatures } = feature15;
     let headMatch = true;
     if (signatures.head && signatures.head.length > 0) {
       headMatch = matchHeadSignatures(headContent, signatures.head);
@@ -1826,8 +3175,8 @@ var feature = {
     requiredFields: ["chatlab"]
   }
 };
-async function* parseChatLab(options) {
-  const { filePath, batchSize = 5e3, onProgress, onLog } = options;
+async function* parseChatLab(options2) {
+  const { filePath, batchSize = 5e3, onProgress, onLog } = options2;
   const totalBytes = getFileSize(filePath);
   let bytesRead = 0;
   let messagesProcessed = 0;
@@ -1896,14 +3245,14 @@ async function* parseChatLab(options) {
   }
   const memberMapFromMessages = /* @__PURE__ */ new Map();
   const messageBatch = [];
-  await new Promise((resolve2, reject) => {
+  await new Promise((resolve3, reject) => {
     const readStream = fs4.createReadStream(filePath, { encoding: "utf-8" });
     readStream.on("data", (chunk) => {
       bytesRead += typeof chunk === "string" ? Buffer.byteLength(chunk) : chunk.length;
     });
-    const pipeline = chain([readStream, parser(), pick({ filter: /^messages\.\d+$/ }), streamValues()]);
+    const pipeline2 = chain([readStream, parser(), pick({ filter: /^messages\.\d+$/ }), streamValues()]);
     const batchCollector = [];
-    pipeline.on("data", ({ value }) => {
+    pipeline2.on("data", ({ value }) => {
       const msg = value;
       if (members.length === 0) {
         memberMapFromMessages.set(msg.sender, {
@@ -1936,13 +3285,13 @@ async function* parseChatLab(options) {
         onProgress?.(progress);
       }
     });
-    pipeline.on("end", () => {
+    pipeline2.on("end", () => {
       if (batchCollector.length > 0) {
         messageBatch.push(...batchCollector);
       }
-      resolve2();
+      resolve3();
     });
-    pipeline.on("error", reject);
+    pipeline2.on("error", reject);
   });
   if (members.length > 0) {
     yield { type: "members", data: members };
@@ -2008,8 +3357,8 @@ var feature2 = {
     head: [/^\s*\{.*"_type"\s*:\s*"header".*"chatlab"/]
   }
 };
-async function* parseChatLabJsonl(options) {
-  const { filePath, batchSize = 5e3, onProgress, onLog } = options;
+async function* parseChatLabJsonl(options2) {
+  const { filePath, batchSize = 5e3, onProgress, onLog } = options2;
   const totalBytes = getFileSize(filePath);
   let bytesRead = 0;
   let messagesProcessed = 0;
@@ -2276,7 +3625,7 @@ async function preprocessQQJson(inputPath, onProgress) {
   const outputPath = path5.join(tempDir, outputFilename);
   onProgress?.(createProgress("parsing", 0, totalBytes, 0, ""));
   const avatarsStr = readAvatarsFromFile(inputPath);
-  return new Promise((resolve2, reject) => {
+  return new Promise((resolve3, reject) => {
     const headChunks = [];
     let headSize = 0;
     const maxHeadSize = 1e5;
@@ -2326,8 +3675,8 @@ async function preprocessQQJson(inputPath, onProgress) {
       const headerJson = JSON.stringify(header);
       writeStream.write(headerJson.slice(0, -2) + "\n");
       let isFirstMessage = true;
-      const pipeline = chain2([readStream, parser3(), pick2({ filter: /^messages\.\d+$/ }), streamValues2()]);
-      pipeline.on("data", ({ value }) => {
+      const pipeline2 = chain2([readStream, parser3(), pick2({ filter: /^messages\.\d+$/ }), streamValues2()]);
+      pipeline2.on("data", ({ value }) => {
         const slimMsg = slimMessage(value);
         const msgJson = JSON.stringify(slimMsg);
         if (isFirstMessage) {
@@ -2349,7 +3698,7 @@ async function preprocessQQJson(inputPath, onProgress) {
           );
         }
       });
-      pipeline.on("end", () => {
+      pipeline2.on("end", () => {
         writeStream.write("\n]");
         if (avatarsStr) {
           writeStream.write(',"avatars":' + avatarsStr);
@@ -2358,10 +3707,10 @@ async function preprocessQQJson(inputPath, onProgress) {
         writeStream.end();
         writeStream.on("finish", () => {
           onProgress?.(createProgress("done", totalBytes, totalBytes, messagesProcessed, ""));
-          resolve2(outputPath);
+          resolve3(outputPath);
         });
       });
-      pipeline.on("error", (err) => {
+      pipeline2.on("error", (err) => {
         writeStream.destroy();
         if (fs6.existsSync(outputPath)) {
           fs6.unlinkSync(outputPath);
@@ -2496,8 +3845,8 @@ function convertMessageType(messageType, content, isRecalled) {
   if (messageType === 9) return 25 /* REPLY */;
   return 0 /* TEXT */;
 }
-async function* parseV4(options) {
-  const { filePath, batchSize = 5e3, onProgress, onLog } = options;
+async function* parseV4(options2) {
+  const { filePath, batchSize = 5e3, onProgress, onLog } = options2;
   const totalBytes = getFileSize(filePath);
   let bytesRead = 0;
   let messagesProcessed = 0;
@@ -2527,13 +3876,13 @@ async function* parseV4(options) {
   yield { type: "meta", data: meta };
   const memberMap = /* @__PURE__ */ new Map();
   const messageBatch = [];
-  await new Promise((resolve2, reject) => {
+  await new Promise((resolve3, reject) => {
     const readStream = fs7.createReadStream(filePath, { encoding: "utf-8" });
     readStream.on("data", (chunk) => {
       bytesRead += typeof chunk === "string" ? Buffer.byteLength(chunk) : chunk.length;
     });
-    const pipeline = chain3([readStream, parser4(), pick3({ filter: /^messages\.\d+$/ }), streamValues3()]);
-    pipeline.on("data", ({ value }) => {
+    const pipeline2 = chain3([readStream, parser4(), pick3({ filter: /^messages\.\d+$/ }), streamValues3()]);
+    pipeline2.on("data", ({ value }) => {
       const platformId = value.sender.uin || value.sender.uid || value.rawMessage?.senderUin || value.rawMessage?.senderUid;
       if (!platformId) {
         skippedMessages++;
@@ -2581,8 +3930,8 @@ async function* parseV4(options) {
         onProgress?.(progress);
       }
     });
-    pipeline.on("end", resolve2);
-    pipeline.on("error", reject);
+    pipeline2.on("end", resolve3);
+    pipeline2.on("error", reject);
   });
   const avatarsMap = /* @__PURE__ */ new Map();
   try {
@@ -2770,8 +4119,8 @@ async function* readJsonlFile(filePath, onParseError) {
     }
   }
 }
-async function* parseChunkedJsonl(options) {
-  const { filePath, batchSize = 5e3, onProgress, onLog } = options;
+async function* parseChunkedJsonl(options2) {
+  const { filePath, batchSize = 5e3, onProgress, onLog } = options2;
   const manifestPath = filePath;
   const baseDir = path7.dirname(manifestPath);
   onLog?.("info", `\u5F00\u59CB\u89E3\u6790 manifest: ${manifestPath}`);
@@ -3044,8 +4393,8 @@ function convertMessageType3(typeStr) {
       return 99 /* OTHER */;
   }
 }
-async function* parseWeFlow(options) {
-  const { filePath, batchSize = 5e3, onProgress, onLog } = options;
+async function* parseWeFlow(options2) {
+  const { filePath, batchSize = 5e3, onProgress, onLog } = options2;
   const totalBytes = getFileSize(filePath);
   let bytesRead = 0;
   let messagesProcessed = 0;
@@ -3056,7 +4405,7 @@ async function* parseWeFlow(options) {
   const headContent = readFileHeadBytes(filePath, 5e3);
   let session = null;
   try {
-    await new Promise((resolve2) => {
+    await new Promise((resolve3) => {
       const sessionStream = fs9.createReadStream(filePath, { encoding: "utf-8" });
       let sessionContent = "";
       let inSession = false;
@@ -3108,9 +4457,9 @@ async function* parseWeFlow(options) {
           } catch {
           }
         }
-        resolve2();
+        resolve3();
       });
-      sessionStream.on("error", () => resolve2());
+      sessionStream.on("error", () => resolve3());
     });
   } catch {
   }
@@ -3179,7 +4528,7 @@ async function* parseWeFlow(options) {
   }
   if (avatarsMap.size === 0) {
     try {
-      await new Promise((resolve2) => {
+      await new Promise((resolve3) => {
         const avatarStream = fs9.createReadStream(filePath, { encoding: "utf-8" });
         let avatarsContent = "";
         let inAvatars = false;
@@ -3236,9 +4585,9 @@ async function* parseWeFlow(options) {
             } catch {
             }
           }
-          resolve2();
+          resolve3();
         });
-        avatarStream.on("error", () => resolve2());
+        avatarStream.on("error", () => resolve3());
       });
     } catch {
     }
@@ -3246,7 +4595,7 @@ async function* parseWeFlow(options) {
   const groupAvatar = sessionData?.avatar || (groupId ? avatarsMap.get(groupId) : void 0);
   let ownerId;
   try {
-    await new Promise((resolve2) => {
+    await new Promise((resolve3) => {
       const scanStream = fs9.createReadStream(filePath, { encoding: "utf-8" });
       const scanPipeline = chain4([scanStream, parser5(), pick4({ filter: /^messages\.\d+$/ }), streamValues4()]);
       scanPipeline.on("data", ({ value }) => {
@@ -3255,9 +4604,9 @@ async function* parseWeFlow(options) {
           scanStream.destroy();
         }
       });
-      scanStream.on("close", () => resolve2());
-      scanPipeline.on("end", () => resolve2());
-      scanPipeline.on("error", () => resolve2());
+      scanStream.on("close", () => resolve3());
+      scanPipeline.on("end", () => resolve3());
+      scanPipeline.on("error", () => resolve3());
     });
   } catch {
   }
@@ -3272,12 +4621,12 @@ async function* parseWeFlow(options) {
   yield { type: "meta", data: meta };
   const memberMap = /* @__PURE__ */ new Map();
   const messageBatch = [];
-  await new Promise((resolve2, reject) => {
+  await new Promise((resolve3, reject) => {
     const readStream = fs9.createReadStream(filePath, { encoding: "utf-8" });
     readStream.on("data", (chunk) => {
       bytesRead += typeof chunk === "string" ? Buffer.byteLength(chunk) : chunk.length;
     });
-    const pipeline = chain4([readStream, parser5(), pick4({ filter: /^messages\.\d+$/ }), streamValues4()]);
+    const pipeline2 = chain4([readStream, parser5(), pick4({ filter: /^messages\.\d+$/ }), streamValues4()]);
     const processMessage = (msg) => {
       if (!msg.senderUsername || msg.createTime === void 0) {
         return null;
@@ -3322,7 +4671,7 @@ async function* parseWeFlow(options) {
       };
     };
     const batchCollector = [];
-    pipeline.on("data", ({ value }) => {
+    pipeline2.on("data", ({ value }) => {
       const parsed = processMessage(value);
       if (parsed) {
         batchCollector.push(parsed);
@@ -3341,13 +4690,13 @@ async function* parseWeFlow(options) {
         }
       }
     });
-    pipeline.on("end", () => {
+    pipeline2.on("end", () => {
       if (batchCollector.length > 0) {
         messageBatch.push(...batchCollector);
       }
-      resolve2();
+      resolve3();
     });
-    pipeline.on("error", reject);
+    pipeline2.on("error", reject);
   });
   const members = Array.from(memberMap.values()).map((m) => ({
     platformId: m.platformId,
@@ -3521,8 +4870,8 @@ function convertRoles(discordRoles) {
     name: role.name
   }));
 }
-async function* parseDiscordExporter(options) {
-  const { filePath, batchSize = 5e3, onProgress, onLog } = options;
+async function* parseDiscordExporter(options2) {
+  const { filePath, batchSize = 5e3, onProgress, onLog } = options2;
   const totalBytes = getFileSize(filePath);
   let bytesRead = 0;
   let messagesProcessed = 0;
@@ -3558,14 +4907,14 @@ async function* parseDiscordExporter(options) {
   onLog?.("info", `\u7FA4\u804A\u540D\u79F0: ${chatName}`);
   const memberMap = /* @__PURE__ */ new Map();
   const messageBatch = [];
-  await new Promise((resolve2, reject) => {
+  await new Promise((resolve3, reject) => {
     const readStream = fs10.createReadStream(filePath, { encoding: "utf-8" });
     readStream.on("data", (chunk) => {
       bytesRead += typeof chunk === "string" ? Buffer.byteLength(chunk) : chunk.length;
     });
-    const pipeline = chain5([readStream, parser6(), pick5({ filter: /^messages\.\d+$/ }), streamValues5()]);
+    const pipeline2 = chain5([readStream, parser6(), pick5({ filter: /^messages\.\d+$/ }), streamValues5()]);
     const batchCollector = [];
-    pipeline.on("data", ({ value }) => {
+    pipeline2.on("data", ({ value }) => {
       const msg = value;
       const author = msg.author;
       if (!memberMap.has(author.id)) {
@@ -3633,13 +4982,13 @@ ${stickerTexts.join("\n")}` : stickerTexts.join("\n");
         onProgress?.(progress);
       }
     });
-    pipeline.on("end", () => {
+    pipeline2.on("end", () => {
       if (batchCollector.length > 0) {
         messageBatch.push(...batchCollector);
       }
-      resolve2();
+      resolve3();
     });
-    pipeline.on("error", reject);
+    pipeline2.on("error", reject);
   });
   const members = Array.from(memberMap.values());
   yield { type: "members", data: members };
@@ -3760,10 +5109,10 @@ var feature8 = {
 };
 async function scanChats(filePath) {
   const chats = [];
-  return new Promise((resolve2, reject) => {
+  return new Promise((resolve3, reject) => {
     const readStream = fs11.createReadStream(filePath, { encoding: "utf-8" });
-    const pipeline = chain6([readStream, parser7(), pick6({ filter: /^chats\.list\.\d+$/ }), streamValues6()]);
-    pipeline.on("data", ({ value }) => {
+    const pipeline2 = chain6([readStream, parser7(), pick6({ filter: /^chats\.list\.\d+$/ }), streamValues6()]);
+    pipeline2.on("data", ({ value }) => {
       const chat = value;
       chats.push({
         index: chats.length,
@@ -3773,16 +5122,16 @@ async function scanChats(filePath) {
         messageCount: Array.isArray(chat.messages) ? chat.messages.length : 0
       });
     });
-    pipeline.on("end", () => {
-      resolve2(chats);
+    pipeline2.on("end", () => {
+      resolve3(chats);
     });
-    pipeline.on("error", (err) => {
+    pipeline2.on("error", (err) => {
       reject(new Error(`\u626B\u63CF Telegram \u6587\u4EF6\u5931\u8D25: ${err.message}`));
     });
   });
 }
-async function* parseTelegram(options) {
-  const { filePath, batchSize = 5e3, formatOptions, onProgress, onLog } = options;
+async function* parseTelegram(options2) {
+  const { filePath, batchSize = 5e3, formatOptions, onProgress, onLog } = options2;
   const chatIndex = formatOptions?.chatIndex ?? 0;
   const totalBytes = getFileSize(filePath);
   let bytesRead = 0;
@@ -3793,26 +5142,26 @@ async function* parseTelegram(options) {
   onLog?.("info", `\u5F00\u59CB\u89E3\u6790 Telegram JSON \u6587\u4EF6\uFF0C\u5927\u5C0F: ${(totalBytes / 1024 / 1024).toFixed(2)} MB`);
   onLog?.("info", `\u76EE\u6807\u804A\u5929\u7D22\u5F15: ${chatIndex}`);
   const chatPathFilter = `chats.list.${chatIndex}`;
-  const chatData = await new Promise((resolve2, reject) => {
+  const chatData = await new Promise((resolve3, reject) => {
     const readStream = fs11.createReadStream(filePath, { encoding: "utf-8" });
     readStream.on("data", (chunk) => {
       bytesRead += typeof chunk === "string" ? Buffer.byteLength(chunk) : chunk.length;
     });
-    const pipeline = chain6([
+    const pipeline2 = chain6([
       readStream,
       parser7(),
       pick6({ filter: new RegExp(`^${chatPathFilter.replace(".", "\\.")}$`) }),
       streamValues6()
     ]);
     let found = false;
-    pipeline.on("data", ({ value }) => {
+    pipeline2.on("data", ({ value }) => {
       found = true;
-      resolve2(value);
+      resolve3(value);
     });
-    pipeline.on("end", () => {
-      if (!found) resolve2(null);
+    pipeline2.on("end", () => {
+      if (!found) resolve3(null);
     });
-    pipeline.on("error", reject);
+    pipeline2.on("error", reject);
   });
   if (!chatData) {
     onLog?.("error", `\u672A\u627E\u5230\u7D22\u5F15 ${chatIndex} \u5BF9\u5E94\u7684\u804A\u5929`);
@@ -3923,28 +5272,28 @@ var feature9 = {
     }
   }
 };
-async function* parseTelegramSingle(options) {
-  const { filePath, batchSize = 5e3, onProgress, onLog } = options;
+async function* parseTelegramSingle(options2) {
+  const { filePath, batchSize = 5e3, onProgress, onLog } = options2;
   const totalBytes = getFileSize(filePath);
   let messagesProcessed = 0;
   const initialProgress = createProgress("parsing", 0, totalBytes, 0, "");
   yield { type: "progress", data: initialProgress };
   onProgress?.(initialProgress);
   onLog?.("info", `\u5F00\u59CB\u89E3\u6790 Telegram \u5355\u804A\u5929 JSON \u6587\u4EF6\uFF0C\u5927\u5C0F: ${(totalBytes / 1024 / 1024).toFixed(2)} MB`);
-  const chatData = await new Promise((resolve2, reject) => {
+  const chatData = await new Promise((resolve3, reject) => {
     const readStream = fs12.createReadStream(filePath, { encoding: "utf-8" });
-    const pipeline = chain7([readStream, parser8(), streamValues7()]);
+    const pipeline2 = chain7([readStream, parser8(), streamValues7()]);
     let found = false;
-    pipeline.on("data", ({ value }) => {
+    pipeline2.on("data", ({ value }) => {
       if (!found) {
         found = true;
-        resolve2(value);
+        resolve3(value);
       }
     });
-    pipeline.on("end", () => {
-      if (!found) resolve2(null);
+    pipeline2.on("end", () => {
+      if (!found) resolve3(null);
     });
-    pipeline.on("error", reject);
+    pipeline2.on("error", reject);
   });
   if (!chatData) {
     onLog?.("error", "\u65E0\u6CD5\u89E3\u6790 Telegram \u5355\u804A\u5929\u6587\u4EF6");
@@ -4202,8 +5551,8 @@ function parseV1Timestamp(timeStr) {
   const ts = Math.floor(date.getTime() / 1e3);
   return isNaN(ts) ? 0 : ts;
 }
-async function* parseWhatsApp(options) {
-  const { filePath, batchSize = 5e3, onProgress, onLog } = options;
+async function* parseWhatsApp(options2) {
+  const { filePath, batchSize = 5e3, onProgress, onLog } = options2;
   const totalBytes = getFileSize(filePath);
   let bytesRead = 0;
   let messagesProcessed = 0;
@@ -4410,8 +5759,8 @@ function cleanNickname(nickname) {
   return nickname.replace(/^(【[^】]*】\s*)+/, "").trim();
 }
 var lastValidNickname = /* @__PURE__ */ new Map();
-async function* parseTxt(options) {
-  const { filePath, batchSize = 5e3, onProgress, onLog } = options;
+async function* parseTxt(options2) {
+  const { filePath, batchSize = 5e3, onProgress, onLog } = options2;
   const totalBytes = getFileSize(filePath);
   let bytesRead = 0;
   let messagesProcessed = 0;
@@ -4630,8 +5979,8 @@ function getMessageContent(msg) {
   }
   return "[\u672A\u77E5\u6D88\u606F]";
 }
-async function* parseInstagram(options) {
-  const { filePath, batchSize = 5e3, onProgress, onLog } = options;
+async function* parseInstagram(options2) {
+  const { filePath, batchSize = 5e3, onProgress, onLog } = options2;
   const totalBytes = getFileSize(filePath);
   let messagesProcessed = 0;
   const initialProgress = createProgress("parsing", 0, totalBytes, 0, "\u6B63\u5728\u89E3\u6790 Instagram \u804A\u5929\u8BB0\u5F55...");
@@ -4730,10 +6079,247 @@ var module_12 = {
 };
 var instagram_native_default = module_12;
 
-// ../../packages/parser/src/formats/line-native-txt.ts
+// ../../packages/parser/src/formats/google-chat-takeout.ts
+var import_stream_chain8 = __toESM(require_stream_chain(), 1);
+var import_stream_json8 = __toESM(require_stream_json(), 1);
+var import_Pick7 = __toESM(require_Pick(), 1);
+var import_StreamValues8 = __toESM(require_StreamValues(), 1);
 import * as fs16 from "fs";
 import * as path12 from "path";
+var { chain: chain8 } = import_stream_chain8.default;
+var { parser: parser9 } = import_stream_json8.default;
+var { pick: pick7 } = import_Pick7.default;
+var { streamValues: streamValues8 } = import_StreamValues8.default;
+var ENGLISH_MONTHS = /* @__PURE__ */ new Map([
+  ["january", 0],
+  ["february", 1],
+  ["march", 2],
+  ["april", 3],
+  ["may", 4],
+  ["june", 5],
+  ["july", 6],
+  ["august", 7],
+  ["september", 8],
+  ["october", 9],
+  ["november", 10],
+  ["december", 11]
+]);
 var feature13 = {
+  id: "google-chat-takeout",
+  name: "Google Chat Takeout",
+  platform: KNOWN_PLATFORMS.GOOGLE_CHAT,
+  priority: 24,
+  extensions: [".json"],
+  signatures: {
+    head: [/"format"\s*:\s*"chatlab-google-chat-takeout"/],
+    requiredFields: ["format", "version", "messagesFile"]
+  }
+};
+function normalizeSpaces(value) {
+  return value.replace(/[\u00a0\u202f]/g, " ").replace(/\s+/g, " ").trim();
+}
+function createUtcTimestamp(year, monthIndex, day, hour, minute, second) {
+  const timestampMs = Date.UTC(year, monthIndex, day, hour, minute, second);
+  const date = new Date(timestampMs);
+  if (date.getUTCFullYear() !== year || date.getUTCMonth() !== monthIndex || date.getUTCDate() !== day || date.getUTCHours() !== hour || date.getUTCMinutes() !== minute || date.getUTCSeconds() !== second) {
+    return null;
+  }
+  return Math.floor(timestampMs / 1e3);
+}
+function parseChineseUtcDate(value) {
+  const match = normalizeSpaces(value).match(
+    /^(\d{4})年(\d{1,2})月(\d{1,2})日(?:星期[一二三四五六日天])?\s+UTC\s+(\d{1,2}):(\d{2}):(\d{2})$/
+  );
+  if (!match) return null;
+  return createUtcTimestamp(
+    Number(match[1]),
+    Number(match[2]) - 1,
+    Number(match[3]),
+    Number(match[4]),
+    Number(match[5]),
+    Number(match[6])
+  );
+}
+function parseEnglishUtcDate(value) {
+  const match = normalizeSpaces(value).match(
+    /^(?:Monday|Tuesday|Wednesday|Thursday|Friday|Saturday|Sunday),\s+([A-Za-z]+)\s+(\d{1,2}),\s+(\d{4})\s+at\s+(\d{1,2}):(\d{2}):(\d{2})\s+(AM|PM)\s+UTC$/i
+  );
+  if (!match) return null;
+  const monthIndex = ENGLISH_MONTHS.get(match[1].toLowerCase());
+  if (monthIndex === void 0) return null;
+  let hour = Number(match[4]);
+  if (hour < 1 || hour > 12) return null;
+  if (match[7].toUpperCase() === "AM") {
+    if (hour === 12) hour = 0;
+  } else if (hour !== 12) {
+    hour += 12;
+  }
+  return createUtcTimestamp(Number(match[3]), monthIndex, Number(match[2]), hour, Number(match[5]), Number(match[6]));
+}
+function parseGoogleChatDate(value) {
+  return parseChineseUtcDate(value) ?? parseEnglishUtcDate(value);
+}
+function normalizeIdentity(user) {
+  const email = user?.email?.trim().toLowerCase();
+  const name = user?.name?.trim() || email || "Unknown";
+  return {
+    platformId: email || name.toLowerCase(),
+    name
+  };
+}
+function readJson(filePath) {
+  return JSON.parse(fs16.readFileSync(filePath, "utf8"));
+}
+function resolveManifestFile(manifestDir, relativePath) {
+  const resolved = path12.resolve(manifestDir, relativePath);
+  const relative2 = path12.relative(manifestDir, resolved);
+  if (relative2.startsWith("..") || path12.isAbsolute(relative2)) {
+    throw new Error(`Google Chat manifest path escapes its directory: ${relativePath}`);
+  }
+  return resolved;
+}
+function readManifest2(filePath) {
+  const manifest = readJson(filePath);
+  if (manifest.format !== "chatlab-google-chat-takeout" || manifest.version !== 1) {
+    throw new Error("Invalid Google Chat import manifest");
+  }
+  if (manifest.chatType !== "private" && manifest.chatType !== "group") {
+    throw new Error("Invalid Google Chat chat type");
+  }
+  const manifestDir = path12.dirname(filePath);
+  return {
+    manifest,
+    userInfoPath: resolveManifestFile(manifestDir, manifest.userInfoFile),
+    groupInfoPath: resolveManifestFile(manifestDir, manifest.groupInfoFile),
+    messagesPath: resolveManifestFile(manifestDir, manifest.messagesFile)
+  };
+}
+function getAttachmentName(attachment) {
+  return attachment.original_name?.trim() || attachment.export_name?.trim() || null;
+}
+function buildQuotePrefix(message) {
+  const quote = message.quoted_message_metadata;
+  const quoteText = quote?.text?.trim();
+  if (!quoteText) return null;
+  const creator = quote?.creator?.name?.trim() || quote?.creator?.email?.trim();
+  return creator ? `> ${creator}: ${quoteText}` : `> ${quoteText}`;
+}
+function buildMessageContent(message) {
+  const parts = [];
+  const quote = buildQuotePrefix(message);
+  if (quote) parts.push(quote);
+  const text = message.text?.trim();
+  if (text) parts.push(text);
+  for (const attachment of message.attached_files ?? []) {
+    const name = getAttachmentName(attachment);
+    if (name) parts.push(`[\u9644\u4EF6] ${name}`);
+  }
+  return parts.length > 0 ? parts.join("\n") : "[\u4E0D\u652F\u6301\u7684 Google Chat \u6D88\u606F]";
+}
+function detectMessageType5(message) {
+  if (message.text?.trim()) return 0 /* TEXT */;
+  if ((message.attached_files ?? []).some((attachment) => getAttachmentName(attachment))) {
+    return 4 /* FILE */;
+  }
+  return 99 /* OTHER */;
+}
+function deriveChatName(manifest, groupInfo, ownerId) {
+  if (manifest.chatName?.trim()) return manifest.chatName.trim();
+  if (manifest.chatType === "group" && groupInfo.name?.trim()) return groupInfo.name.trim();
+  const otherMember = (groupInfo.members ?? []).map(normalizeIdentity).find((member) => !ownerId || member.platformId !== ownerId);
+  return otherMember?.name || groupInfo.members?.map((member) => normalizeIdentity(member).name).join(", ") || manifest.chatId;
+}
+async function* parseGoogleChat(options2) {
+  const { filePath, batchSize = 5e3, onProgress, onLog } = options2;
+  const { manifest, userInfoPath, groupInfoPath, messagesPath } = readManifest2(filePath);
+  const userInfo = readJson(userInfoPath);
+  const groupInfo = readJson(groupInfoPath);
+  const owner = userInfo.user ? normalizeIdentity(userInfo.user) : null;
+  const totalBytes = getFileSize(messagesPath);
+  const initialProgress = createProgress("parsing", 0, totalBytes, 0, "");
+  yield { type: "progress", data: initialProgress };
+  onProgress?.(initialProgress);
+  yield {
+    type: "meta",
+    data: {
+      name: deriveChatName(manifest, groupInfo, owner?.platformId),
+      platform: KNOWN_PLATFORMS.GOOGLE_CHAT,
+      type: manifest.chatType === "group" ? "group" /* GROUP */ : "private" /* PRIVATE */,
+      ...manifest.chatType === "group" ? { groupId: manifest.chatId } : {},
+      ownerId: owner?.platformId
+    }
+  };
+  const memberMap = /* @__PURE__ */ new Map();
+  for (const member of groupInfo.members ?? []) {
+    const identity = normalizeIdentity(member);
+    memberMap.set(identity.platformId, {
+      platformId: identity.platformId,
+      accountName: identity.name
+    });
+  }
+  if (owner && !memberMap.has(owner.platformId)) {
+    memberMap.set(owner.platformId, {
+      platformId: owner.platformId,
+      accountName: owner.name
+    });
+  }
+  yield { type: "members", data: Array.from(memberMap.values()) };
+  const readStream = fs16.createReadStream(messagesPath, { encoding: "utf8" });
+  let bytesRead = 0;
+  let messagesProcessed = 0;
+  readStream.on("data", (chunk) => {
+    bytesRead += typeof chunk === "string" ? Buffer.byteLength(chunk) : chunk.length;
+  });
+  const pipeline2 = chain8([readStream, parser9(), pick7({ filter: /^messages\.\d+$/ }), streamValues8()]);
+  const messageBatch = [];
+  try {
+    for await (const item of pipeline2) {
+      const message = item.value;
+      const sender = normalizeIdentity(message.creator);
+      messageBatch.push({
+        platformMessageId: message.message_id ? String(message.message_id) : void 0,
+        senderPlatformId: sender.platformId,
+        senderAccountName: sender.name,
+        timestamp: parseGoogleChatDate(message.created_date ?? message.updated_date ?? "") ?? Number.NaN,
+        type: detectMessageType5(message),
+        content: buildMessageContent(message)
+      });
+      messagesProcessed++;
+      if (messageBatch.length >= batchSize) {
+        yield { type: "messages", data: messageBatch.splice(0) };
+        const progress = createProgress("parsing", bytesRead, totalBytes, messagesProcessed, "");
+        yield { type: "progress", data: progress };
+        onProgress?.(progress);
+      }
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    onLog?.("error", `Failed to parse Google Chat messages: ${message}`);
+    yield { type: "error", data: new Error(`Failed to parse Google Chat messages: ${message}`) };
+    return;
+  }
+  if (messageBatch.length > 0) {
+    yield { type: "messages", data: messageBatch };
+  }
+  const doneProgress = createProgress("done", totalBytes, totalBytes, messagesProcessed, "");
+  yield { type: "progress", data: doneProgress };
+  onProgress?.(doneProgress);
+  yield { type: "done", data: { messageCount: messagesProcessed, memberCount: memberMap.size } };
+}
+var parser_12 = {
+  feature: feature13,
+  parse: parseGoogleChat
+};
+var module_13 = {
+  feature: feature13,
+  parser: parser_12
+};
+var google_chat_takeout_default = module_13;
+
+// ../../packages/parser/src/formats/line-native-txt.ts
+import * as fs17 from "fs";
+import * as path13 from "path";
+var feature14 = {
   id: "line-native-txt",
   name: "LINE \u5B98\u65B9\u5BFC\u51FA TXT",
   platform: KNOWN_PLATFORMS.LINE,
@@ -4760,7 +6346,7 @@ var feature13 = {
   }
 };
 function extractNameFromFilePath8(filePath) {
-  const basename11 = path12.basename(filePath, ".txt");
+  const basename11 = path13.basename(filePath, ".txt");
   const name = basename11.replace(/^\[LINE\]\s*/i, "").trim();
   return name || "\u672A\u77E5\u804A\u5929";
 }
@@ -4882,7 +6468,7 @@ var SPECIAL_MESSAGE_TYPES = {
   "[\u30CE\u30FC\u30C8]": 0 /* TEXT */
   // JA
 };
-function detectMessageType5(content) {
+function detectMessageType6(content) {
   for (const [pattern, type] of Object.entries(SPECIAL_MESSAGE_TYPES)) {
     if (content === pattern || content.startsWith(pattern)) {
       return type;
@@ -4932,15 +6518,15 @@ function detectMessageType5(content) {
   }
   return 0 /* TEXT */;
 }
-async function* parseLINE(options) {
-  const { filePath, batchSize = 5e3, onProgress, onLog } = options;
+async function* parseLINE(options2) {
+  const { filePath, batchSize = 5e3, onProgress, onLog } = options2;
   const totalBytes = getFileSize(filePath);
   let messagesProcessed = 0;
   const initialProgress = createProgress("parsing", 0, totalBytes, 0, "");
   yield { type: "progress", data: initialProgress };
   onProgress?.(initialProgress);
   onLog?.("info", `\u5F00\u59CB\u89E3\u6790 LINE \u5BFC\u51FA\u6587\u4EF6\uFF0C\u5927\u5C0F: ${(totalBytes / 1024 / 1024).toFixed(2)} MB`);
-  const content = fs16.readFileSync(filePath, "utf-8");
+  const content = fs17.readFileSync(filePath, "utf-8");
   const lines = content.split("\n").map((line) => line.replace(/\r$/, ""));
   let currentDate = null;
   let chatName = extractNameFromFilePath8(filePath);
@@ -5033,7 +6619,7 @@ async function* parseLINE(options) {
         now.setHours(hours, minutes, 0, 0);
         timestamp = Math.floor(now.getTime() / 1e3);
       }
-      const msgType = detectMessageType5(content2);
+      const msgType = detectMessageType6(content2);
       if (!memberMap.has(sender)) {
         memberMap.set(sender, {
           platformId: sender,
@@ -5141,15 +6727,15 @@ async function* parseLINE(options) {
     data: { messageCount: messagesProcessed, memberCount }
   };
 }
-var parser_12 = {
-  feature: feature13,
+var parser_13 = {
+  feature: feature14,
   parse: parseLINE
 };
-var module_13 = {
-  feature: feature13,
-  parser: parser_12
+var module_14 = {
+  feature: feature14,
+  parser: parser_13
 };
-var line_native_txt_default = module_13;
+var line_native_txt_default = module_14;
 
 // ../../packages/parser/src/formats/index.ts
 var formats = [
@@ -5167,6 +6753,8 @@ var formats = [
   // 优先级 22 - Telegram 官方全量导出 JSON
   telegram_native_single_default,
   // 优先级 23 - Telegram 单聊天导出 JSON
+  google_chat_takeout_default,
+  // 优先级 24 - Google Chat Takeout 内部 manifest
   instagram_native_default,
   // 优先级 25 - Instagram 官方导出
   whatsapp_native_txt_default,
@@ -5198,22 +6786,22 @@ function getFormatFeatureById(formatId) {
   return all.find((f) => f.id === formatId) ?? null;
 }
 function getPreprocessor(filePath) {
-  const feature14 = sniffer.sniff(filePath);
-  if (!feature14) return null;
-  const module = formats.find((m) => m.feature.id === feature14.id);
+  const feature15 = sniffer.sniff(filePath);
+  if (!feature15) return null;
+  const module = formats.find((m) => m.feature.id === feature15.id);
   return module?.preprocessor || null;
 }
 async function scanMultiChatFile(filePath) {
-  const feature14 = sniffer.sniff(filePath);
-  if (!feature14) {
+  const feature15 = sniffer.sniff(filePath);
+  if (!feature15) {
     throw new Error(`\u65E0\u6CD5\u8BC6\u522B\u6587\u4EF6\u683C\u5F0F: ${filePath}`);
   }
-  if (!feature14.multiChat) {
-    throw new Error(`\u683C\u5F0F "${feature14.name}" \u4E0D\u662F\u591A\u804A\u5929\u683C\u5F0F`);
+  if (!feature15.multiChat) {
+    throw new Error(`\u683C\u5F0F "${feature15.name}" \u4E0D\u662F\u591A\u804A\u5929\u683C\u5F0F`);
   }
-  const module = formats.find((m) => m.feature.id === feature14.id);
+  const module = formats.find((m) => m.feature.id === feature15.id);
   if (!module?.scanChats) {
-    throw new Error(`\u683C\u5F0F "${feature14.name}" \u58F0\u660E\u4E86 multiChat \u4F46\u672A\u5B9E\u73B0 scanChats`);
+    throw new Error(`\u683C\u5F0F "${feature15.name}" \u58F0\u660E\u4E86 multiChat \u4F46\u672A\u5B9E\u73B0 scanChats`);
   }
   return module.scanChats(filePath);
 }
@@ -5223,35 +6811,35 @@ function needsPreprocess(filePath) {
   const fileSize = getFileSize(filePath);
   return preprocessor.needsPreprocess(filePath, fileSize);
 }
-async function* parseFile(options) {
-  const parser9 = sniffer.getParser(options.filePath);
-  if (!parser9) {
-    yield { type: "error", data: new Error(`\u65E0\u6CD5\u8BC6\u522B\u6587\u4EF6\u683C\u5F0F: ${options.filePath}`) };
+async function* parseFile(options2) {
+  const parser11 = sniffer.getParser(options2.filePath);
+  if (!parser11) {
+    yield { type: "error", data: new Error(`\u65E0\u6CD5\u8BC6\u522B\u6587\u4EF6\u683C\u5F0F: ${options2.filePath}`) };
     return;
   }
-  console.log(`[Parser V2] Using parser: ${parser9.feature.name}`);
-  yield* parser9.parse(options);
+  console.log(`[Parser V2] Using parser: ${parser11.feature.name}`);
+  yield* parser11.parse(options2);
 }
-async function* parseFileWithFormat(formatId, options) {
-  const parser9 = sniffer.getParserById(formatId);
-  if (!parser9) {
+async function* parseFileWithFormat(formatId, options2) {
+  const parser11 = sniffer.getParserById(formatId);
+  if (!parser11) {
     yield { type: "error", data: new Error(`\u672A\u77E5\u7684\u683C\u5F0F ID: ${formatId}`) };
     return;
   }
-  console.log(`[Parser V2] Using parser (explicit): ${parser9.feature.name}`);
-  yield* parser9.parse(options);
+  console.log(`[Parser V2] Using parser (explicit): ${parser11.feature.name}`);
+  yield* parser11.parse(options2);
 }
 function findEntryFileInDirectory(dirPath, maxDepth = 1) {
   function walk(current, depth) {
     if (depth > maxDepth) return null;
     let entries;
     try {
-      entries = fs17.readdirSync(current, { withFileTypes: true });
+      entries = fs18.readdirSync(current, { withFileTypes: true });
     } catch {
       return null;
     }
     for (const entry of entries) {
-      const full = path13.join(current, entry.name);
+      const full = path14.join(current, entry.name);
       if (entry.isFile() && entry.name.endsWith(".json")) {
         const format = detectFormat(full);
         if (format) return full;
@@ -5259,7 +6847,7 @@ function findEntryFileInDirectory(dirPath, maxDepth = 1) {
     }
     for (const entry of entries) {
       if (entry.isDirectory()) {
-        const found = walk(path13.join(current, entry.name), depth + 1);
+        const found = walk(path14.join(current, entry.name), depth + 1);
         if (found) return found;
       }
     }
@@ -5291,7 +6879,7 @@ async function streamParseFile(filePath, callbacks, formatId) {
 }
 
 // ../../packages/node-runtime/src/import/streaming-importer.ts
-import * as fs18 from "fs";
+import * as fs19 from "fs";
 var BATCH_COMMIT_SIZE = 5e4;
 var CHECKPOINT_INTERVAL = 2e5;
 function defaultGenerateSessionId() {
@@ -5302,11 +6890,11 @@ function defaultGenerateSessionId() {
 async function streamingImport(filePath, deps, formatOptions, externalSessionId) {
   if (formatOptions?.formatId) {
     const formatId = formatOptions.formatId;
-    const feature14 = getFormatFeatureById(formatId);
-    if (!feature14) {
+    const feature15 = getFormatFeatureById(formatId);
+    if (!feature15) {
       return { success: false, error: "error.unknown_format_id" };
     }
-    return streamImportSingle(filePath, deps, feature14, formatOptions, externalSessionId);
+    return streamImportSingle(filePath, deps, feature15, formatOptions, externalSessionId);
   }
   const candidates = detectAllFormats(filePath);
   if (candidates.length === 0) {
@@ -5741,7 +7329,7 @@ async function streamParseFileInfo(filePath, deps) {
   if (!formatFeature) {
     throw new Error("Unrecognized file format");
   }
-  const fileSize = fs18.statSync(filePath).size;
+  const fileSize = fs19.statSync(filePath).size;
   deps.onProgress({
     stage: "parsing",
     bytesRead: 0,
@@ -5830,7 +7418,7 @@ async function streamParseFileInfo(filePath, deps) {
     }
     db.close();
     try {
-      if (fs18.existsSync(tempDbPath)) fs18.unlinkSync(tempDbPath);
+      if (fs19.existsSync(tempDbPath)) fs19.unlinkSync(tempDbPath);
     } catch {
     }
     throw error;
@@ -5963,7 +7551,7 @@ async function analyzeIncrementalImport(sessionId, filePath, deps) {
   });
   return { newMessageCount, duplicateCount, totalInFile };
 }
-async function incrementalImport(sessionId, filePath, deps, options) {
+async function incrementalImport(sessionId, filePath, deps, options2) {
   const formatFeature = detectFormat(filePath);
   if (!formatFeature) {
     return { success: false, newMessageCount: 0, error: "error.unrecognized_format" };
@@ -5974,8 +7562,8 @@ async function incrementalImport(sessionId, filePath, deps, options) {
   } catch {
     return { success: false, newMessageCount: 0, error: "error.session_not_found" };
   }
-  const metaUpdateMode = options?.metaUpdateMode ?? "patch";
-  const memberUpdateMode = options?.memberUpdateMode ?? "upsert";
+  const metaUpdateMode = options2?.metaUpdateMode ?? "patch";
+  const memberUpdateMode = options2?.memberUpdateMode ?? "upsert";
   try {
     let trackError2 = function(index, reason, detail) {
       errorCount2++;
@@ -6194,14 +7782,550 @@ async function incrementalImport(sessionId, filePath, deps, options) {
   }
 }
 
-// ../../packages/node-runtime/src/node-path-provider.ts
+// ../../packages/node-runtime/src/import/archive/archive-reader.ts
+var import_yauzl = __toESM(require_yauzl(), 1);
 import * as fs20 from "fs";
-import * as os2 from "os";
 import * as path15 from "path";
+import { pipeline } from "stream/promises";
+
+// ../../packages/node-runtime/src/import/archive/errors.ts
+var ArchiveImportError = class extends Error {
+  constructor(code, message, options2) {
+    super(message, options2);
+    this.code = code;
+    this.name = "ArchiveImportError";
+  }
+  code;
+};
+
+// ../../packages/node-runtime/src/import/archive/archive-reader.ts
+var DEFAULT_MAX_ENTRIES = 1e5;
+var DEFAULT_MAX_ENTRY_BYTES = 20 * 1024 * 1024 * 1024;
+var DEFAULT_MAX_COMPRESSION_RATIO = 1e4;
+function validateArchiveEntryName(fileName) {
+  if (fileName.startsWith("/") || /^[A-Za-z]:\//.test(fileName) || fileName.includes("\\") || fileName.split("/").includes("..")) {
+    throw new ArchiveImportError("error.archive_unsafe_path", `Unsafe archive entry path: ${fileName}`);
+  }
+}
+function mapArchiveError(error) {
+  if (error instanceof ArchiveImportError) return error;
+  const message = error instanceof Error ? error.message : String(error);
+  return new ArchiveImportError("error.archive_corrupt", `Invalid ZIP archive: ${message}`, {
+    cause: error
+  });
+}
+function toSummary(entry) {
+  return {
+    name: entry.fileName,
+    compressedSize: entry.compressedSize,
+    uncompressedSize: entry.uncompressedSize,
+    compressionMethod: entry.compressionMethod,
+    isDirectory: entry.fileName.endsWith("/")
+  };
+}
+function validateEntry(entry, options2) {
+  validateArchiveEntryName(entry.fileName);
+  if (entry.isEncrypted()) {
+    throw new ArchiveImportError("error.archive_encrypted", `Encrypted ZIP entry is not supported: ${entry.fileName}`);
+  }
+  if (!entry.canDecodeFileData() || entry.compressionMethod !== 0 && entry.compressionMethod !== 8) {
+    throw new ArchiveImportError(
+      "error.archive_unsupported",
+      `Unsupported ZIP compression method for entry: ${entry.fileName}`
+    );
+  }
+  if (entry.uncompressedSize > options2.maxEntryBytes) {
+    throw new ArchiveImportError("error.archive_limit_exceeded", `ZIP entry exceeds the size limit: ${entry.fileName}`);
+  }
+  if (entry.uncompressedSize > 0) {
+    const ratio = entry.compressedSize === 0 ? Number.POSITIVE_INFINITY : entry.uncompressedSize / entry.compressedSize;
+    if (ratio > options2.maxCompressionRatio) {
+      throw new ArchiveImportError(
+        "error.archive_limit_exceeded",
+        `ZIP entry exceeds the compression ratio limit: ${entry.fileName}`
+      );
+    }
+  }
+}
+var ZipArchiveReader = class {
+  constructor(archivePath, options2 = {}) {
+    this.archivePath = archivePath;
+    this.options = {
+      maxEntries: options2.maxEntries ?? DEFAULT_MAX_ENTRIES,
+      maxEntryBytes: options2.maxEntryBytes ?? DEFAULT_MAX_ENTRY_BYTES,
+      maxCompressionRatio: options2.maxCompressionRatio ?? DEFAULT_MAX_COMPRESSION_RATIO
+    };
+  }
+  archivePath;
+  options;
+  async open() {
+    try {
+      return await (0, import_yauzl.openPromise)(this.archivePath, {
+        autoClose: true,
+        decodeStrings: true,
+        validateEntrySizes: true,
+        strictFileNames: true
+      });
+    } catch (error) {
+      throw mapArchiveError(error);
+    }
+  }
+  async listEntries() {
+    const entries = [];
+    await this.visitEntries((entry) => {
+      entries.push(entry);
+    });
+    return entries;
+  }
+  /**
+   * 每次只推进一个 ZIP 条目；visitor 若打开流，必须等待流消费结束后返回。
+   * 这样大 ZIP 不会同时创建大量 inflate stream。
+   */
+  async visitEntries(visitor) {
+    const zipFile = await this.open();
+    let count = 0;
+    try {
+      for await (const entry of zipFile.eachEntry()) {
+        count++;
+        if (count > this.options.maxEntries) {
+          throw new ArchiveImportError("error.archive_limit_exceeded", "ZIP archive contains too many entries");
+        }
+        validateEntry(entry, this.options);
+        let opened = false;
+        const openStream = async () => {
+          if (opened) {
+            throw new ArchiveImportError("error.archive_corrupt", `ZIP entry stream opened twice: ${entry.fileName}`);
+          }
+          opened = true;
+          try {
+            return await zipFile.openReadStreamPromise(entry);
+          } catch (error) {
+            throw mapArchiveError(error);
+          }
+        };
+        await visitor(toSummary(entry), openStream);
+      }
+    } catch (error) {
+      throw mapArchiveError(error);
+    } finally {
+      if (zipFile.isOpen) zipFile.close();
+    }
+  }
+  async pipeEntries(targets) {
+    const remaining = new Set(targets.keys());
+    await this.visitEntries(async (entry, openStream) => {
+      const destination = targets.get(entry.name);
+      if (!destination || entry.isDirectory) return;
+      fs20.mkdirSync(path15.dirname(destination), { recursive: true });
+      await pipeline(await openStream(), fs20.createWriteStream(destination, { flags: "wx" }));
+      remaining.delete(entry.name);
+    });
+    if (remaining.size > 0) {
+      throw new ArchiveImportError(
+        "error.archive_corrupt",
+        `ZIP archive is missing expected entries: ${Array.from(remaining).join(", ")}`
+      );
+    }
+  }
+};
+
+// ../../packages/node-runtime/src/import/archive/google-chat-resolver.ts
+var import_stream_chain9 = __toESM(require_stream_chain(), 1);
+var import_stream_json9 = __toESM(require_stream_json(), 1);
+var import_Pick8 = __toESM(require_Pick(), 1);
+var import_StreamValues9 = __toESM(require_StreamValues(), 1);
+import * as fs21 from "fs";
+import * as path16 from "path";
+var { chain: chain9 } = import_stream_chain9.default;
+var { parser: parser10 } = import_stream_json9.default;
+var { pick: pick8 } = import_Pick8.default;
+var { streamValues: streamValues9 } = import_StreamValues9.default;
+var GROUP_FILE = /^Takeout\/Google Chat\/Groups\/((DM|Space) [^/]+)\/(group_info|messages)\.json$/;
+var USER_INFO_FILE = /^Takeout\/Google Chat\/Users\/[^/]+\/user_info\.json$/;
+var TAKEOUT_ROOT = /^Takeout\/([^/]+)\//;
+var MAX_METADATA_BYTES = 5 * 1024 * 1024;
+async function readSmallJson(stream, maxBytes = MAX_METADATA_BYTES) {
+  const chunks = [];
+  let total = 0;
+  for await (const chunk of stream) {
+    const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+    total += buffer.length;
+    if (total > maxBytes) {
+      throw new ArchiveImportError("error.archive_limit_exceeded", "Google Chat metadata exceeds the size limit");
+    }
+    chunks.push(buffer);
+  }
+  try {
+    return JSON.parse(Buffer.concat(chunks).toString("utf8"));
+  } catch (error) {
+    throw new ArchiveImportError("error.archive_corrupt", "Invalid Google Chat metadata JSON", { cause: error });
+  }
+}
+async function countMessages(stream) {
+  const pipeline2 = chain9([stream, parser10(), pick8({ filter: /^messages\.\d+$/ }), streamValues9()]);
+  let count = 0;
+  try {
+    for await (const _item of pipeline2) count++;
+    return count;
+  } catch (error) {
+    throw new ArchiveImportError("error.archive_corrupt", "Invalid Google Chat messages JSON", { cause: error });
+  }
+}
+function normalizeEmail(user) {
+  return user?.email?.trim().toLowerCase() || null;
+}
+function deriveConversationName(draft, ownerEmail) {
+  const groupInfo = draft.groupInfo;
+  if (draft.kind === "Space" && groupInfo?.name?.trim()) return groupInfo.name.trim();
+  const members = groupInfo?.members ?? [];
+  const other = members.find((member) => {
+    const email = normalizeEmail(member);
+    return !ownerEmail || email !== ownerEmail;
+  });
+  return other?.name?.trim() || other?.email?.trim() || members[0]?.name?.trim() || draft.chatId;
+}
+var GoogleChatTakeoutResolver = class {
+  id = "google-chat-takeout";
+  platform = "google-chat";
+  detect(entries) {
+    const products = /* @__PURE__ */ new Set();
+    const groupFiles = /* @__PURE__ */ new Map();
+    for (const entry of entries) {
+      const product = entry.name.match(TAKEOUT_ROOT)?.[1];
+      if (product) products.add(product);
+      const match = entry.name.match(GROUP_FILE);
+      if (!match) continue;
+      const files = groupFiles.get(match[1]) ?? /* @__PURE__ */ new Set();
+      files.add(match[3]);
+      groupFiles.set(match[1], files);
+    }
+    return products.size === 1 && products.has("Google Chat") && Array.from(groupFiles.values()).some((files) => files.has("group_info") && files.has("messages"));
+  }
+  /**
+   * 扫描时按 ZIP 顺序消费必要 JSON。会话元数据和消息计数先暂存，
+   * 等 owner 信息齐备后统一生成名称，避免依赖归档内部文件顺序。
+   */
+  async scan(reader) {
+    let ownerEmail = null;
+    const drafts = /* @__PURE__ */ new Map();
+    await reader.visitEntries(async (entry, openStream) => {
+      if (USER_INFO_FILE.test(entry.name)) {
+        const ownerInfo = await readSmallJson(await openStream());
+        ownerEmail = normalizeEmail(ownerInfo.user);
+        return;
+      }
+      const match = entry.name.match(GROUP_FILE);
+      if (!match) return;
+      const chatId = `Groups/${match[1]}`;
+      const draft = drafts.get(chatId) ?? {
+        chatId,
+        kind: match[2]
+      };
+      if (match[3] === "group_info") {
+        draft.groupInfoEntry = entry.name;
+        draft.groupInfo = await readSmallJson(await openStream());
+      } else {
+        draft.messagesEntry = entry.name;
+        draft.messageCount = await countMessages(await openStream());
+      }
+      drafts.set(chatId, draft);
+    });
+    if (drafts.size === 0) {
+      throw new ArchiveImportError(
+        "error.google_chat_structure_not_found",
+        "Google Chat conversation structure was not found"
+      );
+    }
+    return Array.from(drafts.values()).map((draft) => {
+      if (!draft.groupInfoEntry || !draft.messagesEntry || !draft.groupInfo || draft.messageCount === void 0) {
+        throw new ArchiveImportError(
+          "error.google_chat_conversation_incomplete",
+          `Google Chat conversation is missing required files: ${draft.chatId}`
+        );
+      }
+      return {
+        chatId: draft.chatId,
+        name: deriveConversationName(draft, ownerEmail),
+        type: draft.kind === "Space" ? "group" : "private",
+        messageCount: draft.messageCount,
+        memberCount: draft.groupInfo.members?.length ?? 0
+      };
+    }).sort((a, b) => a.chatId.localeCompare(b.chatId));
+  }
+  async materialize(reader, chat, targetDir) {
+    const entries = await reader.listEntries();
+    const groupPrefix = `Takeout/Google Chat/${chat.chatId}/`;
+    const userInfoEntry = entries.find((entry) => USER_INFO_FILE.test(entry.name))?.name;
+    const groupInfoEntry = `${groupPrefix}group_info.json`;
+    const messagesEntry = `${groupPrefix}messages.json`;
+    if (!userInfoEntry || !entries.some((entry) => entry.name === groupInfoEntry) || !entries.some((entry) => entry.name === messagesEntry)) {
+      throw new ArchiveImportError(
+        "error.google_chat_conversation_incomplete",
+        `Google Chat conversation is missing required files: ${chat.chatId}`
+      );
+    }
+    fs21.mkdirSync(targetDir, { recursive: true });
+    await reader.pipeEntries(
+      /* @__PURE__ */ new Map([
+        [userInfoEntry, path16.join(targetDir, "user_info.json")],
+        [groupInfoEntry, path16.join(targetDir, "group_info.json")],
+        [messagesEntry, path16.join(targetDir, "messages.json")]
+      ])
+    );
+    const manifestPath = path16.join(targetDir, "google-chat-import.json");
+    fs21.writeFileSync(
+      manifestPath,
+      JSON.stringify(
+        {
+          format: "chatlab-google-chat-takeout",
+          version: 1,
+          chatId: chat.chatId,
+          chatType: chat.type,
+          chatName: chat.name,
+          userInfoFile: "user_info.json",
+          groupInfoFile: "group_info.json",
+          messagesFile: "messages.json"
+        },
+        null,
+        2
+      ),
+      { encoding: "utf8", flag: "wx" }
+    );
+    return { manifestPath };
+  }
+};
+
+// ../../packages/node-runtime/src/import/archive/source-manager.ts
+import * as fs22 from "fs";
+import * as path17 from "path";
+import { randomUUID } from "crypto";
+var DEFAULT_TTL_MS = 30 * 60 * 1e3;
+var ArchiveImportSourceManager = class {
+  records = /* @__PURE__ */ new Map();
+  expiredSourceIds = /* @__PURE__ */ new Set();
+  tempRoot;
+  ttlMs;
+  now;
+  resolvers;
+  constructor(options2 = {}) {
+    this.tempRoot = options2.tempRoot ?? path17.join(process.cwd(), ".chatlab-import-sources");
+    this.ttlMs = options2.ttlMs ?? DEFAULT_TTL_MS;
+    this.now = options2.now ?? Date.now;
+    this.resolvers = options2.resolvers ?? [new GoogleChatTakeoutResolver()];
+    fs22.mkdirSync(this.tempRoot, { recursive: true });
+  }
+  prepareLocalArchive(archivePath) {
+    return this.prepareArchive(archivePath, false);
+  }
+  prepareOwnedArchive(archivePath) {
+    return this.prepareArchive(archivePath, true);
+  }
+  async prepareArchive(archivePath, ownsArchive) {
+    await this.cleanupExpired();
+    const reader = new ZipArchiveReader(archivePath);
+    try {
+      const entries = await reader.listEntries();
+      const matches = this.resolvers.filter((resolver2) => resolver2.detect(entries));
+      if (matches.length !== 1) {
+        throw new ArchiveImportError(
+          "error.archive_unsupported",
+          matches.length === 0 ? "Unsupported archive format" : "Archive matches multiple import formats"
+        );
+      }
+      const resolver = matches[0];
+      const chats = await resolver.scan(reader);
+      const createdAt = this.now();
+      const sourceId = randomUUID();
+      const descriptor = {
+        sourceId,
+        formatId: resolver.id,
+        platform: resolver.platform,
+        chats,
+        expiresAt: createdAt + this.ttlMs
+      };
+      this.records.set(sourceId, {
+        descriptor,
+        archivePath,
+        ownsArchive,
+        resolver,
+        lastAccessAt: createdAt
+      });
+      return descriptor;
+    } catch (error) {
+      if (ownsArchive) this.removePath(archivePath);
+      throw error;
+    }
+  }
+  /**
+   * selected chat 的 JSON 物化目录只在 handler 生命周期内存在。
+   * 无论数据库导入成功、失败还是抛异常，finally 都会删除它。
+   */
+  async withMaterializedChat(sourceId, chatId, handler) {
+    const record = await this.getActiveRecord(sourceId);
+    const chat = record.descriptor.chats.find((item) => item.chatId === chatId);
+    if (!chat) {
+      throw new ArchiveImportError(
+        "error.google_chat_conversation_incomplete",
+        `Archive conversation was not found: ${chatId}`
+      );
+    }
+    const materializedDir = fs22.mkdtempSync(path17.join(this.tempRoot, `materialized-${sourceId}-`));
+    try {
+      const reader = new ZipArchiveReader(record.archivePath);
+      const materialized = await record.resolver.materialize(reader, chat, materializedDir);
+      return await handler(materialized.manifestPath);
+    } finally {
+      this.removePath(materializedDir);
+    }
+  }
+  async release(sourceId) {
+    const record = this.records.get(sourceId);
+    if (!record) return;
+    this.records.delete(sourceId);
+    if (record.ownsArchive) this.removePath(record.archivePath);
+  }
+  async cleanupExpired(now = this.now()) {
+    let removed = 0;
+    for (const [sourceId, record] of this.records) {
+      if (now - record.lastAccessAt < this.ttlMs) continue;
+      this.records.delete(sourceId);
+      this.expiredSourceIds.add(sourceId);
+      if (record.ownsArchive) this.removePath(record.archivePath);
+      removed++;
+    }
+    return removed;
+  }
+  async close() {
+    for (const sourceId of Array.from(this.records.keys())) {
+      await this.release(sourceId);
+    }
+    this.removePath(this.tempRoot);
+  }
+  async getActiveRecord(sourceId) {
+    const record = this.records.get(sourceId);
+    if (!record) {
+      const code = this.expiredSourceIds.has(sourceId) ? "error.import_source_expired" : "error.import_source_not_found";
+      throw new ArchiveImportError(code, `Archive import source is unavailable: ${sourceId}`);
+    }
+    const now = this.now();
+    if (now - record.lastAccessAt >= this.ttlMs) {
+      this.records.delete(sourceId);
+      this.expiredSourceIds.add(sourceId);
+      if (record.ownsArchive) this.removePath(record.archivePath);
+      throw new ArchiveImportError("error.import_source_expired", `Archive import source expired: ${sourceId}`);
+    }
+    record.lastAccessAt = now;
+    record.descriptor.expiresAt = now + this.ttlMs;
+    return record;
+  }
+  removePath(targetPath) {
+    try {
+      fs22.rmSync(targetPath, { recursive: true, force: true });
+    } catch {
+    }
+  }
+};
+
+// ../../packages/node-runtime/src/logging/app-logger.ts
+import * as fs23 from "fs";
+import * as path18 from "path";
+var LEVEL_ORDER = { DEBUG: 0, INFO: 1, WARN: 2, ERROR: 3 };
+var MAX_SIZE_BYTES = 10 * 1024 * 1024;
+var AppLogger = class {
+  logFile;
+  oldLogFile;
+  threshold;
+  constructor(logsDir) {
+    this.logFile = path18.join(logsDir, "app.log");
+    this.oldLogFile = path18.join(logsDir, "app.old.log");
+    this.threshold = resolveThreshold();
+  }
+  debug(scope, message, data) {
+    this.write("DEBUG", scope, message, data);
+  }
+  info(scope, message, data) {
+    this.write("INFO", scope, message, data);
+  }
+  warn(scope, message, data) {
+    this.write("WARN", scope, message, data);
+  }
+  /** `data` may be an Error; its name/message/stack are extracted automatically. */
+  error(scope, message, data) {
+    this.write("ERROR", scope, message, data);
+  }
+  getLogPath() {
+    return this.logFile;
+  }
+  write(level, scope, message, data) {
+    if (LEVEL_ORDER[level] < LEVEL_ORDER[this.threshold]) return;
+    let line = `[${(/* @__PURE__ */ new Date()).toISOString()}] [${level}] [${scope}] ${message}`;
+    try {
+      const tail = formatData(data);
+      if (tail) line += `
+${tail}`;
+      line += "\n";
+      ensureDir2(path18.dirname(this.logFile));
+      this.rotateIfNeeded();
+      fs23.appendFileSync(this.logFile, line, "utf-8");
+    } catch (err) {
+      console.error("[AppLogger] Failed to write log:", err);
+    }
+  }
+  // ponytail: rename-based rotation, atomic, no rewrite, ~20MB total ceiling
+  rotateIfNeeded() {
+    let size = 0;
+    try {
+      size = fs23.statSync(this.logFile).size;
+    } catch {
+      return;
+    }
+    if (size < MAX_SIZE_BYTES) return;
+    fs23.renameSync(this.logFile, this.oldLogFile);
+  }
+};
+function resolveThreshold() {
+  const raw = (process.env.CHATLAB_LOG_LEVEL || "").toUpperCase();
+  if (raw === "DEBUG" || raw === "INFO" || raw === "WARN" || raw === "ERROR") return raw;
+  return "INFO";
+}
+function formatData(data) {
+  if (data === void 0) return "";
+  if (data instanceof Error) {
+    const info = extractErrorInfo(data);
+    const stack = extractErrorStack(data);
+    return JSON.stringify(info) + (stack ? `
+${stack}` : "");
+  }
+  if (typeof data === "string") return data;
+  try {
+    return JSON.stringify(data);
+  } catch {
+    return "[unserializable data]";
+  }
+}
+function ensureDir2(dir) {
+  if (!fs23.existsSync(dir)) fs23.mkdirSync(dir, { recursive: true });
+}
+var instance = null;
+function initAppLogger(logsDir) {
+  instance = new AppLogger(logsDir);
+}
+var appLogger = {
+  debug: (scope, message, data) => instance?.debug(scope, message, data),
+  info: (scope, message, data) => instance?.info(scope, message, data),
+  warn: (scope, message, data) => instance?.warn(scope, message, data),
+  error: (scope, message, data) => instance?.error(scope, message, data),
+  getLogPath: () => instance?.getLogPath() ?? null
+};
+
+// ../../packages/node-runtime/src/node-path-provider.ts
+import * as fs25 from "fs";
+import * as os2 from "os";
+import * as path20 from "path";
 
 // ../../packages/node-runtime/src/data-dir-switch.ts
-import * as fs19 from "fs";
-import * as path14 from "path";
+import * as fs24 from "fs";
+import * as path19 from "path";
 var CHATLAB_MARKER_FILE = ".chatlab";
 var USER_DATA_REQUIRED_DIRS = ["databases"];
 var PENDING_MIGRATION_FILE = "data-dir-migration.json";
@@ -6222,15 +8346,15 @@ var DANGEROUS_PATHS = [
   "/Library"
 ];
 function normalizePathForCompare(input) {
-  const resolved = path14.resolve(input);
-  const normalized = path14.normalize(resolved);
+  const resolved = path19.resolve(input);
+  const normalized = path19.normalize(resolved);
   return process.platform === "win32" ? normalized.toLowerCase() : normalized;
 }
 function isSubPath(parent, child) {
   const parentPath = normalizePathForCompare(parent);
   const childPath = normalizePathForCompare(child);
   if (parentPath === childPath) return false;
-  return childPath.startsWith(`${parentPath}${path14.sep}`);
+  return childPath.startsWith(`${parentPath}${path19.sep}`);
 }
 function isPathSafe(targetPath) {
   const normalizedTarget = targetPath.toLowerCase().replace(/\//g, "\\");
@@ -6242,37 +8366,37 @@ function isPathSafe(targetPath) {
   }
   return true;
 }
-function ensureDir2(dirPath) {
-  if (!fs19.existsSync(dirPath)) {
-    fs19.mkdirSync(dirPath, { recursive: true });
+function ensureDir3(dirPath) {
+  if (!fs24.existsSync(dirPath)) {
+    fs24.mkdirSync(dirPath, { recursive: true });
   }
 }
 function hasChatLabUserDataStructure(entries) {
   return entries.includes(CHATLAB_MARKER_FILE) && USER_DATA_REQUIRED_DIRS.every((dir) => entries.includes(dir));
 }
 function hasChatLabDatabaseFiles(dirPath, entries) {
-  const dirEntries = entries ?? fs19.readdirSync(dirPath);
+  const dirEntries = entries ?? fs24.readdirSync(dirPath);
   if (!dirEntries.includes("databases")) return false;
-  const dbDir = path14.join(dirPath, "databases");
+  const dbDir = path19.join(dirPath, "databases");
   try {
-    return fs19.existsSync(dbDir) && fs19.readdirSync(dbDir).some((file) => file.endsWith(".db"));
+    return fs24.existsSync(dbDir) && fs24.readdirSync(dbDir).some((file) => file.endsWith(".db"));
   } catch {
     return false;
   }
 }
 function isExistingUserDataDir(dirPath) {
-  if (!fs19.existsSync(dirPath)) return false;
+  if (!fs24.existsSync(dirPath)) return false;
   try {
-    const entries = fs19.readdirSync(dirPath);
+    const entries = fs24.readdirSync(dirPath);
     return hasChatLabUserDataStructure(entries) || hasChatLabDatabaseFiles(dirPath, entries);
   } catch {
     return false;
   }
 }
 function isUserDataDirSafeToUse(dirPath) {
-  if (!fs19.existsSync(dirPath)) return true;
+  if (!fs24.existsSync(dirPath)) return true;
   try {
-    const entries = fs19.readdirSync(dirPath);
+    const entries = fs24.readdirSync(dirPath);
     if (entries.length === 0) return true;
     return hasChatLabUserDataStructure(entries) || hasChatLabDatabaseFiles(dirPath, entries);
   } catch {
@@ -6280,26 +8404,26 @@ function isUserDataDirSafeToUse(dirPath) {
   }
 }
 function isDirectoryEmptyOrMissing(dirPath) {
-  if (!fs19.existsSync(dirPath)) return true;
+  if (!fs24.existsSync(dirPath)) return true;
   try {
-    return fs19.readdirSync(dirPath).length === 0;
+    return fs24.readdirSync(dirPath).length === 0;
   } catch {
     return false;
   }
 }
-function copyDirMerge(src, dest, mkdir = ensureDir2, stats = { copied: 0, skipped: 0, errors: [] }) {
-  if (!fs19.existsSync(src)) return stats;
+function copyDirMerge(src, dest, mkdir = ensureDir3, stats = { copied: 0, skipped: 0, errors: [] }) {
+  if (!fs24.existsSync(src)) return stats;
   try {
     mkdir(dest);
-    const entries = fs19.readdirSync(src, { withFileTypes: true });
+    const entries = fs24.readdirSync(src, { withFileTypes: true });
     for (const entry of entries) {
-      const srcPath = path14.join(src, entry.name);
-      const destPath = path14.join(dest, entry.name);
+      const srcPath = path19.join(src, entry.name);
+      const destPath = path19.join(dest, entry.name);
       try {
         if (entry.isDirectory()) {
           copyDirMerge(srcPath, destPath, mkdir, stats);
-        } else if (!fs19.existsSync(destPath)) {
-          fs19.copyFileSync(srcPath, destPath);
+        } else if (!fs24.existsSync(destPath)) {
+          fs24.copyFileSync(srcPath, destPath);
           stats.copied++;
         } else {
           stats.skipped++;
@@ -6324,10 +8448,10 @@ function createPendingDataDirMigration(input) {
 }
 function runPendingDataDirMigration(pending, deps) {
   const copy = deps.copyDirMerge ?? copyDirMerge;
-  const mkdir = deps.ensureDir ?? ensureDir2;
+  const mkdir = deps.ensureDir ?? ensureDir3;
   let stats = { copied: 0, skipped: 0, errors: [] };
-  if (pending.migrate && path14.resolve(pending.from) !== path14.resolve(pending.to)) {
-    if (!fs19.existsSync(pending.from)) {
+  if (pending.migrate && path19.resolve(pending.from) !== path19.resolve(pending.to)) {
+    if (!fs24.existsSync(pending.from)) {
       return {
         success: false,
         from: pending.from,
@@ -6356,7 +8480,7 @@ function runPendingDataDirMigration(pending, deps) {
   }
   deps.writeUserDataDir(pending.to);
   deps.clearPendingMigration();
-  if (pending.deleteSourceOnSuccess && path14.resolve(pending.from) !== path14.resolve(pending.to)) {
+  if (pending.deleteSourceOnSuccess && path19.resolve(pending.from) !== path19.resolve(pending.to)) {
     deps.markPendingDeleteDir?.(pending.from);
   }
   return {
@@ -6369,13 +8493,13 @@ function runPendingDataDirMigration(pending, deps) {
   };
 }
 function getPendingMigrationPath(systemDir) {
-  return path14.join(systemDir, "settings", PENDING_MIGRATION_FILE);
+  return path19.join(systemDir, "settings", PENDING_MIGRATION_FILE);
 }
 function getPendingNodeDataDirMigration(systemDir) {
   const filePath = getPendingMigrationPath(systemDir);
-  if (!fs19.existsSync(filePath)) return null;
+  if (!fs24.existsSync(filePath)) return null;
   try {
-    const parsed = JSON.parse(fs19.readFileSync(filePath, "utf-8"));
+    const parsed = JSON.parse(fs24.readFileSync(filePath, "utf-8"));
     if (!parsed.from || !parsed.to || typeof parsed.migrate !== "boolean") return null;
     return parsed;
   } catch {
@@ -6384,23 +8508,23 @@ function getPendingNodeDataDirMigration(systemDir) {
 }
 function clearPendingNodeDataDirMigration(systemDir) {
   const filePath = getPendingMigrationPath(systemDir);
-  if (fs19.existsSync(filePath)) {
-    fs19.unlinkSync(filePath);
+  if (fs24.existsSync(filePath)) {
+    fs24.unlinkSync(filePath);
   }
 }
 function deleteOldUserDataDirIfSafe(dirPath, currentDir, removeDir) {
-  if (path14.resolve(dirPath) === path14.resolve(currentDir)) return false;
+  if (path19.resolve(dirPath) === path19.resolve(currentDir)) return false;
   if (!isPathSafe(dirPath)) return false;
-  if (!fs19.existsSync(dirPath)) return false;
+  if (!fs24.existsSync(dirPath)) return false;
   if (!isExistingUserDataDir(dirPath)) return false;
-  const remove = removeDir ?? ((dir) => fs19.rmSync(dir, { recursive: true, force: true }));
+  const remove = removeDir ?? ((dir) => fs24.rmSync(dir, { recursive: true, force: true }));
   remove(dirPath);
   return true;
 }
 function writePendingNodeDataDirMigration(systemDir, pending) {
   const filePath = getPendingMigrationPath(systemDir);
-  ensureDir2(path14.dirname(filePath));
-  fs19.writeFileSync(filePath, JSON.stringify(pending, null, 2), "utf-8");
+  ensureDir3(path19.dirname(filePath));
+  fs24.writeFileSync(filePath, JSON.stringify(pending, null, 2), "utf-8");
 }
 function createNodeDataDirSwitch(input) {
   if (input.envDataDir) {
@@ -6408,16 +8532,16 @@ function createNodeDataDirSwitch(input) {
   }
   const newDir = (input.targetDir?.trim() || input.defaultDir || "").trim();
   if (!newDir) return { success: false, error: "Data directory is required" };
-  if (!path14.isAbsolute(newDir)) return { success: false, error: "Data directory must be an absolute path" };
+  if (!path19.isAbsolute(newDir)) return { success: false, error: "Data directory must be an absolute path" };
   if (!isPathSafe(newDir)) return { success: false, error: "System directories cannot be used as data directory" };
   const migrate = input.migrate !== false;
-  if (migrate && path14.resolve(input.currentDir) !== path14.resolve(newDir) && isSubPath(input.currentDir, newDir)) {
+  if (migrate && path19.resolve(input.currentDir) !== path19.resolve(newDir) && isSubPath(input.currentDir, newDir)) {
     return { success: false, error: "Target directory cannot be inside current data directory" };
   }
   if (!isUserDataDirSafeToUse(newDir)) {
     return { success: false, error: "Target directory is not empty and is not a ChatLab data directory" };
   }
-  if (path14.resolve(input.currentDir) === path14.resolve(newDir)) {
+  if (path19.resolve(input.currentDir) === path19.resolve(newDir)) {
     clearPendingNodeDataDirMigration(input.systemDir);
     return { success: true, from: input.currentDir, to: newDir, requiresRelaunch: false };
   }
@@ -6453,7 +8577,7 @@ function applyPendingNodeDataDirMigration(systemDir, deps = {}) {
 }
 
 // ../../packages/node-runtime/src/node-path-provider.ts
-var SYSTEM_DIR = path15.join(os2.homedir(), ".chatlab");
+var SYSTEM_DIR = path20.join(os2.homedir(), ".chatlab");
 var _pendingElectronDataWarning = false;
 function hasPendingElectronDataWarning() {
   return _pendingElectronDataWarning;
@@ -6476,28 +8600,28 @@ var NodePathProvider = class {
     return this.userDataDir;
   }
   getDatabaseDir() {
-    return path15.join(this.userDataDir, "databases");
+    return path20.join(this.userDataDir, "databases");
   }
   getVectorDir() {
-    return path15.join(this.userDataDir, "vector");
+    return path20.join(this.userDataDir, "vector");
   }
   getAiDataDir() {
-    return path15.join(this.systemDir, "ai");
+    return path20.join(this.systemDir, "ai");
   }
   getSettingsDir() {
-    return path15.join(this.systemDir, "settings");
+    return path20.join(this.systemDir, "settings");
   }
   getCacheDir() {
-    return path15.join(this.systemDir, "cache");
+    return path20.join(this.systemDir, "cache");
   }
   getTempDir() {
-    return path15.join(this.systemDir, "temp");
+    return path20.join(this.systemDir, "temp");
   }
   getLogsDir() {
-    return path15.join(this.systemDir, "logs");
+    return path20.join(this.systemDir, "logs");
   }
   getDownloadsDir() {
-    return path15.join(os2.homedir(), "Downloads");
+    return path20.join(os2.homedir(), "Downloads");
   }
   /**
    * 确保系统目录和用户数据目录都存在
@@ -6515,13 +8639,13 @@ var NodePathProvider = class {
       this.getLogsDir()
     ];
     for (const dir of dirs) {
-      if (!fs20.existsSync(dir)) {
-        fs20.mkdirSync(dir, { recursive: true });
+      if (!fs25.existsSync(dir)) {
+        fs25.mkdirSync(dir, { recursive: true });
       }
     }
-    const markerPath = path15.join(this.userDataDir, ".chatlab");
-    if (!fs20.existsSync(markerPath)) {
-      fs20.writeFileSync(markerPath, "ChatLab Data Directory", "utf-8");
+    const markerPath = path20.join(this.userDataDir, ".chatlab");
+    if (!fs25.existsSync(markerPath)) {
+      fs25.writeFileSync(markerPath, "ChatLab Data Directory", "utf-8");
     }
   }
 };
@@ -6547,11 +8671,14 @@ function resolveUserDataDir() {
   return defaultDir;
 }
 function getDefaultNodeUserDataDir() {
-  return path15.join(os2.homedir(), ".chatlab", "data");
+  return path20.join(os2.homedir(), ".chatlab", "data");
+}
+function getSystemLogsDir() {
+  return path20.join(SYSTEM_DIR, "logs");
 }
 function expandHome(filePath) {
   if (filePath.startsWith("~/") || filePath === "~") {
-    return path15.join(os2.homedir(), filePath.slice(1));
+    return path20.join(os2.homedir(), filePath.slice(1));
   }
   return filePath;
 }
@@ -6568,12 +8695,12 @@ function createJiebaNlpProvider(dictType = "default") {
 }
 
 // ../../packages/node-runtime/src/cache/analytics-cache.ts
-import * as fs21 from "fs";
+import * as fs26 from "fs";
 function getDbFileVersion(dbPath) {
   const parts = [];
   for (const p of [dbPath, `${dbPath}-wal`]) {
     try {
-      const st = fs21.statSync(p);
+      const st = fs26.statSync(p);
       parts.push(`${Math.floor(st.mtimeMs)}:${st.size}`);
     } catch {
       parts.push("-");
@@ -6592,8 +8719,8 @@ function getOrComputeAnalysisCache(sessionId, key, queryCacheDir, version, compu
 }
 
 // ../../packages/node-runtime/src/preferences.ts
-import * as fs22 from "fs";
-import * as path16 from "path";
+import * as fs27 from "fs";
+import * as path21 from "path";
 var DEFAULTS = {
   pinnedSessionIds: [],
   aiPreprocessConfig: {
@@ -6639,13 +8766,13 @@ var PreferencesManager = class {
   filePath;
   cache = null;
   constructor(systemDir) {
-    this.filePath = path16.join(systemDir, "preferences.json");
+    this.filePath = path21.join(systemDir, "preferences.json");
   }
   load() {
     if (this.cache) return this.cache;
     try {
-      if (fs22.existsSync(this.filePath)) {
-        const raw = fs22.readFileSync(this.filePath, "utf-8");
+      if (fs27.existsSync(this.filePath)) {
+        const raw = fs27.readFileSync(this.filePath, "utf-8");
         const parsed = JSON.parse(raw);
         const migrated = this.migrateLegacyDesensitizeRules(parsed, raw);
         this.cache = this.mergeDefaults(migrated.preferences);
@@ -6760,21 +8887,21 @@ var PreferencesManager = class {
     };
   }
   backupLegacyPreferences(rawContent) {
-    const backupDir = path16.join(path16.dirname(this.filePath), "backups");
-    if (!fs22.existsSync(backupDir)) {
-      fs22.mkdirSync(backupDir, { recursive: true });
+    const backupDir = path21.join(path21.dirname(this.filePath), "backups");
+    if (!fs27.existsSync(backupDir)) {
+      fs27.mkdirSync(backupDir, { recursive: true });
     }
     const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-    const backupPath = path16.join(backupDir, `preferences-pre-desensitize-groups-${timestamp}.json`);
-    fs22.writeFileSync(backupPath, rawContent, "utf-8");
+    const backupPath = path21.join(backupDir, `preferences-pre-desensitize-groups-${timestamp}.json`);
+    fs27.writeFileSync(backupPath, rawContent, "utf-8");
     console.info(`[Preferences] Backed up legacy desensitize rules to ${backupPath}`);
   }
   writePreferences(preferences) {
-    const dir = path16.dirname(this.filePath);
-    if (!fs22.existsSync(dir)) {
-      fs22.mkdirSync(dir, { recursive: true });
+    const dir = path21.dirname(this.filePath);
+    if (!fs27.existsSync(dir)) {
+      fs27.mkdirSync(dir, { recursive: true });
     }
-    fs22.writeFileSync(this.filePath, JSON.stringify(preferences, null, 2), "utf-8");
+    fs27.writeFileSync(this.filePath, JSON.stringify(preferences, null, 2), "utf-8");
   }
   /**
    * Deep merge: arrays are replaced (not concatenated), objects are merged.
@@ -6894,8 +9021,8 @@ function* serializeChatLabToJsonl(data) {
 }
 
 // ../../packages/node-runtime/src/services/analytics.ts
-import * as fs23 from "fs";
-import * as path17 from "path";
+import * as fs28 from "fs";
+import * as path22 from "path";
 var REGIONS = {
   US: "https://us.aptabase.com",
   EU: "https://eu.aptabase.com"
@@ -6908,7 +9035,7 @@ var AnalyticsService = class {
   appVersion;
   sessionId;
   constructor(systemDir, appKey, appVersion) {
-    this.dataPath = path17.join(systemDir, "analytics.json");
+    this.dataPath = path22.join(systemDir, "analytics.json");
     this.appKey = appKey;
     this.appVersion = appVersion;
     this.sessionId = `${Math.floor(Date.now() / 1e3)}${Math.floor(Math.random() * 1e8).toString().padStart(8, "0")}`;
@@ -6918,8 +9045,8 @@ var AnalyticsService = class {
   }
   load() {
     try {
-      if (fs23.existsSync(this.dataPath)) {
-        return { ...DEFAULT_DATA, ...JSON.parse(fs23.readFileSync(this.dataPath, "utf-8")) };
+      if (fs28.existsSync(this.dataPath)) {
+        return { ...DEFAULT_DATA, ...JSON.parse(fs28.readFileSync(this.dataPath, "utf-8")) };
       }
     } catch (_e) {
     }
@@ -6927,7 +9054,7 @@ var AnalyticsService = class {
   }
   save(data) {
     try {
-      fs23.writeFileSync(this.dataPath, JSON.stringify(data, null, 2), "utf-8");
+      fs28.writeFileSync(this.dataPath, JSON.stringify(data, null, 2), "utf-8");
     } catch (e) {
       console.error("[Analytics] Failed to save:", e);
     }
@@ -7047,7 +9174,7 @@ __export(semantic_index_exports, {
 });
 
 // ../../packages/node-runtime/src/semantic-index/worker-client.ts
-import path18 from "path";
+import path23 from "path";
 
 // ../../packages/node-runtime/src/semantic-index/worker-thread-transport.ts
 import { Worker } from "worker_threads";
@@ -7069,22 +9196,22 @@ function createDefaultWorker(startup, entryUrlInput) {
     register();
     await import(${JSON.stringify(entryUrl.href)});
   `;
-  const options = {
+  const options2 = {
     eval: true,
     type: "module",
     workerData: startup,
     execArgv: []
   };
-  return new Worker(bootstrap, options);
+  return new Worker(bootstrap, options2);
 }
 var SemanticIndexWorkerThreadTransport = class {
   worker;
   pending = /* @__PURE__ */ new Map();
   requestId = 0;
   closeTimeoutMs;
-  constructor(options) {
-    this.closeTimeoutMs = options.closeTimeoutMs ?? DEFAULT_CLOSE_TIMEOUT_MS;
-    this.worker = options.workerFactory?.() ?? createDefaultWorker(options.startup, options.workerEntryUrl);
+  constructor(options2) {
+    this.closeTimeoutMs = options2.closeTimeoutMs ?? DEFAULT_CLOSE_TIMEOUT_MS;
+    this.worker = options2.workerFactory?.() ?? createDefaultWorker(options2.startup, options2.workerEntryUrl);
     this.worker.on("message", (message) => this.handleMessage(message));
     this.worker.on("error", (error) => this.rejectAll(error));
     this.worker.on("exit", (code) => {
@@ -7093,8 +9220,8 @@ var SemanticIndexWorkerThreadTransport = class {
   }
   request(method, args) {
     const id = `si_${++this.requestId}`;
-    return new Promise((resolve2, reject) => {
-      this.pending.set(id, { resolve: resolve2, reject });
+    return new Promise((resolve3, reject) => {
+      this.pending.set(id, { resolve: resolve3, reject });
       this.worker.postMessage({ id, method, args });
     });
   }
@@ -7105,8 +9232,8 @@ var SemanticIndexWorkerThreadTransport = class {
   }
   async requestRuntimeClose() {
     let timeout = null;
-    const timeoutPromise = new Promise((resolve2) => {
-      timeout = setTimeout(resolve2, this.closeTimeoutMs);
+    const timeoutPromise = new Promise((resolve3) => {
+      timeout = setTimeout(resolve3, this.closeTimeoutMs);
     });
     try {
       await Promise.race([this.request("__close", []).then(() => void 0), timeoutPromise]);
@@ -7131,8 +9258,8 @@ var SemanticIndexWorkerThreadTransport = class {
     }
   }
 };
-function createSemanticIndexWorkerThreadTransport(options) {
-  return new SemanticIndexWorkerThreadTransport(options);
+function createSemanticIndexWorkerThreadTransport(options2) {
+  return new SemanticIndexWorkerThreadTransport(options2);
 }
 
 // ../../packages/node-runtime/src/semantic-index/worker-client.ts
@@ -7153,24 +9280,25 @@ var SemanticIndexWorkerClient = class {
   timers;
   resolveApiKey;
   writeAuthProfile;
-  constructor(options) {
-    this.configStore = options.configStore;
-    this.transportFactory = options.transportFactory;
-    this.idleTimeoutMs = options.idleTimeoutMs ?? DEFAULT_IDLE_TIMEOUT_MS;
-    this.timers = options.timers ?? defaultTimers;
-    this.resolveApiKey = options.resolveApiKey ?? resolveApiKey;
-    this.writeAuthProfile = options.writeAuthProfile;
+  constructor(options2) {
+    this.configStore = options2.configStore;
+    this.transportFactory = options2.transportFactory;
+    this.idleTimeoutMs = options2.idleTimeoutMs ?? DEFAULT_IDLE_TIMEOUT_MS;
+    this.timers = options2.timers ?? defaultTimers;
+    this.resolveApiKey = options2.resolveApiKey ?? resolveApiKey;
+    this.writeAuthProfile = options2.writeAuthProfile;
   }
   getConfig() {
     return this.configStore.get();
   }
-  async setConfig(config, options) {
+  async setConfig(config, options2) {
     const saved = persistSemanticIndexConfig(this.configStore, config, {
-      apiKey: options?.apiKey,
+      apiKey: options2?.apiKey,
       writeAuthProfile: this.writeAuthProfile
     });
     if (!saved.enabled) this.clearActiveBuildTracking();
-    if (!this.transport) return saved;
+    const needsWorker = saved.enabled && saved.mode === "local" && this.configStore.isConfigured();
+    if (!this.transport && !needsWorker) return saved;
     return await this.call("setConfig", [saved]);
   }
   isConfigured() {
@@ -7179,11 +9307,15 @@ var SemanticIndexWorkerClient = class {
   hasApiKey() {
     return resolveSemanticIndexApiKeySet(this.configStore.get(), this.resolveApiKey);
   }
+  async getModelStatus() {
+    if (!this.transport) return "idle";
+    return this.call("getModelStatus", []);
+  }
   enable(sessionId) {
     return this.call("enable", [sessionId]);
   }
-  disable(sessionId) {
-    return this.call("disable", [sessionId]);
+  remove(sessionId) {
+    return this.call("remove", [sessionId]);
   }
   async build(sessionId) {
     this.activeBuildSessionIds.add(sessionId);
@@ -7246,11 +9378,11 @@ var SemanticIndexWorkerClient = class {
     if (!this.canRunFromLocalConfig()) return false;
     return await this.callProbe("canSearch", [sessionId], false);
   }
-  search(sessionId, query, options) {
-    return this.call("search", [sessionId, query, options]);
+  search(sessionId, query, options2) {
+    return this.call("search", [sessionId, query, options2]);
   }
-  searchForTool(sessionId, query, options) {
-    return this.call("searchForTool", [sessionId, query, options]);
+  searchForTool(sessionId, query, options2) {
+    return this.call("searchForTool", [sessionId, query, options2]);
   }
   cleanupUnused() {
     return this.call("cleanupUnused", []);
@@ -7262,7 +9394,7 @@ var SemanticIndexWorkerClient = class {
     this.clearIdleTimer();
     await this.closeTransport();
   }
-  async call(method, args, options) {
+  async call(method, args, options2) {
     const transport = this.ensureTransport();
     this.pendingRequests++;
     this.clearIdleTimer();
@@ -7270,12 +9402,12 @@ var SemanticIndexWorkerClient = class {
       return await transport.request(method, args);
     } finally {
       this.pendingRequests--;
-      if (options?.scheduleIdle !== false) this.scheduleIdleCloseIfNeeded();
+      if (options2?.scheduleIdle !== false) this.scheduleIdleCloseIfNeeded();
     }
   }
-  async callProbe(method, args, fallback, options) {
+  async callProbe(method, args, fallback, options2) {
     try {
-      return await this.call(method, args, options);
+      return await this.call(method, args, options2);
     } catch {
       await this.closeFailedProbeTransport();
       return fallback;
@@ -7345,25 +9477,25 @@ var SemanticIndexWorkerClient = class {
     }
   }
 };
-function createSemanticIndexWorkerClient(options) {
-  return new SemanticIndexWorkerClient(options);
+function createSemanticIndexWorkerClient(options2) {
+  return new SemanticIndexWorkerClient(options2);
 }
-function createSemanticIndexWorkerRuntimeClient(options) {
+function createSemanticIndexWorkerRuntimeClient(options2) {
   const configStore = new SemanticIndexConfigStore(
-    path18.join(options.pathProvider.getAiDataDir(), SEMANTIC_INDEX_CONFIG_FILE)
+    path23.join(options2.pathProvider.getAiDataDir(), SEMANTIC_INDEX_CONFIG_FILE)
   );
   return createSemanticIndexWorkerClient({
     configStore,
-    idleTimeoutMs: options.idleTimeoutMs,
-    resolveApiKey: options.resolveApiKey,
-    writeAuthProfile: options.writeAuthProfile,
+    idleTimeoutMs: options2.idleTimeoutMs,
+    resolveApiKey: options2.resolveApiKey,
+    writeAuthProfile: options2.writeAuthProfile,
     transportFactory: () => createSemanticIndexWorkerThreadTransport({
-      workerEntryUrl: options.workerEntryUrl,
+      workerEntryUrl: options2.workerEntryUrl,
       startup: {
-        paths: snapshotPathProvider(options.pathProvider),
-        runtime: options.runtime,
-        nativeBinding: options.nativeBinding,
-        sqliteVecLoadablePath: options.sqliteVecLoadablePath
+        paths: snapshotPathProvider(options2.pathProvider),
+        runtime: options2.runtime,
+        nativeBinding: options2.nativeBinding,
+        sqliteVecLoadablePath: options2.sqliteVecLoadablePath
       }
     })
   });
@@ -7405,6 +9537,13 @@ export {
   streamParseFileInfo,
   analyzeIncrementalImport,
   incrementalImport,
+  ArchiveImportError,
+  validateArchiveEntryName,
+  ZipArchiveReader,
+  GoogleChatTakeoutResolver,
+  ArchiveImportSourceManager,
+  initAppLogger,
+  appLogger,
   isExistingUserDataDir,
   isUserDataDirSafeToUse,
   isDirectoryEmptyOrMissing,
@@ -7419,6 +9558,7 @@ export {
   applyPendingNodeDataDirMigrationIfNeeded,
   NodePathProvider,
   getDefaultNodeUserDataDir,
+  getSystemLogsDir,
   createJiebaNlpProvider,
   getDbFileVersion,
   getOrComputeAnalysisCache,
@@ -7430,4 +9570,4 @@ export {
   createSemanticIndexWorkerRuntimeClient,
   semantic_index_exports
 };
-//# sourceMappingURL=chunk-DHRSLYUM.mjs.map
+//# sourceMappingURL=chunk-GPF34WXV.mjs.map