@yhong91/vibetime 0.1.26 → 0.1.27

package/bin/vibetime.mjs

@@ -157,11 +157,736 @@ var init_fs = __esm({
   }
 });
 
+// ../../node_modules/.pnpm/fzstd@0.1.1/node_modules/fzstd/esm/index.mjs
+var esm_exports = {};
+__export(esm_exports, {
+  Decompress: () => Decompress,
+  ZstdErrorCode: () => ZstdErrorCode,
+  decompress: () => decompress
+});
+function decompress(dat, buf) {
+  var bufs = [], nb = +!buf;
+  var bt = 0, ol = 0;
+  for (; dat.length; ) {
+    var st = rzfh(dat, nb || buf);
+    if (typeof st == "object") {
+      if (nb) {
+        buf = null;
+        if (st.w.length == st.u) {
+          bufs.push(buf = st.w);
+          ol += st.u;
+        }
+      } else {
+        bufs.push(buf);
+        st.e = 0;
+      }
+      for (; !st.l; ) {
+        var blk = rzb(dat, st, buf);
+        if (!blk)
+          err(5);
+        if (buf)
+          st.e = st.y;
+        else {
+          bufs.push(blk);
+          ol += blk.length;
+          cpw(st.w, 0, blk.length);
+          st.w.set(blk, st.w.length - blk.length);
+        }
+      }
+      bt = st.b + st.c * 4;
+    } else
+      bt = st;
+    dat = dat.subarray(bt);
+  }
+  return cct(bufs, ol);
+}
+var ab, u8, u16, i16, i32, slc, fill, cpw, ZstdErrorCode, ec, err, rb, b4, rzfh, msb, rfse, rhu, dllt, dmlt, doct, b2bl, llb, llbl, mlb, mlbl, dhu, dhu4, rzb, cct, Decompress;
+var init_esm = __esm({
+  "../../node_modules/.pnpm/fzstd@0.1.1/node_modules/fzstd/esm/index.mjs"() {
+    ab = ArrayBuffer;
+    u8 = Uint8Array;
+    u16 = Uint16Array;
+    i16 = Int16Array;
+    i32 = Int32Array;
+    slc = function(v, s, e) {
+      if (u8.prototype.slice)
+        return u8.prototype.slice.call(v, s, e);
+      if (s == null || s < 0)
+        s = 0;
+      if (e == null || e > v.length)
+        e = v.length;
+      var n = new u8(e - s);
+      n.set(v.subarray(s, e));
+      return n;
+    };
+    fill = function(v, n, s, e) {
+      if (u8.prototype.fill)
+        return u8.prototype.fill.call(v, n, s, e);
+      if (s == null || s < 0)
+        s = 0;
+      if (e == null || e > v.length)
+        e = v.length;
+      for (; s < e; ++s)
+        v[s] = n;
+      return v;
+    };
+    cpw = function(v, t, s, e) {
+      if (u8.prototype.copyWithin)
+        return u8.prototype.copyWithin.call(v, t, s, e);
+      if (s == null || s < 0)
+        s = 0;
+      if (e == null || e > v.length)
+        e = v.length;
+      while (s < e) {
+        v[t++] = v[s++];
+      }
+    };
+    ZstdErrorCode = {
+      InvalidData: 0,
+      WindowSizeTooLarge: 1,
+      InvalidBlockType: 2,
+      FSEAccuracyTooHigh: 3,
+      DistanceTooFarBack: 4,
+      UnexpectedEOF: 5
+    };
+    ec = [
+      "invalid zstd data",
+      "window size too large (>2046MB)",
+      "invalid block type",
+      "FSE accuracy too high",
+      "match distance too far back",
+      "unexpected EOF"
+    ];
+    err = function(ind, msg, nt) {
+      var e = new Error(msg || ec[ind]);
+      e.code = ind;
+      if (Error.captureStackTrace)
+        Error.captureStackTrace(e, err);
+      if (!nt)
+        throw e;
+      return e;
+    };
+    rb = function(d, b, n) {
+      var i = 0, o = 0;
+      for (; i < n; ++i)
+        o |= d[b++] << (i << 3);
+      return o;
+    };
+    b4 = function(d, b) {
+      return (d[b] | d[b + 1] << 8 | d[b + 2] << 16 | d[b + 3] << 24) >>> 0;
+    };
+    rzfh = function(dat, w) {
+      var n3 = dat[0] | dat[1] << 8 | dat[2] << 16;
+      if (n3 == 3126568 && dat[3] == 253) {
+        var flg = dat[4];
+        var ss = flg >> 5 & 1, cc = flg >> 2 & 1, df = flg & 3, fcf = flg >> 6;
+        if (flg & 8)
+          err(0);
+        var bt = 6 - ss;
+        var db = df == 3 ? 4 : df;
+        var di = rb(dat, bt, db);
+        bt += db;
+        var fsb = fcf ? 1 << fcf : ss;
+        var fss = rb(dat, bt, fsb) + (fcf == 1 && 256);
+        var ws = fss;
+        if (!ss) {
+          var wb = 1 << 10 + (dat[5] >> 3);
+          ws = wb + (wb >> 3) * (dat[5] & 7);
+        }
+        if (ws > 2145386496)
+          err(1);
+        var buf = new u8((w == 1 ? fss || ws : w ? 0 : ws) + 12);
+        buf[0] = 1, buf[4] = 4, buf[8] = 8;
+        return {
+          b: bt + fsb,
+          y: 0,
+          l: 0,
+          d: di,
+          w: w && w != 1 ? w : buf.subarray(12),
+          e: ws,
+          o: new i32(buf.buffer, 0, 3),
+          u: fss,
+          c: cc,
+          m: Math.min(131072, ws)
+        };
+      } else if ((n3 >> 4 | dat[3] << 20) == 25481893) {
+        return b4(dat, 4) + 8;
+      }
+      err(0);
+    };
+    msb = function(val) {
+      var bits = 0;
+      for (; 1 << bits <= val; ++bits)
+        ;
+      return bits - 1;
+    };
+    rfse = function(dat, bt, mal) {
+      var tpos = (bt << 3) + 4;
+      var al = (dat[bt] & 15) + 5;
+      if (al > mal)
+        err(3);
+      var sz = 1 << al;
+      var probs = sz, sym = -1, re = -1, i = -1, ht = sz;
+      var buf = new ab(512 + (sz << 2));
+      var freq = new i16(buf, 0, 256);
+      var dstate = new u16(buf, 0, 256);
+      var nstate = new u16(buf, 512, sz);
+      var bb1 = 512 + (sz << 1);
+      var syms = new u8(buf, bb1, sz);
+      var nbits = new u8(buf, bb1 + sz);
+      while (sym < 255 && probs > 0) {
+        var bits = msb(probs + 1);
+        var cbt = tpos >> 3;
+        var msk = (1 << bits + 1) - 1;
+        var val = (dat[cbt] | dat[cbt + 1] << 8 | dat[cbt + 2] << 16) >> (tpos & 7) & msk;
+        var msk1fb = (1 << bits) - 1;
+        var msv = msk - probs - 1;
+        var sval = val & msk1fb;
+        if (sval < msv)
+          tpos += bits, val = sval;
+        else {
+          tpos += bits + 1;
+          if (val > msk1fb)
+            val -= msv;
+        }
+        freq[++sym] = --val;
+        if (val == -1) {
+          probs += val;
+          syms[--ht] = sym;
+        } else
+          probs -= val;
+        if (!val) {
+          do {
+            var rbt = tpos >> 3;
+            re = (dat[rbt] | dat[rbt + 1] << 8) >> (tpos & 7) & 3;
+            tpos += 2;
+            sym += re;
+          } while (re == 3);
+        }
+      }
+      if (sym > 255 || probs)
+        err(0);
+      var sympos = 0;
+      var sstep = (sz >> 1) + (sz >> 3) + 3;
+      var smask = sz - 1;
+      for (var s = 0; s <= sym; ++s) {
+        var sf = freq[s];
+        if (sf < 1) {
+          dstate[s] = -sf;
+          continue;
+        }
+        for (i = 0; i < sf; ++i) {
+          syms[sympos] = s;
+          do {
+            sympos = sympos + sstep & smask;
+          } while (sympos >= ht);
+        }
+      }
+      if (sympos)
+        err(0);
+      for (i = 0; i < sz; ++i) {
+        var ns = dstate[syms[i]]++;
+        var nb = nbits[i] = al - msb(ns);
+        nstate[i] = (ns << nb) - sz;
+      }
+      return [tpos + 7 >> 3, {
+        b: al,
+        s: syms,
+        n: nbits,
+        t: nstate
+      }];
+    };
+    rhu = function(dat, bt) {
+      var i = 0, wc = -1;
+      var buf = new u8(292), hb = dat[bt];
+      var hw = buf.subarray(0, 256);
+      var rc = buf.subarray(256, 268);
+      var ri = new u16(buf.buffer, 268);
+      if (hb < 128) {
+        var _a = rfse(dat, bt + 1, 6), ebt = _a[0], fdt = _a[1];
+        bt += hb;
+        var epos = ebt << 3;
+        var lb = dat[bt];
+        if (!lb)
+          err(0);
+        var st1 = 0, st2 = 0, btr1 = fdt.b, btr2 = btr1;
+        var fpos = (++bt << 3) - 8 + msb(lb);
+        for (; ; ) {
+          fpos -= btr1;
+          if (fpos < epos)
+            break;
+          var cbt = fpos >> 3;
+          st1 += (dat[cbt] | dat[cbt + 1] << 8) >> (fpos & 7) & (1 << btr1) - 1;
+          hw[++wc] = fdt.s[st1];
+          fpos -= btr2;
+          if (fpos < epos)
+            break;
+          cbt = fpos >> 3;
+          st2 += (dat[cbt] | dat[cbt + 1] << 8) >> (fpos & 7) & (1 << btr2) - 1;
+          hw[++wc] = fdt.s[st2];
+          btr1 = fdt.n[st1];
+          st1 = fdt.t[st1];
+          btr2 = fdt.n[st2];
+          st2 = fdt.t[st2];
+        }
+        if (++wc > 255)
+          err(0);
+      } else {
+        wc = hb - 127;
+        for (; i < wc; i += 2) {
+          var byte = dat[++bt];
+          hw[i] = byte >> 4;
+          hw[i + 1] = byte & 15;
+        }
+        ++bt;
+      }
+      var wes = 0;
+      for (i = 0; i < wc; ++i) {
+        var wt = hw[i];
+        if (wt > 11)
+          err(0);
+        wes += wt && 1 << wt - 1;
+      }
+      var mb = msb(wes) + 1;
+      var ts = 1 << mb;
+      var rem = ts - wes;
+      if (rem & rem - 1)
+        err(0);
+      hw[wc++] = msb(rem) + 1;
+      for (i = 0; i < wc; ++i) {
+        var wt = hw[i];
+        ++rc[hw[i] = wt && mb + 1 - wt];
+      }
+      var hbuf = new u8(ts << 1);
+      var syms = hbuf.subarray(0, ts), nb = hbuf.subarray(ts);
+      ri[mb] = 0;
+      for (i = mb; i > 0; --i) {
+        var pv = ri[i];
+        fill(nb, i, pv, ri[i - 1] = pv + rc[i] * (1 << mb - i));
+      }
+      if (ri[0] != ts)
+        err(0);
+      for (i = 0; i < wc; ++i) {
+        var bits = hw[i];
+        if (bits) {
+          var code = ri[bits];
+          fill(syms, i, code, ri[bits] = code + (1 << mb - bits));
+        }
+      }
+      return [bt, {
+        n: nb,
+        b: mb,
+        s: syms
+      }];
+    };
+    dllt = rfse(/* @__PURE__ */ new u8([
+      81,
+      16,
+      99,
+      140,
+      49,
+      198,
+      24,
+      99,
+      12,
+      33,
+      196,
+      24,
+      99,
+      102,
+      102,
+      134,
+      70,
+      146,
+      4
+    ]), 0, 6)[1];
+    dmlt = rfse(/* @__PURE__ */ new u8([
+      33,
+      20,
+      196,
+      24,
+      99,
+      140,
+      33,
+      132,
+      16,
+      66,
+      8,
+      33,
+      132,
+      16,
+      66,
+      8,
+      33,
+      68,
+      68,
+      68,
+      68,
+      68,
+      68,
+      68,
+      68,
+      36,
+      9
+    ]), 0, 6)[1];
+    doct = rfse(/* @__PURE__ */ new u8([
+      32,
+      132,
+      16,
+      66,
+      102,
+      70,
+      68,
+      68,
+      68,
+      68,
+      36,
+      73,
+      2
+    ]), 0, 5)[1];
+    b2bl = function(b, s) {
+      var len = b.length, bl = new i32(len);
+      for (var i = 0; i < len; ++i) {
+        bl[i] = s;
+        s += 1 << b[i];
+      }
+      return bl;
+    };
+    llb = /* @__PURE__ */ new u8((/* @__PURE__ */ new i32([
+      0,
+      0,
+      0,
+      0,
+      16843009,
+      50528770,
+      134678020,
+      202050057,
+      269422093
+    ])).buffer, 0, 36);
+    llbl = /* @__PURE__ */ b2bl(llb, 0);
+    mlb = /* @__PURE__ */ new u8((/* @__PURE__ */ new i32([
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      16843009,
+      50528770,
+      117769220,
+      185207048,
+      252579084,
+      16
+    ])).buffer, 0, 53);
+    mlbl = /* @__PURE__ */ b2bl(mlb, 3);
+    dhu = function(dat, out, hu) {
+      var len = dat.length, ss = out.length, lb = dat[len - 1], msk = (1 << hu.b) - 1, eb = -hu.b;
+      if (!lb)
+        err(0);
+      var st = 0, btr = hu.b, pos = (len << 3) - 8 + msb(lb) - btr, i = -1;
+      for (; pos > eb && i < ss; ) {
+        var cbt = pos >> 3;
+        var val = (dat[cbt] | dat[cbt + 1] << 8 | dat[cbt + 2] << 16) >> (pos & 7);
+        st = (st << btr | val) & msk;
+        out[++i] = hu.s[st];
+        pos -= btr = hu.n[st];
+      }
+      if (pos != eb || i + 1 != ss)
+        err(0);
+    };
+    dhu4 = function(dat, out, hu) {
+      var bt = 6;
+      var ss = out.length, sz1 = ss + 3 >> 2, sz2 = sz1 << 1, sz3 = sz1 + sz2;
+      dhu(dat.subarray(bt, bt += dat[0] | dat[1] << 8), out.subarray(0, sz1), hu);
+      dhu(dat.subarray(bt, bt += dat[2] | dat[3] << 8), out.subarray(sz1, sz2), hu);
+      dhu(dat.subarray(bt, bt += dat[4] | dat[5] << 8), out.subarray(sz2, sz3), hu);
+      dhu(dat.subarray(bt), out.subarray(sz3), hu);
+    };
+    rzb = function(dat, st, out) {
+      var _a;
+      var bt = st.b;
+      var b0 = dat[bt], btype = b0 >> 1 & 3;
+      st.l = b0 & 1;
+      var sz = b0 >> 3 | dat[bt + 1] << 5 | dat[bt + 2] << 13;
+      var ebt = (bt += 3) + sz;
+      if (btype == 1) {
+        if (bt >= dat.length)
+          return;
+        st.b = bt + 1;
+        if (out) {
+          fill(out, dat[bt], st.y, st.y += sz);
+          return out;
+        }
+        return fill(new u8(sz), dat[bt]);
+      }
+      if (ebt > dat.length)
+        return;
+      if (btype == 0) {
+        st.b = ebt;
+        if (out) {
+          out.set(dat.subarray(bt, ebt), st.y);
+          st.y += sz;
+          return out;
+        }
+        return slc(dat, bt, ebt);
+      }
+      if (btype == 2) {
+        var b3 = dat[bt], lbt = b3 & 3, sf = b3 >> 2 & 3;
+        var lss = b3 >> 4, lcs = 0, s4 = 0;
+        if (lbt < 2) {
+          if (sf & 1)
+            lss |= dat[++bt] << 4 | (sf & 2 && dat[++bt] << 12);
+          else
+            lss = b3 >> 3;
+        } else {
+          s4 = sf;
+          if (sf < 2)
+            lss |= (dat[++bt] & 63) << 4, lcs = dat[bt] >> 6 | dat[++bt] << 2;
+          else if (sf == 2)
+            lss |= dat[++bt] << 4 | (dat[++bt] & 3) << 12, lcs = dat[bt] >> 2 | dat[++bt] << 6;
+          else
+            lss |= dat[++bt] << 4 | (dat[++bt] & 63) << 12, lcs = dat[bt] >> 6 | dat[++bt] << 2 | dat[++bt] << 10;
+        }
+        ++bt;
+        var buf = out ? out.subarray(st.y, st.y + st.m) : new u8(st.m);
+        var spl = buf.length - lss;
+        if (lbt == 0)
+          buf.set(dat.subarray(bt, bt += lss), spl);
+        else if (lbt == 1)
+          fill(buf, dat[bt++], spl);
+        else {
+          var hu = st.h;
+          if (lbt == 2) {
+            var hud = rhu(dat, bt);
+            lcs += bt - (bt = hud[0]);
+            st.h = hu = hud[1];
+          } else if (!hu)
+            err(0);
+          (s4 ? dhu4 : dhu)(dat.subarray(bt, bt += lcs), buf.subarray(spl), hu);
+        }
+        var ns = dat[bt++];
+        if (ns) {
+          if (ns == 255)
+            ns = (dat[bt++] | dat[bt++] << 8) + 32512;
+          else if (ns > 127)
+            ns = ns - 128 << 8 | dat[bt++];
+          var scm = dat[bt++];
+          if (scm & 3)
+            err(0);
+          var dts = [dmlt, doct, dllt];
+          for (var i = 2; i > -1; --i) {
+            var md = scm >> (i << 1) + 2 & 3;
+            if (md == 1) {
+              var rbuf = new u8([0, 0, dat[bt++]]);
+              dts[i] = {
+                s: rbuf.subarray(2, 3),
+                n: rbuf.subarray(0, 1),
+                t: new u16(rbuf.buffer, 0, 1),
+                b: 0
+              };
+            } else if (md == 2) {
+              _a = rfse(dat, bt, 9 - (i & 1)), bt = _a[0], dts[i] = _a[1];
+            } else if (md == 3) {
+              if (!st.t)
+                err(0);
+              dts[i] = st.t[i];
+            }
+          }
+          var _b = st.t = dts, mlt = _b[0], oct = _b[1], llt = _b[2];
+          var lb = dat[ebt - 1];
+          if (!lb)
+            err(0);
+          var spos = (ebt << 3) - 8 + msb(lb) - llt.b, cbt = spos >> 3, oubt = 0;
+          var lst = (dat[cbt] | dat[cbt + 1] << 8) >> (spos & 7) & (1 << llt.b) - 1;
+          cbt = (spos -= oct.b) >> 3;
+          var ost = (dat[cbt] | dat[cbt + 1] << 8) >> (spos & 7) & (1 << oct.b) - 1;
+          cbt = (spos -= mlt.b) >> 3;
+          var mst = (dat[cbt] | dat[cbt + 1] << 8) >> (spos & 7) & (1 << mlt.b) - 1;
+          for (++ns; --ns; ) {
+            var llc = llt.s[lst];
+            var lbtr = llt.n[lst];
+            var mlc = mlt.s[mst];
+            var mbtr = mlt.n[mst];
+            var ofc = oct.s[ost];
+            var obtr = oct.n[ost];
+            cbt = (spos -= ofc) >> 3;
+            var ofp = 1 << ofc;
+            var off = ofp + ((dat[cbt] | dat[cbt + 1] << 8 | dat[cbt + 2] << 16 | dat[cbt + 3] << 24) >>> (spos & 7) & ofp - 1);
+            cbt = (spos -= mlb[mlc]) >> 3;
+            var ml = mlbl[mlc] + ((dat[cbt] | dat[cbt + 1] << 8 | dat[cbt + 2] << 16) >> (spos & 7) & (1 << mlb[mlc]) - 1);
+            cbt = (spos -= llb[llc]) >> 3;
+            var ll = llbl[llc] + ((dat[cbt] | dat[cbt + 1] << 8 | dat[cbt + 2] << 16) >> (spos & 7) & (1 << llb[llc]) - 1);
+            cbt = (spos -= lbtr) >> 3;
+            lst = llt.t[lst] + ((dat[cbt] | dat[cbt + 1] << 8) >> (spos & 7) & (1 << lbtr) - 1);
+            cbt = (spos -= mbtr) >> 3;
+            mst = mlt.t[mst] + ((dat[cbt] | dat[cbt + 1] << 8) >> (spos & 7) & (1 << mbtr) - 1);
+            cbt = (spos -= obtr) >> 3;
+            ost = oct.t[ost] + ((dat[cbt] | dat[cbt + 1] << 8) >> (spos & 7) & (1 << obtr) - 1);
+            if (off > 3) {
+              st.o[2] = st.o[1];
+              st.o[1] = st.o[0];
+              st.o[0] = off -= 3;
+            } else {
+              var idx = off - (ll != 0);
+              if (idx) {
+                off = idx == 3 ? st.o[0] - 1 : st.o[idx];
+                if (idx > 1)
+                  st.o[2] = st.o[1];
+                st.o[1] = st.o[0];
+                st.o[0] = off;
+              } else
+                off = st.o[0];
+            }
+            for (var i = 0; i < ll; ++i) {
+              buf[oubt + i] = buf[spl + i];
+            }
+            oubt += ll, spl += ll;
+            var stin = oubt - off;
+            if (stin < 0) {
+              var len = -stin;
+              var bs = st.e + stin;
+              if (len > ml)
+                len = ml;
+              for (var i = 0; i < len; ++i) {
+                buf[oubt + i] = st.w[bs + i];
+              }
+              oubt += len, ml -= len, stin = 0;
+            }
+            for (var i = 0; i < ml; ++i) {
+              buf[oubt + i] = buf[stin + i];
+            }
+            oubt += ml;
+          }
+          if (oubt != spl) {
+            while (spl < buf.length) {
+              buf[oubt++] = buf[spl++];
+            }
+          } else
+            oubt = buf.length;
+          if (out)
+            st.y += oubt;
+          else
+            buf = slc(buf, 0, oubt);
+        } else if (out) {
+          st.y += lss;
+          if (spl) {
+            for (var i = 0; i < lss; ++i) {
+              buf[i] = buf[spl + i];
+            }
+          }
+        } else if (spl)
+          buf = slc(buf, spl);
+        st.b = ebt;
+        return buf;
+      }
+      err(2);
+    };
+    cct = function(bufs, ol) {
+      if (bufs.length == 1)
+        return bufs[0];
+      var buf = new u8(ol);
+      for (var i = 0, b = 0; i < bufs.length; ++i) {
+        var chk = bufs[i];
+        buf.set(chk, b);
+        b += chk.length;
+      }
+      return buf;
+    };
+    Decompress = /* @__PURE__ */ (function() {
+      function Decompress2(ondata) {
+        this.ondata = ondata;
+        this.c = [];
+        this.l = 0;
+        this.z = 0;
+      }
+      Decompress2.prototype.push = function(chunk, final) {
+        if (typeof this.s == "number") {
+          var sub = Math.min(chunk.length, this.s);
+          chunk = chunk.subarray(sub);
+          this.s -= sub;
+        }
+        var sl = chunk.length;
+        var ncs = sl + this.l;
+        if (!this.s) {
+          if (final) {
+            if (!ncs) {
+              this.ondata(new u8(0), true);
+              return;
+            }
+            if (ncs < 5)
+              err(5);
+          } else if (ncs < 18) {
+            this.c.push(chunk);
+            this.l = ncs;
+            return;
+          }
+          if (this.l) {
+            this.c.push(chunk);
+            chunk = cct(this.c, ncs);
+            this.c = [];
+            this.l = 0;
+          }
+          if (typeof (this.s = rzfh(chunk)) == "number")
+            return this.push(chunk, final);
+        }
+        if (typeof this.s != "number") {
+          if (ncs < (this.z || 3)) {
+            if (final)
+              err(5);
+            this.c.push(chunk);
+            this.l = ncs;
+            return;
+          }
+          if (this.l) {
+            this.c.push(chunk);
+            chunk = cct(this.c, ncs);
+            this.c = [];
+            this.l = 0;
+          }
+          if (!this.z && ncs < (this.z = chunk[this.s.b] & 2 ? 4 : 3 + (chunk[this.s.b] >> 3 | chunk[this.s.b + 1] << 5 | chunk[this.s.b + 2] << 13))) {
+            if (final)
+              err(5);
+            this.c.push(chunk);
+            this.l = ncs;
+            return;
+          } else
+            this.z = 0;
+          for (; ; ) {
+            var blk = rzb(chunk, this.s);
+            if (!blk) {
+              if (final)
+                err(5);
+              var adc = chunk.subarray(this.s.b);
+              this.s.b = 0;
+              this.c.push(adc), this.l += adc.length;
+              return;
+            } else {
+              this.ondata(blk, false);
+              cpw(this.s.w, 0, blk.length);
+              this.s.w.set(blk, this.s.w.length - blk.length);
+            }
+            if (this.s.l) {
+              var rest = chunk.subarray(this.s.b);
+              this.s = this.s.c * 4;
+              this.push(rest, final);
+              return;
+            }
+          }
+        } else if (final)
+          err(5);
+      };
+      return Decompress2;
+    })();
+  }
+});
+
 // src/cli.ts
 import { spawn as spawn2, spawnSync } from "node:child_process";
 import { mkdir as mkdir5, open, rm, stat as stat13, writeFile as writeFile4 } from "node:fs/promises";
-import os9 from "node:os";
-import path22 from "node:path";
+import os10 from "node:os";
+import path23 from "node:path";
 import { fileURLToPath } from "node:url";
 
 // ../shared/src/index.ts
@@ -199,7 +924,7 @@ var TELEMETRY_EVENT_TYPES = [
   "agent.operation"
 ];
 var FILE_ACTIVITY_OPERATIONS = ["read", "search", "create", "write", "edit", "delete"];
-var BACKFILL_SOURCE_IDS = ["codex", "claude-code", "claude-cowork", "copilot", "opencode", "pi", "agy", "codebuddy", "qoder", "qoder-cn", "workbuddy", "zcode", "grok-build"];
+var BACKFILL_SOURCE_IDS = ["codex", "claude-code", "claude-cowork", "copilot", "opencode", "pi", "agy", "codebuddy", "qoder", "qoder-cn", "workbuddy", "zcode", "grok-build", "zed"];
 function createWorkspaceId(input) {
   const basis = input.repoUrl || input.repoRoot || input.projectName || "unknown";
   return `workspace_${fnv1a(basis)}`;
@@ -1203,7 +1928,7 @@ function countTextLines(text) {
 }
 
 // src/lib/constants.ts
-var PACKAGE_VERSION = true ? "0.1.26" : "0.1.1";
+var PACKAGE_VERSION = true ? "0.1.27" : "0.1.1";
 var DEFAULT_API_URL = "http://121.196.224.82:3001";
 var DEFAULT_BACKFILL_BATCH_SIZE = 50;
 var DEFAULT_BACKFILL_BATCH_BYTES = 800 * 1024;
@@ -1228,6 +1953,12 @@ function objectField(object, key) {
   }
   return object[key];
 }
+function arrayField(object, key) {
+  if (!isPlainObject(object) || !Array.isArray(object[key])) {
+    return [];
+  }
+  return object[key];
+}
 function isPlainObject(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
 }
@@ -2907,7 +3638,7 @@ function fileActivitiesFromClaudeToolUse(tool, input, ts, cwd) {
     const metrics = fileMetricsFromClaudeToolInput(tool, input);
     addResolvedPathActivity(changes, filePath, operation, ts, cwd, workdir, metrics);
   }
-  for (const edit of arrayField(input, "edits")) {
+  for (const edit of arrayField2(input, "edits")) {
     if (!isPlainObject(edit)) {
       continue;
     }
@@ -2951,17 +3682,17 @@ function fileMetricsFromClaudeToolInput(tool, input) {
   }
   return {};
 }
-function arrayField(object, key) {
+function arrayField2(object, key) {
   if (!isPlainObject(object) || !Array.isArray(object[key])) {
     return [];
   }
   return object[key];
 }
 function claudeToolUseItems(message) {
-  return arrayField(message, "content").filter((item) => isPlainObject(item) && item.type === "tool_use");
+  return arrayField2(message, "content").filter((item) => isPlainObject(item) && item.type === "tool_use");
 }
 function claudeToolResultItems(message) {
-  return arrayField(message, "content").filter((item) => isPlainObject(item) && item.type === "tool_result");
+  return arrayField2(message, "content").filter((item) => isPlainObject(item) && item.type === "tool_result");
 }
 function isClaudeToolResultMessage(message) {
   return claudeToolResultItems(message).length > 0;
@@ -4617,7 +5348,7 @@ function fileActivitiesFromFunctionCall(payload, payloadType, ts, cwd) {
   for (const key of ["file_path", "path", "notebook_path"]) {
     addResolvedPathActivity(changes, stringField(args, key), operation, ts, cwd, workdir);
   }
-  for (const file of arrayField2(args, "files")) {
+  for (const file of arrayField3(args, "files")) {
     if (typeof file === "string") {
       addResolvedPathActivity(changes, file, operation, ts, cwd, workdir);
     }
@@ -4630,7 +5361,7 @@ function fileActivitiesFromFunctionCall(payload, payloadType, ts, cwd) {
   }
   return [...changes.values()];
 }
-function arrayField2(object, key) {
+function arrayField3(object, key) {
   if (!isPlainObject(object) || !Array.isArray(object[key])) {
     return [];
   }
@@ -6972,7 +7703,7 @@ function fileActivitiesFromQoderCnToolUse(tool, input, ts, cwd) {
     const metrics = fileMetricsFromQoderCnToolInput(tool, input);
     addResolvedPathActivity(changes, filePath, operation, ts, cwd, workdir, metrics);
   }
-  for (const edit of arrayField3(input, "edits")) {
+  for (const edit of arrayField4(input, "edits")) {
     if (!isPlainObject(edit)) {
       continue;
     }
@@ -7016,17 +7747,17 @@ function fileMetricsFromQoderCnToolInput(tool, input) {
   }
   return {};
 }
-function arrayField3(object, key) {
+function arrayField4(object, key) {
   if (!isPlainObject(object) || !Array.isArray(object[key])) {
     return [];
   }
   return object[key];
 }
 function qoderCnToolUseItems(message) {
-  return arrayField3(message, "content").filter((item) => isPlainObject(item) && item.type === "tool_use");
+  return arrayField4(message, "content").filter((item) => isPlainObject(item) && item.type === "tool_use");
 }
 function qoderCnToolResultItems(message) {
-  return arrayField3(message, "content").filter((item) => isPlainObject(item) && item.type === "tool_result");
+  return arrayField4(message, "content").filter((item) => isPlainObject(item) && item.type === "tool_result");
 }
 function isQoderCnToolResultMessage(message) {
   return qoderCnToolResultItems(message).length > 0;
@@ -7715,7 +8446,7 @@ function fileActivitiesFromQoderToolUse(tool, input, ts, cwd) {
     const metrics = fileMetricsFromQoderToolInput(tool, input);
     addResolvedPathActivity(changes, filePath, operation, ts, cwd, workdir, metrics);
   }
-  for (const edit of arrayField4(input, "edits")) {
+  for (const edit of arrayField5(input, "edits")) {
     if (!isPlainObject(edit)) {
       continue;
     }
@@ -7759,17 +8490,17 @@ function fileMetricsFromQoderToolInput(tool, input) {
   }
   return {};
 }
-function arrayField4(object, key) {
+function arrayField5(object, key) {
   if (!isPlainObject(object) || !Array.isArray(object[key])) {
     return [];
   }
   return object[key];
 }
 function qoderToolUseItems(message) {
-  return arrayField4(message, "content").filter((item) => isPlainObject(item) && item.type === "tool_use");
+  return arrayField5(message, "content").filter((item) => isPlainObject(item) && item.type === "tool_use");
 }
 function qoderToolResultItems(message) {
-  return arrayField4(message, "content").filter((item) => isPlainObject(item) && item.type === "tool_result");
+  return arrayField5(message, "content").filter((item) => isPlainObject(item) && item.type === "tool_result");
 }
 function isQoderToolResultMessage(message) {
   return qoderToolResultItems(message).length > 0;
@@ -8842,6 +9573,404 @@ function createZCodeAdapter() {
   };
 }
 
+// src/adapters/zed.ts
+import os9 from "node:os";
+import path20 from "node:path";
+function zedThreadsCandidates(home, env) {
+  const candidates = [];
+  const platform2 = process.platform;
+  if (platform2 === "darwin") {
+    candidates.push(path20.join(home, "Library", "Application Support", "Zed", "threads", "threads.db"));
+  } else if (platform2 === "win32") {
+    const appdata = env?.APPDATA;
+    if (appdata && appdata.trim()) {
+      candidates.push(path20.join(path20.resolve(appdata), "Zed", "threads", "threads.db"));
+    }
+    candidates.push(path20.join(home, "AppData", "Roaming", "Zed", "threads", "threads.db"));
+  } else {
+    const xdgData = env?.XDG_DATA_HOME;
+    if (xdgData && xdgData.trim()) {
+      candidates.push(path20.join(path20.resolve(xdgData), "zed", "threads", "threads.db"));
+    }
+    candidates.push(path20.join(home, ".local", "share", "zed", "threads", "threads.db"));
+    const xdgConfig = env?.XDG_CONFIG_HOME;
+    if (xdgConfig && xdgConfig.trim()) {
+      candidates.push(path20.join(path20.resolve(xdgConfig), "zed", "threads", "threads.db"));
+    }
+    candidates.push(path20.join(home, ".config", "zed", "threads", "threads.db"));
+  }
+  return candidates;
+}
+function zedConfigDir(home, env) {
+  const platform2 = process.platform;
+  if (platform2 === "darwin") {
+    return path20.join(home, "Library", "Application Support", "Zed");
+  }
+  if (platform2 === "win32") {
+    const appdata = env?.APPDATA;
+    if (appdata && appdata.trim()) {
+      return path20.join(path20.resolve(appdata), "Zed");
+    }
+    return path20.join(home, "AppData", "Roaming", "Zed");
+  }
+  const xdgConfig = env?.XDG_CONFIG_HOME;
+  if (xdgConfig && xdgConfig.trim()) {
+    return path20.join(path20.resolve(xdgConfig), "zed");
+  }
+  return path20.join(home, ".config", "zed");
+}
+function baseZedEvent(event) {
+  return {
+    schemaVersion: AGENT_TIME_SCHEMA_VERSION,
+    source: "zed",
+    agent: "zed",
+    workspaceId: createWorkspaceId({ projectName: event.project, repoRoot: event.cwd }),
+    ...event
+  };
+}
+function zedUsageFromRequest(entry) {
+  const input = Math.max(0, numberField(entry, "input_tokens") || 0);
+  const output = Math.max(0, numberField(entry, "output_tokens") || 0);
+  if (input <= 0 && output <= 0) {
+    return void 0;
+  }
+  return {
+    tokensInput: input || void 0,
+    tokensOutput: output || void 0,
+    tokensTotal: input + output
+  };
+}
+function filePathFromToolInput(tool, input) {
+  if (!isPlainObject(input)) {
+    return void 0;
+  }
+  const direct = stringField(input, "path") || stringField(input, "file_path") || stringField(input, "filePath");
+  if (direct) {
+    return direct;
+  }
+  if (tool === "save_file") {
+    const paths = arrayField(input, "paths");
+    if (paths && paths.length > 0) {
+      const first = paths[0];
+      if (typeof first === "string") {
+        return first;
+      }
+    }
+  }
+  return void 0;
+}
+async function parseZedSessionFile(dbPath, options) {
+  const { DatabaseSync } = await import("node:sqlite");
+  const fzstd = await Promise.resolve().then(() => (init_esm(), esm_exports));
+  const decompress2 = fzstd.decompress;
+  if (!dbPath.endsWith(".db")) {
+    return [];
+  }
+  const db = new DatabaseSync(dbPath, { readOnly: true });
+  const events = [];
+  try {
+    const rows = db.prepare(
+      "SELECT id, data, data_type, updated_at, created_at, summary, folder_paths FROM threads ORDER BY updated_at"
+    ).all();
+    for (const row of rows) {
+      const sessionId = row.id;
+      const threadTs = row.updated_at;
+      if (!threadTs) {
+        continue;
+      }
+      const folderRaw = row.folder_paths || "";
+      const folder = folderRaw.split(/[\n,]/).map((s) => s.trim()).find(Boolean);
+      const cwd = folder || void 0;
+      const project = cwd ? path20.basename(cwd) : row.summary ? row.summary.slice(0, 40) : void 0;
+      let json;
+      try {
+        const bytes = row.data_type === "zstd" ? decompress2(new Uint8Array(row.data)) : new Uint8Array(row.data);
+        json = JSON.parse(new TextDecoder().decode(bytes));
+      } catch {
+        continue;
+      }
+      if (!isPlainObject(json)) {
+        continue;
+      }
+      const modelObj = objectField(json, "model");
+      const model = modelObj ? stringField(modelObj, "model") : void 0;
+      const provider = modelObj ? stringField(modelObj, "provider") : void 0;
+      const requestUsage = objectField(json, "request_token_usage");
+      const messages = arrayField(json, "messages") || [];
+      events.push(baseZedEvent({
+        ts: row.created_at || threadTs,
+        type: "session.started",
+        sessionId,
+        cwd,
+        project,
+        model,
+        provider,
+        operation: "session start",
+        confidence: "partial"
+      }));
+      let currentTurnId;
+      let turnStarted = false;
+      let msgIndex = 0;
+      for (const msg of messages) {
+        msgIndex++;
+        if (!isPlainObject(msg)) {
+          continue;
+        }
+        const userPayload = objectField(msg, "User");
+        const agentPayload = objectField(msg, "Agent");
+        if (userPayload) {
+          if (turnStarted && currentTurnId) {
+            events.push(baseZedEvent({
+              ts: threadTs,
+              type: "turn.completed",
+              sessionId,
+              turnId: currentTurnId,
+              cwd,
+              project,
+              model,
+              provider,
+              operation: "turn completed",
+              confidence: "partial"
+            }));
+          }
+          const requestId = stringField(userPayload, "id") || `${sessionId}:${msgIndex}`;
+          currentTurnId = `turn_${createStableHash([sessionId, requestId]).slice(0, 24)}`;
+          turnStarted = true;
+          events.push(baseZedEvent({
+            ts: threadTs,
+            type: "turn.started",
+            sessionId,
+            turnId: currentTurnId,
+            cwd,
+            project,
+            model,
+            provider,
+            operation: "turn start",
+            confidence: "partial"
+          }));
+          const content = arrayField(userPayload, "content") || [];
+          let promptText = "";
+          for (const part of content) {
+            if (!isPlainObject(part)) {
+              continue;
+            }
+            const text = stringField(part, "Text");
+            if (text) {
+              promptText += text;
+            }
+          }
+          if (promptText) {
+            events.push(baseZedEvent({
+              ts: threadTs,
+              type: "prompt.submitted",
+              sessionId,
+              turnId: currentTurnId,
+              cwd,
+              project,
+              model,
+              provider,
+              operation: "prompt submitted",
+              confidence: "partial",
+              metrics: { prompts: 1, promptChars: promptText.length },
+              refs: stringRefs({ promptHash: `sha256:${createStableHash(promptText)}` })
+            }));
+          }
+          const usageEntry = requestUsage ? objectField(requestUsage, requestId) : void 0;
+          if (usageEntry) {
+            const usage = zedUsageFromRequest(usageEntry);
+            if (usage) {
+              const metrics = {
+                tokensInput: usage.tokensInput,
+                tokensOutput: usage.tokensOutput,
+                tokensTotal: usage.tokensTotal
+              };
+              events.push(baseZedEvent({
+                ts: threadTs,
+                type: "model.usage",
+                sessionId,
+                turnId: currentTurnId,
+                cwd,
+                project,
+                model,
+                provider,
+                operation: "model usage",
+                confidence: "partial",
+                metrics
+              }));
+            }
+          }
+        }
+        if (agentPayload) {
+          const content = arrayField(agentPayload, "content") || [];
+          for (const part of content) {
+            if (!isPlainObject(part)) {
+              continue;
+            }
+            const toolUse = objectField(part, "ToolUse");
+            if (!toolUse) {
+              continue;
+            }
+            const tool = stringField(toolUse, "name") || "unknown";
+            const callId = stringField(toolUse, "id") || `call_${createStableHash([sessionId, currentTurnId || "", tool, msgIndex]).slice(0, 16)}`;
+            const input = objectField(toolUse, "input");
+            events.push(baseZedEvent({
+              ts: threadTs,
+              type: "tool.started",
+              sessionId,
+              turnId: currentTurnId,
+              cwd,
+              project,
+              model,
+              provider,
+              tool,
+              operation: `${tool} started`,
+              metrics: { toolCalls: 1 },
+              refs: stringRefs({ sourceId: callId }),
+              confidence: "exact"
+            }));
+            const toolResults = objectField(agentPayload, "tool_results");
+            const resultEntry = toolResults ? objectField(toolResults, callId) : void 0;
+            const isError = resultEntry ? Boolean(numberField(resultEntry, "is_error")) : false;
+            const success = !isError;
+            events.push(baseZedEvent({
+              ts: threadTs,
+              type: success ? "tool.completed" : "tool.failed",
+              sessionId,
+              turnId: currentTurnId,
+              cwd,
+              project,
+              model,
+              provider,
+              tool,
+              success,
+              operation: success ? `${tool} completed` : `${tool} failed`,
+              refs: stringRefs({ sourceId: callId }),
+              confidence: "exact"
+            }));
+            if (tool === "terminal") {
+              const command = input ? stringField(input, "command") : void 0;
+              events.push(baseZedEvent({
+                ts: threadTs,
+                type: success ? "command.completed" : "command.failed",
+                sessionId,
+                turnId: currentTurnId,
+                cwd,
+                project,
+                model,
+                provider,
+                tool: "terminal",
+                success,
+                operation: success ? "command completed" : "command failed",
+                metrics: { commandCalls: 1 },
+                refs: stringRefs({
+                  sourceId: callId,
+                  commandHash: command ? `sha256:${createStableHash(String(command))}` : void 0
+                }),
+                confidence: "partial"
+              }));
+            }
+            const filePath = filePathFromToolInput(tool, input);
+            if (filePath) {
+              events.push(baseZedEvent({
+                ts: threadTs,
+                type: toolFileActivityType(tool),
+                sessionId,
+                turnId: currentTurnId,
+                cwd,
+                project,
+                model,
+                provider,
+                tool,
+                success,
+                operation: `${tool} file activity`,
+                fileActivities: [{
+                  ts: threadTs,
+                  path: filePath,
+                  operation: operationForTool(tool)
+                }],
+                refs: stringRefs({ sourceId: callId }),
+                confidence: "partial"
+              }));
+            }
+          }
+        }
+      }
+      if (turnStarted && currentTurnId) {
+        events.push(baseZedEvent({
+          ts: threadTs,
+          type: "turn.completed",
+          sessionId,
+          turnId: currentTurnId,
+          cwd,
+          project,
+          model,
+          provider,
+          operation: "turn completed",
+          confidence: "partial"
+        }));
+      }
+      events.push(baseZedEvent({
+        ts: threadTs,
+        type: "session.ended",
+        sessionId,
+        cwd,
+        project,
+        model,
+        provider,
+        operation: "session end",
+        confidence: "partial"
+      }));
+    }
+  } finally {
+    db.close();
+  }
+  return events.filter((event) => matchesBackfillFilters(event, options));
+}
+async function zedBackfillFiles(sourceRoot, home = os9.homedir(), env) {
+  const { stat: stat14 } = await import("node:fs/promises");
+  if (sourceRoot) {
+    if (!sourceRoot.endsWith(".db")) {
+      return [];
+    }
+    const info = await stat14(sourceRoot).catch(() => null);
+    if (!info) {
+      return [];
+    }
+    return [{ path: sourceRoot, modifiedAt: info.mtime.toISOString() }];
+  }
+  for (const candidatePath of zedThreadsCandidates(home, env)) {
+    const info = await stat14(candidatePath).catch(() => null);
+    if (info) {
+      return [{ path: candidatePath, modifiedAt: info.mtime.toISOString() }];
+    }
+  }
+  return [];
+}
+function createZedAdapter() {
+  return {
+    id: "zed",
+    label: "Zed",
+    agentName: "zed",
+    kind: "ide",
+    detectPath(home, env) {
+      return zedConfigDir(home, env);
+    },
+    installedPath(home, env) {
+      return path20.join(zedConfigDir(home, env), "vibetime-marker");
+    },
+    async isInstalled() {
+      return false;
+    },
+    installEntries(_home, _env) {
+      return [];
+    },
+    sourcePaths(home, env) {
+      return zedThreadsCandidates(home, env);
+    },
+    parseSessionFile: parseZedSessionFile
+  };
+}
+
 // src/lib/pricing.ts
 function estimateEventCostUsd(event) {
   if (event.type !== "model.usage") {
@@ -9286,15 +10415,15 @@ function hookCommandFromGroup(group) {
 import { randomUUID } from "node:crypto";
 import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { homedir, hostname } from "node:os";
-import path20 from "node:path";
+import path21 from "node:path";
 function configDir(home = homedir()) {
-  return path20.join(home, ".vibetime");
+  return path21.join(home, ".vibetime");
 }
 function configPath(home = homedir()) {
-  return path20.join(configDir(home), "config.json");
+  return path21.join(configDir(home), "config.json");
 }
 function machineIdPath(home = homedir()) {
-  return path20.join(configDir(home), "machine-id");
+  return path21.join(configDir(home), "machine-id");
 }
 function readConfig(home = homedir()) {
   const file = configPath(home);
@@ -9343,13 +10472,13 @@ init_fs();
 // src/lib/logger.ts
 import { appendFile, mkdir as mkdir4, rename, stat as stat12 } from "node:fs/promises";
 import { homedir as homedir2 } from "node:os";
-import path21 from "node:path";
+import path22 from "node:path";
 var MAX_BYTES = 1 * 1024 * 1024;
 function logDir(home = homedir2()) {
-  return path21.join(home, ".vibetime", "logs");
+  return path22.join(home, ".vibetime", "logs");
 }
 function logPath(home = homedir2(), name = "cli.log") {
-  return path21.join(logDir(home), name);
+  return path22.join(logDir(home), name);
 }
 function serializeError(error) {
   if (error instanceof Error) {
@@ -9524,8 +10653,8 @@ function buildHeaders(token, machine) {
     ...machine?.platform ? { "x-machine-platform": machine.platform } : {}
   };
 }
-function joinUrl(base, path23) {
-  return new URL(path23, base.endsWith("/") ? base : `${base}/`).toString();
+function joinUrl(base, path24) {
+  return new URL(path24, base.endsWith("/") ? base : `${base}/`).toString();
 }
 async function postRollupBatch(remote, rollups, options = {}) {
   const response = await remote.fetchImpl(joinUrl(remote.baseUrl, "/v3/agent/ingest"), {
@@ -9608,6 +10737,7 @@ function createRegistry() {
   registry.register(createWorkbuddyAdapter());
   registry.register(createZCodeAdapter());
   registry.register(createGrokBuildAdapter());
+  registry.register(createZedAdapter());
   return registry;
 }
 var defaultContext = {
@@ -10123,6 +11253,9 @@ async function listBackfillSourceFiles(source, options, ctx) {
   if (source.id === "grok-build") {
     return grokBackfillFiles(stringOption(options["source-root"]), resolveHome3(options, ctx), ctx.env);
   }
+  if (source.id === "zed") {
+    return zedBackfillFiles(stringOption(options["source-root"]), resolveHome3(options, ctx), ctx.env);
+  }
   const roots = stringOption(options["source-root"]) ? [requiredOption(options, "source-root")] : source.paths;
   const fileLists = await Promise.all(roots.map((r) => listJsonlFiles(r)));
   const files = fileLists.flat().sort().slice(0, numberOption(options.limit) || void 0);
@@ -10440,13 +11573,13 @@ function selectBackfillFilesForImport(files, watermarkTs) {
   });
 }
 function backfillIncrementalStatePath(home) {
-  return path22.join(home, ".vibetime", "backfill-state.json");
+  return path23.join(home, ".vibetime", "backfill-state.json");
 }
 function syncLocalTriggerStatePath(home) {
-  return path22.join(home, ".vibetime", "sync-local-trigger.json");
+  return path23.join(home, ".vibetime", "sync-local-trigger.json");
 }
 function syncLocalTriggerLockPath(home) {
-  return path22.join(home, ".vibetime", "sync-local-trigger.lock");
+  return path23.join(home, ".vibetime", "sync-local-trigger.lock");
 }
 function backfillRemoteKey(baseUrl) {
   try {
@@ -10508,7 +11641,7 @@ async function readBackfillIncrementalStateFile(home, ctx) {
 }
 async function writeBackfillIncrementalStateFile(home, file) {
   const statePath = backfillIncrementalStatePath(home);
-  await mkdir5(path22.dirname(statePath), { recursive: true });
+  await mkdir5(path23.dirname(statePath), { recursive: true });
   await writeFile4(statePath, `${JSON.stringify(file, null, 2)}
 `, "utf8");
 }
@@ -10557,7 +11690,7 @@ async function readSyncLocalTriggerState(statePath) {
   return nextState;
 }
 async function writeSyncLocalTriggerState(statePath, state) {
-  await mkdir5(path22.dirname(statePath), { recursive: true });
+  await mkdir5(path23.dirname(statePath), { recursive: true });
   await writeFile4(statePath, `${JSON.stringify(state, null, 2)}
 `, "utf8");
 }
@@ -10572,12 +11705,12 @@ async function readSyncLocalLock(lockPath) {
   return { pid: lock.pid, startedAt: lock.startedAt };
 }
 async function writeSyncLocalLock(lockPath, lock) {
-  await mkdir5(path22.dirname(lockPath), { recursive: true });
+  await mkdir5(path23.dirname(lockPath), { recursive: true });
   await writeFile4(lockPath, `${JSON.stringify(lock, null, 2)}
 `, "utf8");
 }
 async function acquireSyncLocalLock(lockPath, lock) {
-  await mkdir5(path22.dirname(lockPath), { recursive: true });
+  await mkdir5(path23.dirname(lockPath), { recursive: true });
   try {
     const handle = await open(lockPath, "wx");
     try {
@@ -10657,10 +11790,10 @@ function syncLocalRunnerEntryArgs(cliPath) {
   if (cliPath.endsWith(".ts")) {
     return ["--import", "tsx", cliPath];
   }
-  return [path22.resolve(path22.dirname(cliPath), "../bin/vibetime.mjs")];
+  return [path23.resolve(path23.dirname(cliPath), "../bin/vibetime.mjs")];
 }
 function resolveHome3(options, ctx) {
-  return path22.resolve(stringOption(options.home) || ctx.env.HOME || os9.homedir());
+  return path23.resolve(stringOption(options.home) || ctx.env.HOME || os10.homedir());
 }
 function requestedTargets(options) {
   const value = options.target || options.targets;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@yhong91/vibetime",
   "type": "module",
-  "version": "0.1.26",
+  "version": "0.1.27",
   "description": "vibetime CLI — install AI-agent hooks (Claude Code, Codex, OpenCode, Pi) and report activity to vibetime.",
   "license": "MIT",
   "publishConfig": {
@@ -35,6 +35,7 @@
   "devDependencies": {
     "cac": "^7.0.0",
     "esbuild": "^0.28.0",
+    "fzstd": "^0.1.1",
     "@codetime/shared": "0.4.0"
   },
   "scripts": {