@primitivedotdev/map 0.0.0-stage → 0.2.0

package/dist/map.mjs

@@ -0,0 +1,3889 @@
+#!/usr/bin/env node
+
+// ../core/src/brand.ts
+var LEGACY_TAG = /^(\s*)\[gud /i;
+function canonicalSubject(subject) {
+  return subject.replace(LEGACY_TAG, "$1[map ");
+}
+
+// ../core/src/subjects.ts
+var WITH_ID = /* @__PURE__ */ new Set([
+  "commit",
+  "received",
+  "review",
+  "verdict",
+  "landed",
+  "conflict",
+  "objected",
+  "rejected",
+  "help",
+  "handle",
+  "repo",
+  "vetoed",
+  "owner",
+  "too-late",
+  "snapshot",
+  "check",
+  "check-failed",
+  "confirm",
+  "confirmed",
+  "created",
+  "event",
+  "tick",
+  "pending",
+  "stuck",
+  "consent",
+  "escalated"
+]);
+var NO_ID = /* @__PURE__ */ new Set(["config", "not-allowed", "settings", "log", "diff", "status", "create-failed"]);
+var WITH_FIELDS = /* @__PURE__ */ new Set(["commit", "review", "handle", "repo", "check", "tick", "pending", "consent"]);
+var SUBJECT = /^\[(?:map|gud) ([a-z][a-z-]*)(?: ([^\s\]]+))?(?: ([^\s\]]+))?\](?: (.*))?$/;
+function parseSubject(subject) {
+  const m = SUBJECT.exec(subject.trim());
+  if (!m) return null;
+  const kind = m[1];
+  const id = m[2];
+  const extra = m[3];
+  const rest = (m[4] ?? "").trim();
+  if (NO_ID.has(kind)) {
+    if (id !== void 0) return null;
+    return { kind, fields: {}, rest };
+  }
+  if (!WITH_ID.has(kind) || id === void 0) return null;
+  const out = { kind, id, fields: {}, rest };
+  if (kind === "verdict") {
+    if (extra !== "approve" && extra !== "object") return null;
+    out.verdict = extra;
+  } else if (kind === "owner") {
+    if (extra !== "veto" && extra !== "approve") return null;
+    out.action = extra;
+  } else if (kind === "event" || kind === "tick") {
+    if (extra === void 0) return null;
+    out.ref = extra;
+  } else if (extra !== void 0) {
+    return null;
+  }
+  if (WITH_FIELDS.has(kind)) {
+    for (const tok of rest.split(/\s+/)) {
+      if (!tok) continue;
+      const eq = tok.indexOf("=");
+      if (eq <= 0) return null;
+      out.fields[tok.slice(0, eq)] = tok.slice(eq + 1);
+    }
+  }
+  return out;
+}
+
+// ../../node_modules/.pnpm/fflate@0.8.3/node_modules/fflate/esm/index.mjs
+import { createRequire } from "module";
+var require2 = createRequire("/");
+var _a;
+var Worker;
+var isMarkedAsUntransferable;
+try {
+  _a = require2("worker_threads"), Worker = _a.Worker, isMarkedAsUntransferable = _a.isMarkedAsUntransferable;
+} catch (e) {
+}
+var u8 = Uint8Array;
+var u16 = Uint16Array;
+var i32 = Int32Array;
+var fleb = new u8([
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  1,
+  1,
+  1,
+  1,
+  2,
+  2,
+  2,
+  2,
+  3,
+  3,
+  3,
+  3,
+  4,
+  4,
+  4,
+  4,
+  5,
+  5,
+  5,
+  5,
+  0,
+  /* unused */
+  0,
+  0,
+  /* impossible */
+  0
+]);
+var fdeb = new u8([
+  0,
+  0,
+  0,
+  0,
+  1,
+  1,
+  2,
+  2,
+  3,
+  3,
+  4,
+  4,
+  5,
+  5,
+  6,
+  6,
+  7,
+  7,
+  8,
+  8,
+  9,
+  9,
+  10,
+  10,
+  11,
+  11,
+  12,
+  12,
+  13,
+  13,
+  /* unused */
+  0,
+  0
+]);
+var clim = new u8([16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15]);
+var freb = function(eb, start) {
+  var b = new u16(31);
+  for (var i = 0; i < 31; ++i) {
+    b[i] = start += 1 << eb[i - 1];
+  }
+  var r = new i32(b[30]);
+  for (var i = 1; i < 30; ++i) {
+    for (var j = b[i]; j < b[i + 1]; ++j) {
+      r[j] = j - b[i] << 5 | i;
+    }
+  }
+  return { b, r };
+};
+var _a = freb(fleb, 2);
+var fl = _a.b;
+var revfl = _a.r;
+fl[28] = 258, revfl[258] = 28;
+var _b = freb(fdeb, 0);
+var fd = _b.b;
+var revfd = _b.r;
+var rev = new u16(32768);
+for (i = 0; i < 32768; ++i) {
+  x = (i & 43690) >> 1 | (i & 21845) << 1;
+  x = (x & 52428) >> 2 | (x & 13107) << 2;
+  x = (x & 61680) >> 4 | (x & 3855) << 4;
+  rev[i] = ((x & 65280) >> 8 | (x & 255) << 8) >> 1;
+}
+var x;
+var i;
+var hMap = (function(cd, mb, r) {
+  var s = cd.length;
+  var i = 0;
+  var l = new u16(mb);
+  for (; i < s; ++i) {
+    if (cd[i])
+      ++l[cd[i] - 1];
+  }
+  var le = new u16(mb);
+  for (i = 1; i < mb; ++i) {
+    le[i] = le[i - 1] + l[i - 1] << 1;
+  }
+  var co;
+  if (r) {
+    co = new u16(1 << mb);
+    var rvb = 15 - mb;
+    for (i = 0; i < s; ++i) {
+      if (cd[i]) {
+        var sv = i << 4 | cd[i];
+        var r_1 = mb - cd[i];
+        var v = le[cd[i] - 1]++ << r_1;
+        for (var m = v | (1 << r_1) - 1; v <= m; ++v) {
+          co[rev[v] >> rvb] = sv;
+        }
+      }
+    }
+  } else {
+    co = new u16(s);
+    for (i = 0; i < s; ++i) {
+      if (cd[i]) {
+        co[i] = rev[le[cd[i] - 1]++] >> 15 - cd[i];
+      }
+    }
+  }
+  return co;
+});
+var flt = new u8(288);
+for (i = 0; i < 144; ++i)
+  flt[i] = 8;
+var i;
+for (i = 144; i < 256; ++i)
+  flt[i] = 9;
+var i;
+for (i = 256; i < 280; ++i)
+  flt[i] = 7;
+var i;
+for (i = 280; i < 288; ++i)
+  flt[i] = 8;
+var i;
+var fdt = new u8(32);
+for (i = 0; i < 32; ++i)
+  fdt[i] = 5;
+var i;
+var flm = /* @__PURE__ */ hMap(flt, 9, 0);
+var flrm = /* @__PURE__ */ hMap(flt, 9, 1);
+var fdm = /* @__PURE__ */ hMap(fdt, 5, 0);
+var fdrm = /* @__PURE__ */ hMap(fdt, 5, 1);
+var max = function(a) {
+  var m = a[0];
+  for (var i = 1; i < a.length; ++i) {
+    if (a[i] > m)
+      m = a[i];
+  }
+  return m;
+};
+var bits = function(d, p, m) {
+  var o = p / 8 | 0;
+  return (d[o] | d[o + 1] << 8) >> (p & 7) & m;
+};
+var bits16 = function(d, p) {
+  var o = p / 8 | 0;
+  return (d[o] | d[o + 1] << 8 | d[o + 2] << 16) >> (p & 7);
+};
+var shft = function(p) {
+  return (p + 7) / 8 | 0;
+};
+var slc = function(v, s, e) {
+  if (s == null || s < 0)
+    s = 0;
+  if (e == null || e > v.length)
+    e = v.length;
+  return new u8(v.subarray(s, e));
+};
+var ec = [
+  "unexpected EOF",
+  "invalid block type",
+  "invalid length/literal",
+  "invalid distance",
+  "stream finished",
+  "no stream handler",
+  ,
+  // determined by compression function
+  "no callback",
+  "invalid UTF-8 data",
+  "extra field too long",
+  "date not in range 1980-2099",
+  "filename too long",
+  "stream finishing",
+  "invalid zip data"
+  // determined by unknown compression method
+];
+var 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;
+};
+var inflt = function(dat, st, buf, dict) {
+  var sl = dat.length, dl = dict ? dict.length : 0;
+  if (!sl || st.f && !st.l)
+    return buf || new u8(0);
+  var noBuf = !buf;
+  var resize = noBuf || st.i != 2;
+  var noSt = st.i;
+  if (noBuf)
+    buf = new u8(sl * 3);
+  var cbuf = function(l2) {
+    var bl = buf.length;
+    if (l2 > bl) {
+      var nbuf = new u8(Math.max(bl * 2, l2));
+      nbuf.set(buf);
+      buf = nbuf;
+    }
+  };
+  var final = st.f || 0, pos = st.p || 0, bt = st.b || 0, lm = st.l, dm = st.d, lbt = st.m, dbt = st.n;
+  var tbts = sl * 8;
+  do {
+    if (!lm) {
+      final = bits(dat, pos, 1);
+      var type = bits(dat, pos + 1, 3);
+      pos += 3;
+      if (!type) {
+        var s = shft(pos) + 4, l = dat[s - 4] | dat[s - 3] << 8, t = s + l;
+        if (t > sl) {
+          if (noSt)
+            err(0);
+          break;
+        }
+        if (resize)
+          cbuf(bt + l);
+        buf.set(dat.subarray(s, t), bt);
+        st.b = bt += l, st.p = pos = t * 8, st.f = final;
+        continue;
+      } else if (type == 1)
+        lm = flrm, dm = fdrm, lbt = 9, dbt = 5;
+      else if (type == 2) {
+        var hLit = bits(dat, pos, 31) + 257, hcLen = bits(dat, pos + 10, 15) + 4;
+        var tl = hLit + bits(dat, pos + 5, 31) + 1;
+        pos += 14;
+        var ldt = new u8(tl);
+        var clt = new u8(19);
+        for (var i = 0; i < hcLen; ++i) {
+          clt[clim[i]] = bits(dat, pos + i * 3, 7);
+        }
+        pos += hcLen * 3;
+        var clb = max(clt), clbmsk = (1 << clb) - 1;
+        var clm = hMap(clt, clb, 1);
+        for (var i = 0; i < tl; ) {
+          var r = clm[bits(dat, pos, clbmsk)];
+          pos += r & 15;
+          var s = r >> 4;
+          if (s < 16) {
+            ldt[i++] = s;
+          } else {
+            var c = 0, n = 0;
+            if (s == 16)
+              n = 3 + bits(dat, pos, 3), pos += 2, c = ldt[i - 1];
+            else if (s == 17)
+              n = 3 + bits(dat, pos, 7), pos += 3;
+            else if (s == 18)
+              n = 11 + bits(dat, pos, 127), pos += 7;
+            while (n--)
+              ldt[i++] = c;
+          }
+        }
+        var lt = ldt.subarray(0, hLit), dt = ldt.subarray(hLit);
+        lbt = max(lt);
+        dbt = max(dt);
+        lm = hMap(lt, lbt, 1);
+        dm = hMap(dt, dbt, 1);
+      } else
+        err(1);
+      if (pos > tbts) {
+        if (noSt)
+          err(0);
+        break;
+      }
+    }
+    if (resize)
+      cbuf(bt + 131072);
+    var lms = (1 << lbt) - 1, dms = (1 << dbt) - 1;
+    var lpos = pos;
+    for (; ; lpos = pos) {
+      var c = lm[bits16(dat, pos) & lms], sym = c >> 4;
+      pos += c & 15;
+      if (pos > tbts) {
+        if (noSt)
+          err(0);
+        break;
+      }
+      if (!c)
+        err(2);
+      if (sym < 256)
+        buf[bt++] = sym;
+      else if (sym == 256) {
+        lpos = pos, lm = null;
+        break;
+      } else {
+        var add = sym - 254;
+        if (sym > 264) {
+          var i = sym - 257, b = fleb[i];
+          add = bits(dat, pos, (1 << b) - 1) + fl[i];
+          pos += b;
+        }
+        var d = dm[bits16(dat, pos) & dms], dsym = d >> 4;
+        if (!d)
+          err(3);
+        pos += d & 15;
+        var dt = fd[dsym];
+        if (dsym > 3) {
+          var b = fdeb[dsym];
+          dt += bits16(dat, pos) & (1 << b) - 1, pos += b;
+        }
+        if (pos > tbts) {
+          if (noSt)
+            err(0);
+          break;
+        }
+        if (resize)
+          cbuf(bt + 131072);
+        var end = bt + add;
+        if (bt < dt) {
+          var shift = dl - dt, dend = Math.min(dt, end);
+          if (shift + bt < 0)
+            err(3);
+          for (; bt < dend; ++bt)
+            buf[bt] = dict[shift + bt];
+        }
+        for (; bt < end; ++bt)
+          buf[bt] = buf[bt - dt];
+      }
+    }
+    st.l = lm, st.p = lpos, st.b = bt, st.f = final;
+    if (lm)
+      final = 1, st.m = lbt, st.d = dm, st.n = dbt;
+  } while (!final);
+  return bt != buf.length && noBuf ? slc(buf, 0, bt) : buf.subarray(0, bt);
+};
+var wbits = function(d, p, v) {
+  v <<= p & 7;
+  var o = p / 8 | 0;
+  d[o] |= v;
+  d[o + 1] |= v >> 8;
+};
+var wbits16 = function(d, p, v) {
+  v <<= p & 7;
+  var o = p / 8 | 0;
+  d[o] |= v;
+  d[o + 1] |= v >> 8;
+  d[o + 2] |= v >> 16;
+};
+var hTree = function(d, mb) {
+  var t = [];
+  for (var i = 0; i < d.length; ++i) {
+    if (d[i])
+      t.push({ s: i, f: d[i] });
+  }
+  var s = t.length;
+  var t2 = t.slice();
+  if (!s)
+    return { t: et, l: 0 };
+  if (s == 1) {
+    var v = new u8(t[0].s + 1);
+    v[t[0].s] = 1;
+    return { t: v, l: 1 };
+  }
+  t.sort(function(a, b) {
+    return a.f - b.f;
+  });
+  t.push({ s: -1, f: 25001 });
+  var l = t[0], r = t[1], i0 = 0, i1 = 1, i2 = 2;
+  t[0] = { s: -1, f: l.f + r.f, l, r };
+  while (i1 != s - 1) {
+    l = t[t[i0].f < t[i2].f ? i0++ : i2++];
+    r = t[i0 != i1 && t[i0].f < t[i2].f ? i0++ : i2++];
+    t[i1++] = { s: -1, f: l.f + r.f, l, r };
+  }
+  var maxSym = t2[0].s;
+  for (var i = 1; i < s; ++i) {
+    if (t2[i].s > maxSym)
+      maxSym = t2[i].s;
+  }
+  var tr = new u16(maxSym + 1);
+  var mbt = ln(t[i1 - 1], tr, 0);
+  if (mbt > mb) {
+    var i = 0, dt = 0;
+    var lft = mbt - mb, cst = 1 << lft;
+    t2.sort(function(a, b) {
+      return tr[b.s] - tr[a.s] || a.f - b.f;
+    });
+    for (; i < s; ++i) {
+      var i2_1 = t2[i].s;
+      if (tr[i2_1] > mb) {
+        dt += cst - (1 << mbt - tr[i2_1]);
+        tr[i2_1] = mb;
+      } else
+        break;
+    }
+    dt >>= lft;
+    while (dt > 0) {
+      var i2_2 = t2[i].s;
+      if (tr[i2_2] < mb)
+        dt -= 1 << mb - tr[i2_2]++ - 1;
+      else
+        ++i;
+    }
+    for (; i >= 0 && dt; --i) {
+      var i2_3 = t2[i].s;
+      if (tr[i2_3] == mb) {
+        --tr[i2_3];
+        ++dt;
+      }
+    }
+    mbt = mb;
+  }
+  return { t: new u8(tr), l: mbt };
+};
+var ln = function(n, l, d) {
+  return n.s == -1 ? Math.max(ln(n.l, l, d + 1), ln(n.r, l, d + 1)) : l[n.s] = d;
+};
+var lc = function(c) {
+  var s = c.length;
+  while (s && !c[--s])
+    ;
+  var cl = new u16(++s);
+  var cli2 = 0, cln = c[0], cls = 1;
+  var w = function(v) {
+    cl[cli2++] = v;
+  };
+  for (var i = 1; i <= s; ++i) {
+    if (c[i] == cln && i != s)
+      ++cls;
+    else {
+      if (!cln && cls > 2) {
+        for (; cls > 138; cls -= 138)
+          w(32754);
+        if (cls > 2) {
+          w(cls > 10 ? cls - 11 << 5 | 28690 : cls - 3 << 5 | 12305);
+          cls = 0;
+        }
+      } else if (cls > 3) {
+        w(cln), --cls;
+        for (; cls > 6; cls -= 6)
+          w(8304);
+        if (cls > 2)
+          w(cls - 3 << 5 | 8208), cls = 0;
+      }
+      while (cls--)
+        w(cln);
+      cls = 1;
+      cln = c[i];
+    }
+  }
+  return { c: cl.subarray(0, cli2), n: s };
+};
+var clen = function(cf, cl) {
+  var l = 0;
+  for (var i = 0; i < cl.length; ++i)
+    l += cf[i] * cl[i];
+  return l;
+};
+var wfblk = function(out, pos, dat) {
+  var s = dat.length;
+  var o = shft(pos + 2);
+  out[o] = s & 255;
+  out[o + 1] = s >> 8;
+  out[o + 2] = out[o] ^ 255;
+  out[o + 3] = out[o + 1] ^ 255;
+  for (var i = 0; i < s; ++i)
+    out[o + i + 4] = dat[i];
+  return (o + 4 + s) * 8;
+};
+var wblk = function(dat, out, final, syms, lf, df, eb, li, bs, bl, p) {
+  wbits(out, p++, final);
+  ++lf[256];
+  var _a2 = hTree(lf, 15), dlt = _a2.t, mlb = _a2.l;
+  var _b2 = hTree(df, 15), ddt = _b2.t, mdb = _b2.l;
+  var _c = lc(dlt), lclt = _c.c, nlc = _c.n;
+  var _d = lc(ddt), lcdt = _d.c, ndc = _d.n;
+  var lcfreq = new u16(19);
+  for (var i = 0; i < lclt.length; ++i)
+    ++lcfreq[lclt[i] & 31];
+  for (var i = 0; i < lcdt.length; ++i)
+    ++lcfreq[lcdt[i] & 31];
+  var _e = hTree(lcfreq, 7), lct = _e.t, mlcb = _e.l;
+  var nlcc = 19;
+  for (; nlcc > 4 && !lct[clim[nlcc - 1]]; --nlcc)
+    ;
+  var flen = bl + 5 << 3;
+  var ftlen = clen(lf, flt) + clen(df, fdt) + eb;
+  var dtlen = clen(lf, dlt) + clen(df, ddt) + eb + 14 + 3 * nlcc + clen(lcfreq, lct) + 2 * lcfreq[16] + 3 * lcfreq[17] + 7 * lcfreq[18];
+  if (bs >= 0 && flen <= ftlen && flen <= dtlen)
+    return wfblk(out, p, dat.subarray(bs, bs + bl));
+  var lm, ll, dm, dl;
+  wbits(out, p, 1 + (dtlen < ftlen)), p += 2;
+  if (dtlen < ftlen) {
+    lm = hMap(dlt, mlb, 0), ll = dlt, dm = hMap(ddt, mdb, 0), dl = ddt;
+    var llm = hMap(lct, mlcb, 0);
+    wbits(out, p, nlc - 257);
+    wbits(out, p + 5, ndc - 1);
+    wbits(out, p + 10, nlcc - 4);
+    p += 14;
+    for (var i = 0; i < nlcc; ++i)
+      wbits(out, p + 3 * i, lct[clim[i]]);
+    p += 3 * nlcc;
+    var lcts = [lclt, lcdt];
+    for (var it = 0; it < 2; ++it) {
+      var clct = lcts[it];
+      for (var i = 0; i < clct.length; ++i) {
+        var len = clct[i] & 31;
+        wbits(out, p, llm[len]), p += lct[len];
+        if (len > 15)
+          wbits(out, p, clct[i] >> 5 & 127), p += clct[i] >> 12;
+      }
+    }
+  } else {
+    lm = flm, ll = flt, dm = fdm, dl = fdt;
+  }
+  for (var i = 0; i < li; ++i) {
+    var sym = syms[i];
+    if (sym > 255) {
+      var len = sym >> 18 & 31;
+      wbits16(out, p, lm[len + 257]), p += ll[len + 257];
+      if (len > 7)
+        wbits(out, p, sym >> 23 & 31), p += fleb[len];
+      var dst = sym & 31;
+      wbits16(out, p, dm[dst]), p += dl[dst];
+      if (dst > 3)
+        wbits16(out, p, sym >> 5 & 8191), p += fdeb[dst];
+    } else {
+      wbits16(out, p, lm[sym]), p += ll[sym];
+    }
+  }
+  wbits16(out, p, lm[256]);
+  return p + ll[256];
+};
+var deo = /* @__PURE__ */ new i32([65540, 131080, 131088, 131104, 262176, 1048704, 1048832, 2114560, 2117632]);
+var et = /* @__PURE__ */ new u8(0);
+var dflt = function(dat, lvl, plvl, pre, post, st) {
+  var s = st.z || dat.length;
+  var o = new u8(pre + s + 5 * (1 + Math.ceil(s / 7e3)) + post);
+  var w = o.subarray(pre, o.length - post);
+  var lst = st.l;
+  var pos = (st.r || 0) & 7;
+  if (lvl) {
+    if (pos)
+      w[0] = st.r >> 3;
+    var opt = deo[lvl - 1];
+    var n = opt >> 13, c = opt & 8191;
+    var msk_1 = (1 << plvl) - 1;
+    var prev = st.p || new u16(32768), head = st.h || new u16(msk_1 + 1);
+    var bs1_1 = Math.ceil(plvl / 3), bs2_1 = 2 * bs1_1;
+    var hsh = function(i2) {
+      return (dat[i2] ^ dat[i2 + 1] << bs1_1 ^ dat[i2 + 2] << bs2_1) & msk_1;
+    };
+    var syms = new i32(25e3);
+    var lf = new u16(288), df = new u16(32);
+    var lc_1 = 0, eb = 0, i = st.i || 0, li = 0, wi = st.w || 0, bs = 0;
+    for (; i + 2 < s; ++i) {
+      var hv = hsh(i);
+      var imod = i & 32767, pimod = head[hv];
+      prev[imod] = pimod;
+      head[hv] = imod;
+      if (wi <= i) {
+        var rem = s - i;
+        if ((lc_1 > 7e3 || li > 24576) && (rem > 423 || !lst)) {
+          pos = wblk(dat, w, 0, syms, lf, df, eb, li, bs, i - bs, pos);
+          li = lc_1 = eb = 0, bs = i;
+          for (var j = 0; j < 286; ++j)
+            lf[j] = 0;
+          for (var j = 0; j < 30; ++j)
+            df[j] = 0;
+        }
+        var l = 2, d = 0, ch_1 = c, dif = imod - pimod & 32767;
+        if (rem > 2 && hv == hsh(i - dif)) {
+          var maxn = Math.min(n, rem) - 1;
+          var maxd = Math.min(32767, i);
+          var ml = Math.min(258, rem);
+          while (dif <= maxd && --ch_1 && imod != pimod) {
+            if (dat[i + l] == dat[i + l - dif]) {
+              var nl2 = 0;
+              for (; nl2 < ml && dat[i + nl2] == dat[i + nl2 - dif]; ++nl2)
+                ;
+              if (nl2 > l) {
+                l = nl2, d = dif;
+                if (nl2 > maxn)
+                  break;
+                var mmd = Math.min(dif, nl2 - 2);
+                var md = 0;
+                for (var j = 0; j < mmd; ++j) {
+                  var ti = i - dif + j & 32767;
+                  var pti = prev[ti];
+                  var cd = ti - pti & 32767;
+                  if (cd > md)
+                    md = cd, pimod = ti;
+                }
+              }
+            }
+            imod = pimod, pimod = prev[imod];
+            dif += imod - pimod & 32767;
+          }
+        }
+        if (d) {
+          syms[li++] = 268435456 | revfl[l] << 18 | revfd[d];
+          var lin = revfl[l] & 31, din = revfd[d] & 31;
+          eb += fleb[lin] + fdeb[din];
+          ++lf[257 + lin];
+          ++df[din];
+          wi = i + l;
+          ++lc_1;
+        } else {
+          syms[li++] = dat[i];
+          ++lf[dat[i]];
+        }
+      }
+    }
+    for (i = Math.max(i, wi); i < s; ++i) {
+      syms[li++] = dat[i];
+      ++lf[dat[i]];
+    }
+    pos = wblk(dat, w, lst, syms, lf, df, eb, li, bs, i - bs, pos);
+    if (!lst) {
+      st.r = pos & 7 | w[pos / 8 | 0] << 3;
+      pos -= 7;
+      st.h = head, st.p = prev, st.i = i, st.w = wi;
+    }
+  } else {
+    for (var i = st.w || 0; i < s + lst; i += 65535) {
+      var e = i + 65535;
+      if (e >= s) {
+        w[pos / 8 | 0] = lst;
+        e = s;
+      }
+      pos = wfblk(w, pos + 1, dat.subarray(i, e));
+    }
+    st.i = s;
+  }
+  return slc(o, 0, pre + shft(pos) + post);
+};
+var crct = /* @__PURE__ */ (function() {
+  var t = new Int32Array(256);
+  for (var i = 0; i < 256; ++i) {
+    var c = i, k = 9;
+    while (--k)
+      c = (c & 1 && -306674912) ^ c >>> 1;
+    t[i] = c;
+  }
+  return t;
+})();
+var crc = function() {
+  var c = -1;
+  return {
+    p: function(d) {
+      var cr = c;
+      for (var i = 0; i < d.length; ++i)
+        cr = crct[cr & 255 ^ d[i]] ^ cr >>> 8;
+      c = cr;
+    },
+    d: function() {
+      return ~c;
+    }
+  };
+};
+var dopt = function(dat, opt, pre, post, st) {
+  if (!st) {
+    st = { l: 1 };
+    if (opt.dictionary) {
+      var dict = opt.dictionary.subarray(-32768);
+      var newDat = new u8(dict.length + dat.length);
+      newDat.set(dict);
+      newDat.set(dat, dict.length);
+      dat = newDat;
+      st.w = dict.length;
+    }
+  }
+  return dflt(dat, opt.level == null ? 6 : opt.level, opt.mem == null ? st.l ? Math.ceil(Math.max(8, Math.min(13, Math.log(dat.length))) * 1.5) : 20 : 12 + opt.mem, pre, post, st);
+};
+var wbytes = function(d, b, v) {
+  for (; v; ++b)
+    d[b] = v, v >>>= 8;
+};
+var gzh = function(c, o) {
+  var fn = o.filename;
+  c[0] = 31, c[1] = 139, c[2] = 8, c[8] = o.level < 2 ? 4 : o.level == 9 ? 2 : 0, c[9] = 3;
+  if (o.mtime != 0)
+    wbytes(c, 4, Math.floor(new Date(o.mtime || Date.now()) / 1e3));
+  if (fn) {
+    c[3] = 8;
+    for (var i = 0; i <= fn.length; ++i)
+      c[i + 10] = fn.charCodeAt(i);
+  }
+};
+var gzs = function(d) {
+  if (d[0] != 31 || d[1] != 139 || d[2] != 8)
+    err(6, "invalid gzip data");
+  var flg = d[3];
+  var st = 10;
+  if (flg & 4)
+    st += (d[10] | d[11] << 8) + 2;
+  for (var zs = (flg >> 3 & 1) + (flg >> 4 & 1); zs > 0; zs -= !d[st++])
+    ;
+  return st + (flg & 2);
+};
+var gzhl = function(o) {
+  return 10 + (o.filename ? o.filename.length + 1 : 0);
+};
+var Inflate = /* @__PURE__ */ (function() {
+  function Inflate2(opts, cb) {
+    if (typeof opts == "function")
+      cb = opts, opts = {};
+    this.ondata = cb;
+    var dict = opts && opts.dictionary && opts.dictionary.subarray(-32768);
+    this.s = { i: 0, b: dict ? dict.length : 0 };
+    this.o = new u8(32768);
+    this.p = new u8(0);
+    if (dict)
+      this.o.set(dict);
+  }
+  Inflate2.prototype.e = function(c) {
+    if (!this.ondata)
+      err(5);
+    if (this.d)
+      err(4);
+    if (!this.p.length)
+      this.p = c;
+    else if (c.length) {
+      var n = new u8(this.p.length + c.length);
+      n.set(this.p), n.set(c, this.p.length), this.p = n;
+    }
+  };
+  Inflate2.prototype.c = function(final) {
+    this.s.i = +(this.d = final || false);
+    var bts = this.s.b;
+    var dt = inflt(this.p, this.s, this.o);
+    this.ondata(slc(dt, bts, this.s.b), this.d);
+    this.o = slc(dt, this.s.b - 32768), this.s.b = this.o.length;
+    this.p = slc(this.p, this.s.p / 8 | 0), this.s.p &= 7;
+  };
+  Inflate2.prototype.push = function(chunk, final) {
+    this.e(chunk), this.c(final);
+  };
+  return Inflate2;
+})();
+function gzipSync(data, opts) {
+  if (!opts)
+    opts = {};
+  var c = crc(), l = data.length;
+  c.p(data);
+  var d = dopt(data, opts, gzhl(opts), 8), s = d.length;
+  return gzh(d, opts), wbytes(d, s - 8, c.d()), wbytes(d, s - 4, l), d;
+}
+var Gunzip = /* @__PURE__ */ (function() {
+  function Gunzip2(opts, cb) {
+    this.v = 1;
+    this.r = 0;
+    Inflate.call(this, opts, cb);
+  }
+  Gunzip2.prototype.push = function(chunk, final) {
+    Inflate.prototype.e.call(this, chunk);
+    this.r += chunk.length;
+    if (this.v) {
+      var p = this.p.subarray(this.v - 1);
+      var s = p.length > 3 ? gzs(p) : 4;
+      if (s > p.length) {
+        if (!final)
+          return;
+      } else if (this.v > 1 && this.onmember) {
+        this.onmember(this.r - p.length);
+      }
+      this.p = p.subarray(s), this.v = 0;
+    }
+    Inflate.prototype.c.call(this, 0);
+    if (this.s.f && !this.s.l) {
+      this.v = shft(this.s.p) + 9;
+      this.s = { i: 0 };
+      this.o = new u8(0);
+      this.push(new u8(0), final);
+    } else if (final) {
+      Inflate.prototype.c.call(this, final);
+    }
+  };
+  return Gunzip2;
+})();
+var td = typeof TextDecoder != "undefined" && /* @__PURE__ */ new TextDecoder();
+var tds = 0;
+try {
+  td.decode(et, { stream: true });
+  tds = 1;
+} catch (e) {
+}
+
+// ../core/src/util.ts
+var enc = new TextEncoder();
+var dec = new TextDecoder();
+var strictDec = new TextDecoder("utf-8", { fatal: true });
+function utf8(s) {
+  return enc.encode(s);
+}
+function fromUtf8(b) {
+  return dec.decode(b);
+}
+function asText(b) {
+  if (b.includes(0)) return null;
+  try {
+    return strictDec.decode(b);
+  } catch {
+    return null;
+  }
+}
+function bytesEqual(a, b) {
+  if (a.length !== b.length) return false;
+  for (let i = 0; i < a.length; i++) if (a[i] !== b[i]) return false;
+  return true;
+}
+function compareBytes(a, b) {
+  const n = Math.min(a.length, b.length);
+  for (let i = 0; i < n; i++) {
+    const d = a[i] - b[i];
+    if (d !== 0) return d;
+  }
+  return a.length - b.length;
+}
+function sortPaths(paths) {
+  return [...paths].map((p) => ({ p, b: utf8(p) })).sort((x, y) => compareBytes(x.b, y.b)).map((x) => x.p);
+}
+function concat(parts) {
+  let n = 0;
+  for (const p of parts) n += p.length;
+  const out = new Uint8Array(n);
+  let o = 0;
+  for (const p of parts) {
+    out.set(p, o);
+    o += p.length;
+  }
+  return out;
+}
+
+// ../core/src/patch.ts
+var PATCH_LIMITS = {
+  maxBytes: 5 * 1024 * 1024,
+  maxFiles: 500,
+  maxPathBytes: 400,
+  maxComponents: 30,
+  fuzz: 3,
+  context: 3
+};
+var DEVNULL = "/dev/null";
+function foldKey(p) {
+  return p.normalize("NFC").toLowerCase();
+}
+var B85 = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz!#$%&()*+-;<=>?@^_`{|}~";
+var B85_VALUE = new Map([...B85].map((c, i) => [c, i]));
+function tokens(s) {
+  const out = s.split(/(?<=\n)/);
+  if (out[out.length - 1] === "") out.pop();
+  return out;
+}
+var MAX_EDIT_DISTANCE = 2e3;
+function myers(a, b) {
+  const n = a.length;
+  const m = b.length;
+  const max2 = n + m;
+  const off = max2 + 1;
+  const v = new Int32Array(2 * max2 + 3);
+  const snaps = [];
+  for (let d = 0; d <= Math.min(max2, MAX_EDIT_DISTANCE); d++) {
+    for (let k = -d; k <= d; k += 2) {
+      let x = k === -d || k !== d && v[off + k - 1] < v[off + k + 1] ? v[off + k + 1] : v[off + k - 1] + 1;
+      let y = x - k;
+      while (x < n && y < m && a[x] === b[y]) {
+        x++;
+        y++;
+      }
+      v[off + k] = x;
+    }
+    snaps.push(v.slice(off - d, off + d + 1));
+    const kEnd = n - m;
+    if (Math.abs(kEnd) <= d && (d - kEnd) % 2 === 0 && v[off + kEnd] >= n) {
+      const ops = [];
+      let x = n;
+      let y = m;
+      for (let dd = d; dd > 0; dd--) {
+        const prev = snaps[dd - 1];
+        const get = (kk) => prev[kk + dd - 1];
+        const k = x - y;
+        const down = k === -dd || k !== dd && get(k - 1) < get(k + 1);
+        const pk = down ? k + 1 : k - 1;
+        const px = get(pk);
+        const py = px - pk;
+        while (x > (down ? px : px + 1) && y > (down ? py + 1 : py)) {
+          ops.push([" ", a[x - 1]]);
+          x--;
+          y--;
+        }
+        if (down) {
+          ops.push(["+", b[y - 1]]);
+          y--;
+        } else {
+          ops.push(["-", a[x - 1]]);
+          x--;
+        }
+      }
+      while (x > 0 && y > 0) {
+        ops.push([" ", a[x - 1]]);
+        x--;
+        y--;
+      }
+      return ops.reverse();
+    }
+  }
+  return null;
+}
+function diffTokens(a, b) {
+  let pre = 0;
+  while (pre < a.length && pre < b.length && a[pre] === b[pre]) pre++;
+  let suf = 0;
+  while (suf < a.length - pre && suf < b.length - pre && a[a.length - 1 - suf] === b[b.length - 1 - suf]) suf++;
+  const A = a.slice(pre, a.length - suf);
+  const B = b.slice(pre, b.length - suf);
+  const mid = myers(A, B) ?? [...A.map((t) => ["-", t]), ...B.map((t) => ["+", t])];
+  return [
+    ...a.slice(0, pre).map((t) => [" ", t]),
+    ...mid,
+    ...a.slice(a.length - suf).map((t) => [" ", t])
+  ];
+}
+var lineTokens = tokens;
+var diffLines = diffTokens;
+function range(start, count) {
+  const s = count === 0 ? start : start + 1;
+  return count === 1 ? `${s}` : `${s},${count}`;
+}
+function unifiedHunks(a, b) {
+  const ops = diffTokens(tokens(a), tokens(b));
+  const ctx = PATCH_LIMITS.context;
+  const out = [];
+  let i = 0;
+  let oldLine = 0;
+  let newLine = 0;
+  while (i < ops.length) {
+    if (ops[i][0] === " ") {
+      i++;
+      oldLine++;
+      newLine++;
+      continue;
+    }
+    const start = Math.max(0, i - ctx);
+    let last = i;
+    let j = i;
+    while (j < ops.length) {
+      if (ops[j][0] !== " ") last = j;
+      else if (j - last > 2 * ctx) break;
+      j++;
+    }
+    const end = Math.min(ops.length, last + ctx + 1);
+    const lead = i - start;
+    const oStart = oldLine - lead;
+    const nStart = newLine - lead;
+    let oc = 0;
+    let nc = 0;
+    const body = [];
+    for (let k = start; k < end; k++) {
+      const [op, t] = ops[k];
+      if (op !== "+") oc++;
+      if (op !== "-") nc++;
+      body.push(op + (t.endsWith("\n") ? t.slice(0, -1) : t));
+      if (!t.endsWith("\n")) body.push("\");
+    }
+    out.push(`@@ -${range(oStart, oc)} +${range(nStart, nc)} @@`, ...body);
+    oldLine = oStart + oc;
+    newLine = nStart + nc;
+    i = end;
+  }
+  return out;
+}
+function side(prefix, p) {
+  return `${prefix}${p}${p.includes(" ") ? "	" : ""}`;
+}
+var MAX_LOSSY_BYTES = 256 * 1024;
+var looseDec = new TextDecoder("utf-8", { fatal: false });
+function lossyText(b) {
+  return looseDec.decode(b).replace(/[\x00-\x08\x0b\x0c\x0e-\x1f\x7f]/g, (c) => `\\x${c.charCodeAt(0).toString(16).padStart(2, "0")}`);
+}
+function binaryPaths(a, b) {
+  const out = [];
+  for (const p of sortPaths(/* @__PURE__ */ new Set([...a.keys(), ...b.keys()]))) {
+    const A = a.get(p);
+    const B = b.get(p);
+    if (A && B && bytesEqual(A, B)) continue;
+    if (A && asText(A) === null || B && asText(B) === null) out.push(p);
+  }
+  return out;
+}
+function renderDiff(a, b, o = {}) {
+  const out = [];
+  for (const p of sortPaths(/* @__PURE__ */ new Set([...a.keys(), ...b.keys()]))) {
+    const A = a.get(p);
+    const B = b.get(p);
+    if (A && B && bytesEqual(A, B)) continue;
+    out.push(`diff --git a/${p} b/${p}`);
+    if (!A) out.push("new file mode 100644");
+    if (!B) out.push("deleted file mode 100644");
+    let ta = A ? asText(A) : "";
+    let tb = B ? asText(B) : "";
+    const minus = A ? `a/${p}` : DEVNULL;
+    const plus = B ? `b/${p}` : DEVNULL;
+    if (ta === null || tb === null) {
+      const small = (A?.length ?? 0) <= MAX_LOSSY_BYTES && (B?.length ?? 0) <= MAX_LOSSY_BYTES;
+      if (!o.lossy || !small) {
+        out.push(`Binary files ${minus} and ${plus} differ`);
+        continue;
+      }
+      out.push(`map: ${p} is binary or not valid UTF-8 text; shown with undecodable bytes as U+FFFD and control bytes as \\xNN`);
+      ta = A ? lossyText(A) : "";
+      tb = B ? lossyText(B) : "";
+    }
+    if (ta === "" && tb === "") continue;
+    out.push(`--- ${A ? side("a/", p) : DEVNULL}`, `+++ ${B ? side("b/", p) : DEVNULL}`, ...unifiedHunks(ta, tb));
+  }
+  return out.length ? out.join("\n") + "\n" : "";
+}
+
+// ../core/src/merge.ts
+function changes(base, side2) {
+  const out = [];
+  let i = 0;
+  let j = 0;
+  let cur = null;
+  for (const [op] of diffLines(base, side2)) {
+    if (op === " ") {
+      if (cur) out.push(cur);
+      cur = null;
+      i++;
+      j++;
+      continue;
+    }
+    cur ??= { bs: i, be: i, ss: j, se: j };
+    if (op === "-") cur.be = ++i;
+    else cur.se = ++j;
+  }
+  if (cur) out.push(cur);
+  return out;
+}
+var join = (lines2) => lines2.join("");
+var range2 = (start, end) => ({ start: start + 1, count: end - start });
+function isBinary(s) {
+  return s.includes("\0");
+}
+var TOKEN = /\w+|[^\S\n]+|\n|[^\w\s]/g;
+function mergeInsertedTokens(base, ours, theirs) {
+  if (!base) return null;
+  const tok = (s) => s.match(TOKEN) ?? [];
+  const B = tok(base);
+  const inserts = (side2) => {
+    const at = /* @__PURE__ */ new Map();
+    let i = 0;
+    for (const [op, t2] of diffLines(B, side2)) {
+      if (op === " ") i++;
+      else if (op === "-") return null;
+      else at.set(i, [...at.get(i) ?? [], t2]);
+    }
+    return at;
+  };
+  const o = inserts(tok(ours));
+  const t = inserts(tok(theirs));
+  if (!o || !t) return null;
+  let out = "";
+  for (let i = 0; i <= B.length; i++) {
+    const a = (o.get(i) ?? []).join("");
+    const b = (t.get(i) ?? []).join("");
+    out += a === b ? a : a + b;
+    if (i < B.length) out += B[i];
+  }
+  return out;
+}
+function merge3(base, ours, theirs) {
+  if (ours === theirs) return { ok: true, text: ours, unioned: false };
+  if (ours === base) return { ok: true, text: theirs, unioned: false };
+  if (theirs === base) return { ok: true, text: ours, unioned: false };
+  const B = lineTokens(base);
+  const O = lineTokens(ours);
+  const T = lineTokens(theirs);
+  if (isBinary(base) || isBinary(ours) || isBinary(theirs)) {
+    return {
+      ok: false,
+      conflicts: [{ baseRange: range2(0, B.length), oursRange: range2(0, O.length), theirsRange: range2(0, T.length), base, ours, theirs }]
+    };
+  }
+  const all = [
+    ...changes(B, O).map((c) => ({ ...c, side: "o" })),
+    ...changes(B, T).map((c) => ({ ...c, side: "t" }))
+  ].sort((a, b) => a.bs - b.bs || a.be - b.be || (a.side < b.side ? -1 : 1));
+  const out = [];
+  const conflicts = [];
+  let unioned = false;
+  let pos = 0;
+  let offO = 0;
+  let offT = 0;
+  for (let k = 0; k < all.length; ) {
+    const first = all[k];
+    const group = [first];
+    let lo = first.bs;
+    let hi = first.be;
+    k++;
+    while (k < all.length && all[k].bs <= hi) {
+      const c = all[k];
+      group.push(c);
+      lo = Math.min(lo, c.bs);
+      hi = Math.max(hi, c.be);
+      k++;
+    }
+    out.push(...B.slice(pos, lo));
+    pos = hi;
+    const os = group.filter((c) => c.side === "o");
+    const ts = group.filter((c) => c.side === "t");
+    const delta = (cs) => cs.reduce((n, c) => n + (c.se - c.ss) - (c.be - c.bs), 0);
+    const oStart = lo + offO;
+    const oEnd = hi + offO + delta(os);
+    const tStart = lo + offT;
+    const tEnd = hi + offT + delta(ts);
+    offO += delta(os);
+    offT += delta(ts);
+    const oLines = O.slice(oStart, oEnd);
+    const tLines = T.slice(tStart, tEnd);
+    if (!ts.length) {
+      out.push(...oLines);
+      continue;
+    }
+    if (!os.length) {
+      out.push(...tLines);
+      continue;
+    }
+    if (join(oLines) === join(tLines)) {
+      out.push(...oLines);
+      continue;
+    }
+    if (group.every((c) => c.bs === c.be && c.bs === lo)) {
+      out.push(...oLines, ...tLines);
+      unioned = true;
+      continue;
+    }
+    const words = mergeInsertedTokens(join(B.slice(lo, hi)), join(oLines), join(tLines));
+    if (words !== null) {
+      out.push(words);
+      unioned = true;
+      continue;
+    }
+    conflicts.push({
+      baseRange: range2(lo, hi),
+      oursRange: range2(oStart, oEnd),
+      theirsRange: range2(tStart, tEnd),
+      base: join(B.slice(lo, hi)),
+      ours: join(oLines),
+      theirs: join(tLines)
+    });
+  }
+  if (conflicts.length) return { ok: false, conflicts };
+  out.push(...B.slice(pos));
+  return { ok: true, text: join(out), unioned };
+}
+var same = (a, b) => a === void 0 || b === void 0 ? a === b : bytesEqual(a, b);
+function mergeTrees(base, ours, theirs) {
+  const out = new Map(ours);
+  const conflicts = [];
+  const changed = [];
+  let unioned = false;
+  const set = (p, v) => {
+    if (same(ours.get(p), v)) return;
+    if (v === void 0) out.delete(p);
+    else out.set(p, v);
+    changed.push(p);
+  };
+  for (const p of sortPaths(/* @__PURE__ */ new Set([...base.keys(), ...ours.keys(), ...theirs.keys()]))) {
+    const b = base.get(p);
+    const o = ours.get(p);
+    const t = theirs.get(p);
+    if (same(o, t) || same(t, b)) continue;
+    if (same(o, b)) {
+      set(p, t);
+      continue;
+    }
+    const fail = (reason, lines2 = []) => conflicts.push({ path: p, reason, conflicts: lines2 });
+    if (b === void 0) {
+      fail(`${p} was added at the tip and by this push with different content`);
+      continue;
+    }
+    if (o === void 0) {
+      fail(`${p} was deleted at the tip and changed by this push`);
+      continue;
+    }
+    if (t === void 0) {
+      fail(`${p} was changed at the tip and deleted by this push`);
+      continue;
+    }
+    const tb = asText(b);
+    const to = asText(o);
+    const tt = asText(t);
+    if (tb === null || to === null || tt === null) {
+      fail(`${p} is binary and was changed both at the tip and by this push`);
+      continue;
+    }
+    const m = merge3(tb, to, tt);
+    if (m.ok) {
+      unioned ||= m.unioned;
+      set(p, new TextEncoder().encode(m.text));
+    } else fail(`${p} was changed at the tip and by this push in the same lines`, m.conflicts);
+  }
+  const folded = /* @__PURE__ */ new Map();
+  for (const p of sortPaths(out.keys())) {
+    const key = foldKey(p);
+    const other = folded.get(key);
+    if (other !== void 0 && (!ours.has(p) || !ours.has(other))) {
+      conflicts.push({ path: p, reason: `${p} and ${other} differ only by case or Unicode normalisation`, conflicts: [] });
+    }
+    folded.set(key, p);
+  }
+  if (conflicts.length) return { ok: false, conflicts };
+  return { ok: true, tree: out, changed: sortPaths(changed), unioned };
+}
+
+// ../core/src/tree.ts
+var MAX_UNPACKED_BYTES = 50 * 1024 * 1024;
+var MAX_TAR_BYTES = MAX_UNPACKED_BYTES + 16 * 1024 * 1024;
+function octal(n, width) {
+  return n.toString(8).padStart(width - 1, "0") + "\0";
+}
+function header(name, prefix, size, type) {
+  const h = new Uint8Array(512);
+  const put = (s, off) => h.set(typeof s === "string" ? utf8(s) : s, off);
+  put(name, 0);
+  put(octal(420, 8), 100);
+  put(octal(0, 8), 108);
+  put(octal(0, 8), 116);
+  put(octal(size, 12), 124);
+  put(octal(0, 12), 136);
+  put("        ", 148);
+  put(type, 156);
+  put("ustar\0", 257);
+  put("00", 263);
+  put(prefix, 345);
+  let sum = 0;
+  for (const b of h) sum += b;
+  put(sum.toString(8).padStart(6, "0") + "\0 ", 148);
+  return h;
+}
+function pad(n) {
+  return new Uint8Array((512 - n % 512) % 512);
+}
+function splitUstarName(path) {
+  if (path.length <= 100) return [path, new Uint8Array(0)];
+  for (let i = path.length - 1; i > 0; i--) {
+    if (path[i] !== 47) continue;
+    if (i <= 155 && path.length - i - 1 <= 100) return [path.subarray(i + 1), path.subarray(0, i)];
+  }
+  return null;
+}
+function paxRecord(key, value) {
+  const body = ` ${key}=${value}
+`;
+  const bodyLen = utf8(body).length;
+  let len = bodyLen + String(bodyLen).length;
+  if (String(len).length !== String(bodyLen).length) len = bodyLen + String(len).length;
+  return utf8(`${len}${body}`);
+}
+function packTarGz(t) {
+  const parts = [];
+  for (const path of sortPaths(t.keys())) {
+    const data = t.get(path);
+    const name = utf8(path);
+    const split = splitUstarName(name);
+    if (split) {
+      parts.push(header(split[0], split[1], data.length, "0"));
+    } else {
+      const pax = paxRecord("path", path);
+      parts.push(header(utf8("PaxHeader"), new Uint8Array(0), pax.length, "x"), pax, pad(pax.length));
+      parts.push(header(name.subarray(name.length - 100), new Uint8Array(0), data.length, "0"));
+    }
+    parts.push(data, pad(data.length));
+  }
+  parts.push(new Uint8Array(1024));
+  return gzipSync(concat(parts), { mtime: 0 });
+}
+var TarError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "TarError";
+  }
+};
+function cstr(b) {
+  const z = b.indexOf(0);
+  return z === -1 ? b : b.subarray(0, z);
+}
+function readOctal(b) {
+  const s = fromUtf8(cstr(b)).trim();
+  if (!/^[0-7]*$/.test(s)) throw new TarError("bad number in tar header");
+  return s ? parseInt(s, 8) : 0;
+}
+function parsePax(b) {
+  const out = {};
+  let i = 0;
+  while (i < b.length) {
+    const sp = b.indexOf(32, i);
+    if (sp === -1) break;
+    const len = parseInt(fromUtf8(b.subarray(i, sp)), 10);
+    if (!(len > 0) || i + len > b.length) throw new TarError("bad pax record");
+    const rec = fromUtf8(b.subarray(sp + 1, i + len - 1));
+    const eq = rec.indexOf("=");
+    if (eq > 0) out[rec.slice(0, eq)] = rec.slice(eq + 1);
+    i += len;
+  }
+  return out;
+}
+function safePath(raw) {
+  let p = raw;
+  while (p.startsWith("./")) p = p.slice(2);
+  if (!p || p.startsWith("/") || /[\x00-\x1f\x7f\\]/.test(p)) throw new TarError(`unsafe path in snapshot: ${JSON.stringify(raw)}`);
+  const parts = p.split("/");
+  if (parts.some((c) => c === "" || c === "." || c === "..")) throw new TarError(`unsafe path in snapshot: ${JSON.stringify(raw)}`);
+  return p;
+}
+function gunzipCapped(b) {
+  const chunks = [];
+  let total = 0;
+  const g = new Gunzip((chunk) => {
+    total += chunk.length;
+    if (total > MAX_TAR_BYTES) throw new TarError("snapshot is larger than 50 MB");
+    chunks.push(chunk);
+  });
+  for (let i = 0; i < b.length; i += 65536) g.push(b.subarray(i, i + 65536), i + 65536 >= b.length);
+  if (b.length === 0) throw new TarError("empty snapshot");
+  return concat(chunks);
+}
+function unpackTarGz(b) {
+  const tar = gunzipCapped(b);
+  const tree = /* @__PURE__ */ new Map();
+  let total = 0;
+  let off = 0;
+  let nextPath = null;
+  while (off + 512 <= tar.length) {
+    const h = tar.subarray(off, off + 512);
+    if (h.every((x) => x === 0)) break;
+    let sum = 0;
+    for (let i = 0; i < 512; i++) sum += i >= 148 && i < 156 ? 32 : h[i];
+    if (sum !== readOctal(h.subarray(148, 156))) throw new TarError("bad tar header checksum");
+    const size = readOctal(h.subarray(124, 136));
+    const type = String.fromCharCode(h[156]);
+    const dataStart = off + 512;
+    const dataEnd = dataStart + size;
+    if (dataEnd > tar.length) throw new TarError("truncated tar");
+    const data = tar.subarray(dataStart, dataEnd);
+    off = dataStart + Math.ceil(size / 512) * 512;
+    if (type === "x") {
+      const pax = parsePax(data);
+      if (pax.path !== void 0) nextPath = pax.path;
+      continue;
+    }
+    if (type === "g") continue;
+    if (type === "L") {
+      nextPath = fromUtf8(cstr(data));
+      continue;
+    }
+    let name = fromUtf8(cstr(h.subarray(0, 100)));
+    const magic = fromUtf8(h.subarray(257, 262));
+    const prefix = magic === "ustar" ? fromUtf8(cstr(h.subarray(345, 500))) : "";
+    if (prefix) name = `${prefix}/${name}`;
+    if (nextPath !== null) name = nextPath;
+    nextPath = null;
+    if (type === "5") {
+      safePath(name.replace(/\/+$/, ""));
+      continue;
+    }
+    if (type === "1" || type === "2") throw new TarError(`links are not allowed in snapshots: ${name}`);
+    if (type !== "0" && type !== "\0" && type !== "7") throw new TarError(`unsupported tar entry type ${JSON.stringify(type)}: ${name}`);
+    const path = safePath(name);
+    if (tree.has(path)) throw new TarError(`duplicate path in snapshot: ${path}`);
+    total += size;
+    if (total > MAX_UNPACKED_BYTES) throw new TarError("snapshot is larger than 50 MB");
+    tree.set(path, data.slice());
+  }
+  return tree;
+}
+
+// ../core/src/settings.ts
+var CONFIRM_TTL_MS = 7 * 24 * 60 * 60 * 1e3;
+
+// ../core/src/webhook.ts
+var enc2 = new TextEncoder();
+var MAX_AGE_SECONDS = 24 * 60 * 60;
+
+// src/main.ts
+import { chmodSync, copyFileSync, existsSync as existsSync5, mkdirSync as mkdirSync5, readdirSync as readdirSync4, readFileSync as readFileSync5, realpathSync as realpathSync2, writeFileSync as writeFileSync7 } from "node:fs";
+import { homedir as homedir3 } from "node:os";
+import { basename, delimiter, join as join9, resolve as resolve3 } from "node:path";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
+
+// src/address.ts
+import { mkdirSync as mkdirSync2, readFileSync as readFileSync3, writeFileSync as writeFileSync3 } from "node:fs";
+import { homedir } from "node:os";
+import { dirname as dirname2, join as join5 } from "node:path";
+
+// src/transport.ts
+import { pathToFileURL } from "node:url";
+
+// ../transports/primitive/src/index.ts
+import { spawn } from "node:child_process";
+import { randomBytes } from "node:crypto";
+import { mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join as join2 } from "node:path";
+import { userInfo } from "node:os";
+var TransportError = class extends Error {
+  name = "TransportError";
+};
+var MapError = TransportError;
+function run(cmd, args, o = {}) {
+  return new Promise((resolve4, reject) => {
+    const child = spawn(cmd, args, { stdio: ["ignore", "pipe", "pipe"] });
+    const out = [];
+    const err2 = [];
+    const timer = o.timeoutMs ? setTimeout(() => child.kill("SIGTERM"), o.timeoutMs) : void 0;
+    child.stdout.on("data", (b) => out.push(b));
+    child.stderr.on("data", (b) => err2.push(b));
+    child.on("error", (e) => {
+      if (timer) clearTimeout(timer);
+      reject(e.code === "ENOENT" ? new TransportError(`${cmd} was not found on PATH (install it with npm install -g primitive)`) : e);
+    });
+    child.on("close", (code) => {
+      if (timer) clearTimeout(timer);
+      resolve4({ code: code ?? 1, out: Buffer.concat(out).toString("utf8"), err: Buffer.concat(err2).toString("utf8") });
+    });
+  });
+}
+var scratch;
+function tempDir() {
+  if (!scratch) {
+    const dir = mkdtempSync(join2(tmpdir(), "map-primitive-"));
+    scratch = dir;
+    process.on("exit", () => rmSync(dir, { recursive: true, force: true }));
+  }
+  return scratch;
+}
+function bin() {
+  return process.env.MAP_PRIMITIVE_BIN || "primitive";
+}
+function agentProfile() {
+  return process.env.PRIMITIVE_AGENT_PROFILE || void 0;
+}
+function summary(x) {
+  return {
+    id: String(x?.id ?? ""),
+    subject: String(x?.subject ?? ""),
+    sender: String(x?.from_email ?? x?.sender ?? "").toLowerCase(),
+    recipient: x?.recipient ? String(x.recipient).toLowerCase() : void 0,
+    received_at: String(x?.received_at ?? x?.created_at ?? ""),
+    awaiting: x?.awaiting ?? void 0,
+    thread_id: x?.thread_id ?? void 0
+  };
+}
+function jsonLines(out) {
+  const xs = [];
+  for (const line of out.split("\n")) {
+    const t = line.trim();
+    if (!t.startsWith("{")) continue;
+    try {
+      xs.push(JSON.parse(t));
+    } catch {
+    }
+  }
+  return xs;
+}
+var seq = 0;
+function bodyFile(body) {
+  const f = join2(tempDir(), `body-${process.pid}-${++seq}.txt`);
+  writeFileSync(f, body);
+  return f;
+}
+async function cli(args, timeoutMs = 12e4) {
+  const r = await run(bin(), args, { timeoutMs });
+  if (r.code !== 0) {
+    const why = (r.err.trim() || r.out.trim()).split("\n").slice(-6).join("\n");
+    throw new MapError(`primitive ${args.slice(0, 2).join(" ")} failed: ${why}`);
+  }
+  return r.out;
+}
+var sentSearch = null;
+function searchesSentMail() {
+  sentSearch ??= run(bin(), ["emails", "search", "--help"], { timeoutMs: 6e4 }).then((r) => r.code === 0 && /--direction/.test(r.out)).catch(() => false);
+  return sentSearch;
+}
+function primitiveTransport() {
+  return {
+    name: "primitive",
+    async send(m) {
+      const from = m.fromName ? `"${m.fromName.replace(/["\\]/g, "\\$&")}" <${m.from}>` : m.from;
+      const args = ["send", "--from", from, "--to", m.to, "--subject", m.subject, "--body-file", bodyFile(m.body)];
+      for (const a of m.attachments ?? []) args.push("--attachment", a);
+      args.push("--idempotency-key", `map-cli-${randomBytes(12).toString("hex")}`, "--json");
+      const out = await cli(args);
+      let d;
+      try {
+        d = JSON.parse(out);
+      } catch {
+        throw new MapError(`primitive send printed something unexpected: ${out.slice(0, 300)}`);
+      }
+      if (d?.error) throw new MapError(`primitive send failed: ${JSON.stringify(d.error).slice(0, 300)}`);
+      const id = d?.sent_email_id ?? d?.sent?.id ?? d?.id;
+      if (typeof id !== "string" || !id) throw new MapError(`primitive send did not report a sent email id: ${out.slice(0, 300)}`);
+      return id;
+    },
+    async waitReply(sentId, o) {
+      const args = ["emails", "wait", "--reply-to-sent-email-id", sentId, "--from", o.from, "--include-existing", "--timeout", String(Math.max(1, Math.round(o.timeoutSec)))];
+      if (!agentProfile()) args.push("--to", o.me);
+      if (o.since) args.push("--since", o.since);
+      const r = await run(bin(), args, { timeoutMs: (o.timeoutSec + 60) * 1e3 });
+      const hits = jsonLines(r.out).map(summary).filter((x) => x.id);
+      if (hits.length) return hits[0];
+      if (r.code === 0 || /timed out/i.test(r.err + r.out)) return null;
+      throw new MapError(`primitive emails wait failed: ${(r.err.trim() || r.out.trim()).slice(-400)}`);
+    },
+    async get(id) {
+      const d = JSON.parse(await cli(["emails", "get", "--id", id, "--json"]));
+      const atts = d?.parsed?.attachments ?? d?.attachments ?? [];
+      const detail = {
+        ...summary(d),
+        body_text: String(d?.body_text ?? d?.parsed?.body_text ?? ""),
+        attachments: atts.map((a, i) => ({ filename: String(a?.filename ?? ""), part_index: Number(a?.part_index ?? i) })),
+        message_id: d?.message_id ?? void 0,
+        in_reply_to: d?.parsed?.in_reply_to ?? void 0,
+        references: d?.parsed?.references ?? void 0,
+        from_header: d?.from_header ?? void 0
+      };
+      return detail;
+    },
+    async download(id, part, out) {
+      await cli(["emails", "download-email-attachment-part", "--id", id, "--part-index", String(part), "--output", out]);
+      return new Uint8Array(readFileSync(out));
+    },
+    async reply(id, m) {
+      await cli(["reply", "--id", id, "--from", m.from, "--body-file", bodyFile(m.body)]);
+    },
+    async list(o) {
+      const args = ["emails", "list", "--envelope", "--json", "--limit", String(o.limit ?? 100)];
+      if (!agentProfile()) args.push("--recipient", o.me);
+      if (o.after) args.push("--date-from", o.after);
+      if (o.cursor) args.push("--cursor", o.cursor);
+      const d = JSON.parse(await cli(args));
+      const rows = Array.isArray(d) ? d : d?.data ?? [];
+      return { data: rows.map(summary), cursor: Array.isArray(d) ? null : d?.meta?.cursor ?? null };
+    },
+    async tail(o) {
+      const cursor = o.cursor ?? `${new Date(o.from ?? Date.now()).toISOString()}|00000000-0000-0000-0000-000000000000`;
+      const args = ["emails", "list", "--envelope", "--json", "--limit", String(o.limit ?? 100), "--since", cursor];
+      if (!agentProfile()) args.push("--recipient", o.me);
+      if (o.wait) args.push("--wait", String(Math.min(60, Math.max(1, Math.round(o.wait)))));
+      const d = JSON.parse(await cli(args, ((o.wait ?? 0) + 120) * 1e3));
+      const rows = d?.data ?? [];
+      return { data: rows.map(summary), cursor: d?.meta?.cursor ?? cursor };
+    },
+    async describe() {
+      const r = await run(bin(), ["--version"], { timeoutMs: 3e4 }).catch(() => null);
+      return { provider: "Primitive (primitive.dev)", version: r?.out.trim().split("\n")[0] || void 0 };
+    },
+    async setup() {
+      const login = { why: "log in to Primitive (opens a browser, or pass your email for a code)", command: ["primitive", "login"], interactive: true };
+      const version = await run(bin(), ["--version"], { timeoutMs: 3e4 }).catch(() => null);
+      if (!version) {
+        return { ready: false, steps: [{ why: "install the primitive CLI", command: ["npm", "install", "-g", "primitive"], interactive: false }, login] };
+      }
+      const profile = agentProfile();
+      if (profile) {
+        const address = await this.defaultAddress().catch(() => null);
+        return address ? { ready: true, steps: [], account: `connected agent (profile ${profile})`, address } : { ready: false, steps: [{ why: `reconnect the agent profile ${profile}`, command: ["primitive", "agent", "connect", "--profile", profile, "--status"], interactive: false }] };
+      }
+      const who = await run(bin(), ["whoami", "--json"], { timeoutMs: 6e4 }).catch(() => null);
+      let d = null;
+      try {
+        d = who && who.code === 0 ? JSON.parse(who.out) : null;
+      } catch {
+        d = null;
+      }
+      if (!d) return { ready: false, steps: [login] };
+      const domain = typeof d.managed_inbox_domain === "string" ? d.managed_inbox_domain : "";
+      const local = (userInfo().username || "agent").toLowerCase().replace(/[^a-z0-9._-]/g, "") || "agent";
+      return { ready: true, steps: [], account: typeof d.email === "string" ? d.email : void 0, suggestedAddress: domain ? `${local}@${domain}` : void 0 };
+    },
+    async search(o) {
+      if (o.direction && o.direction !== "inbound" && !await searchesSentMail()) return { data: [], cursor: null, unsupported: true };
+      const shown2 = [];
+      const add = (flag, v) => {
+        if (v === void 0 || v === "") return;
+        shown2.push(flag, String(v));
+      };
+      add("--q", o.q);
+      add("--from", o.from);
+      add("--to", o.to);
+      add("--subject", o.subject);
+      add("--body", o.body);
+      add("--thread-id", o.threadId);
+      if (o.direction && o.direction !== "inbound") add("--direction", o.direction);
+      add("--sort", o.sort ?? "received_at_desc");
+      add("--limit", o.limit ?? 50);
+      const args = ["emails", "search", ...shown2, "--json", "--envelope", "--snippet", "false"];
+      if (o.cursor) args.push("--cursor", o.cursor);
+      const d = JSON.parse(await cli(args));
+      const rows = Array.isArray(d) ? d : d?.data ?? [];
+      const quote = (x) => /^[\w@.:=-]+$/.test(x) ? x : `'${x.replace(/'/g, "'\\''")}'`;
+      return {
+        data: rows.map((x) => ({ ...summary(x), snippet: typeof x?.snippet === "string" ? x.snippet : void 0 })),
+        cursor: Array.isArray(d) ? null : d?.meta?.cursor ?? null,
+        command: `primitive emails search ${shown2.map(quote).join(" ")}`
+      };
+    },
+    // A connected agent can send as no other address. Primitive's session hook
+    // exports it as PRIMITIVE_AGENT_ADDRESS; otherwise ask the selected profile.
+    async boundAddress() {
+      const exported = process.env.PRIMITIVE_AGENT_ADDRESS?.trim();
+      if (exported && agentProfile()) return exported;
+      return agentProfile() ? await this.defaultAddress() : null;
+    },
+    async defaultAddress() {
+      const profile = agentProfile();
+      if (!profile) return null;
+      const r = await run(bin(), ["agent", "connect", "--profile", profile, "--status", "--json"], { timeoutMs: 6e4 }).catch(() => null);
+      try {
+        const d = JSON.parse(r?.out ?? "");
+        const a = d?.identity?.agentAddress ?? d?.agentAddress ?? d?.address;
+        if (typeof a === "string" && a) return a;
+      } catch {
+      }
+      throw new MapError(`could not read the address of the primitive agent profile ${profile}. Pass --from <your address> or set MAP_FROM.`);
+    }
+  };
+}
+
+// src/util.ts
+import { spawn as spawn2 } from "node:child_process";
+import { mkdtempSync as mkdtempSync2, rmSync as rmSync2 } from "node:fs";
+import { tmpdir as tmpdir2 } from "node:os";
+import { join as join3 } from "node:path";
+var MapError2 = class extends Error {
+  constructor(message, code = 1) {
+    super(message);
+    this.code = code;
+  }
+};
+function adoptLegacyEnv(env = process.env) {
+  for (const [k, v] of Object.entries(env)) {
+    if (k.startsWith("GUD_") && !env[`MAP_${k.slice(4)}`]) env[`MAP_${k.slice(4)}`] = v;
+  }
+}
+function run2(cmd, args, o = {}) {
+  return new Promise((resolve4, reject) => {
+    const child = spawn2(cmd, args, { env: o.env ?? process.env, cwd: o.cwd, stdio: ["pipe", "pipe", "pipe"] });
+    const out = [];
+    const err2 = [];
+    let timer;
+    if (o.timeoutMs) timer = setTimeout(() => child.kill("SIGTERM"), o.timeoutMs);
+    child.stdout.on("data", (b) => out.push(b));
+    child.stderr.on("data", (b) => err2.push(b));
+    child.on("error", (e) => {
+      if (timer) clearTimeout(timer);
+      if (e.code === "ENOENT") reject(new MapError2(`${cmd} was not found on PATH`));
+      else reject(e);
+    });
+    child.on("close", (code) => {
+      if (timer) clearTimeout(timer);
+      const bytes = Buffer.concat(out);
+      resolve4({ code: code ?? 1, out: bytes.toString("utf8"), err: Buffer.concat(err2).toString("utf8"), bytes });
+    });
+    child.stdin.on("error", () => {
+    });
+    child.stdin.end(o.input ?? "");
+  });
+}
+var scratch2;
+function tempDir2() {
+  if (!scratch2) {
+    scratch2 = mkdtempSync2(join3(tmpdir2(), "map-"));
+    const dir = scratch2;
+    process.on("exit", () => rmSync2(dir, { recursive: true, force: true }));
+  }
+  return scratch2;
+}
+function say(line) {
+  process.stderr.write(`${line}
+`);
+}
+function oneLine(s, max2 = 150) {
+  const t = s.replace(/\s+/g, " ").trim();
+  return t.length > max2 ? `${t.slice(0, max2 - 3)}...` : t;
+}
+function indent(text2, pad2 = "  ") {
+  return text2.replace(/\n+$/, "").split("\n").map((l) => l ? pad2 + l : l).join("\n");
+}
+
+// src/transport.ts
+var BUILT_IN = { primitive: primitiveTransport };
+var current;
+function transport() {
+  return current ??= loadTransport(process.env.MAP_TRANSPORT || "primitive");
+}
+async function loadTransport(name) {
+  const built = BUILT_IN[name];
+  if (built) return built();
+  if (/[\\/]|\.m?js$/.test(name)) {
+    const mod = await import(pathToFileURL(name).href).catch((e) => {
+      throw new MapError2(`could not load the transport module ${name}: ${e.message}`);
+    });
+    const f = mod?.default ?? mod?.transport;
+    if (typeof f !== "function") throw new MapError2(`${name} must export a default function that returns a transport`);
+    return f();
+  }
+  throw new MapError2(`unknown MAP_TRANSPORT "${name}": use ${Object.keys(BUILT_IN).join(", ")}, or the path of an adapter module`);
+}
+
+// src/workdir.ts
+import { existsSync, lstatSync, mkdirSync, readdirSync, readFileSync as readFileSync2, rmSync as rmSync3, writeFileSync as writeFileSync2 } from "node:fs";
+import { dirname, join as join4, relative, resolve, sep } from "node:path";
+var META_DIR = ".map";
+var LEGACY_META_DIR = ".gud";
+function metaDirOf(dir) {
+  if (!existsSync(join4(dir, META_DIR, "meta.json")) && existsSync(join4(dir, LEGACY_META_DIR, "meta.json"))) return LEGACY_META_DIR;
+  return META_DIR;
+}
+function metaPath(dir) {
+  return join4(dir, metaDirOf(dir), "meta.json");
+}
+function findWorkdir(start = process.cwd()) {
+  let d = resolve(start);
+  for (; ; ) {
+    if (existsSync(metaPath(d))) return d;
+    const up = dirname(d);
+    if (up === d) return null;
+    d = up;
+  }
+}
+function readMeta(dir) {
+  try {
+    return JSON.parse(readFileSync2(metaPath(dir), "utf8"));
+  } catch {
+    throw new MapError2(`${dir} is not a map working copy (no ${META_DIR}/meta.json). Make one with: map get <repo> [dir]`);
+  }
+}
+function writeMeta(dir, m) {
+  mkdirSync(join4(dir, metaDirOf(dir)), { recursive: true });
+  writeFileSync2(metaPath(dir), `${JSON.stringify(m, null, 2)}
+`);
+}
+function readBase(dir) {
+  return unpackTarGz(new Uint8Array(readFileSync2(join4(dir, metaDirOf(dir), "base.tar.gz"))));
+}
+function writeBase(dir, t) {
+  mkdirSync(join4(dir, metaDirOf(dir)), { recursive: true });
+  writeFileSync2(join4(dir, metaDirOf(dir), "base.tar.gz"), packTarGz(t));
+}
+function writeSent(dir, sent, t) {
+  mkdirSync(join4(dir, metaDirOf(dir), "sent"), { recursive: true });
+  writeFileSync2(join4(dir, metaDirOf(dir), "sent", `${sent}.tar.gz`), packTarGz(t));
+}
+function readSent(dir, sent) {
+  const f = join4(dir, metaDirOf(dir), "sent", `${sent}.tar.gz`);
+  return existsSync(f) ? unpackTarGz(new Uint8Array(readFileSync2(f))) : null;
+}
+function dropSent(dir, sent) {
+  rmSync3(join4(dir, metaDirOf(dir), "sent", `${sent}.tar.gz`), { force: true });
+}
+function ignoreMatcher(text2) {
+  const rules = [];
+  for (const raw of text2.split(/\r?\n/)) {
+    let p = raw.trim();
+    if (!p || p.startsWith("#") || p.startsWith("!")) continue;
+    const dirOnly = p.endsWith("/");
+    if (dirOnly) p = p.slice(0, -1);
+    const anchored = p.startsWith("/") || p.includes("/");
+    p = p.replace(/^\//, "");
+    const re = p.split("").map((c, i, a) => c === "*" ? a[i + 1] === "*" ? "\0" : a[i - 1] === "*" ? "" : "[^/]*" : c === "?" ? "[^/]" : /[.+^${}()|[\]\\]/.test(c) ? `\\${c}` : c).join("").replace(/\u0000\/?/g, "(?:.*/)?");
+    rules.push({ re: new RegExp(`^${re}$`), dirOnly, anchored });
+  }
+  return (path, isDir) => {
+    const parts = path.split("/");
+    return rules.some((r) => {
+      if (r.dirOnly && !isDir) return false;
+      return r.anchored ? r.re.test(path) : r.re.test(parts[parts.length - 1]);
+    });
+  };
+}
+function readWork(dir, base) {
+  const tree = /* @__PURE__ */ new Map();
+  const skipped = [];
+  const gi = join4(dir, ".gitignore");
+  const ignored = ignoreMatcher(existsSync(gi) ? readFileSync2(gi, "utf8") : "");
+  const tracked = (p) => base.has(p) || [...base.keys()].some((k) => k.startsWith(`${p}/`));
+  const walk = (abs) => {
+    for (const name of readdirSync(abs).sort()) {
+      const full = join4(abs, name);
+      const rel = relative(dir, full).split(sep).join("/");
+      if (rel === META_DIR || rel === LEGACY_META_DIR || rel === ".git") continue;
+      const st = lstatSync(full);
+      if (st.isSymbolicLink()) {
+        skipped.push(`${rel} (symlink)`);
+        continue;
+      }
+      if (st.isDirectory()) {
+        if (ignored(rel, true) && !tracked(rel)) continue;
+        walk(full);
+      } else if (st.isFile()) {
+        if (ignored(rel, false) && !base.has(rel)) continue;
+        tree.set(rel, new Uint8Array(readFileSync2(full)));
+      } else skipped.push(`${rel} (not a regular file)`);
+    }
+  };
+  walk(dir);
+  return { tree, skipped };
+}
+function writeWork(dir, prev, next) {
+  for (const [p, b] of next) {
+    const cur = prev.get(p);
+    if (cur && cur.length === b.length && Buffer.compare(Buffer.from(cur), Buffer.from(b)) === 0 && existsSync(join4(dir, p))) continue;
+    const full = join4(dir, ...p.split("/"));
+    mkdirSync(dirname(full), { recursive: true });
+    writeFileSync2(full, b);
+  }
+  for (const p of prev.keys()) {
+    if (next.has(p)) continue;
+    rmSync3(join4(dir, ...p.split("/")), { force: true });
+    let d = dirname(join4(dir, ...p.split("/")));
+    while (d.startsWith(dir) && d !== dir) {
+      try {
+        if (readdirSync(d).length) break;
+        rmSync3(d, { recursive: true });
+      } catch {
+        break;
+      }
+      d = dirname(d);
+    }
+  }
+}
+
+// src/address.ts
+var REPO_RE = /^[a-z][a-z0-9]{1,30}-[a-z][a-z0-9]{1,30}@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z]{2,}$/;
+function parseRepo(s) {
+  const a = s.trim().replace(/^(?:map|gud):\/\//i, "").replace(/\/+$/, "").toLowerCase();
+  if (!REPO_RE.test(a)) throw new MapError2(`"${s}" is not a map repo address (like owner-repo@map.dev)`);
+  return a;
+}
+function isRepoAddress(s) {
+  return REPO_RE.test(s.toLowerCase());
+}
+var ADDRESS = /^[^\s@<>"]+@[^\s@<>"]+\.[^\s@<>"]+$/;
+async function resolveRepo(arg) {
+  if (arg) return parseRepo(arg);
+  const dir = findWorkdir();
+  if (dir) return readMeta(dir).repo;
+  throw new MapError2("no repo given and this folder is not a map working copy. Pass the repo address, like owner-repo@map.dev, or run map get <repo> first.");
+}
+function configPath() {
+  return process.env.MAP_CONFIG || join5(process.env.XDG_CONFIG_HOME || join5(homedir(), ".config"), "map", "config.json");
+}
+function legacyConfigPath() {
+  return join5(process.env.XDG_CONFIG_HOME || join5(homedir(), ".config"), "gud", "config.json");
+}
+function readConfig() {
+  for (const p of process.env.MAP_CONFIG ? [configPath()] : [configPath(), legacyConfigPath()]) {
+    try {
+      return JSON.parse(readFileSync3(p, "utf8"));
+    } catch {
+    }
+  }
+  return {};
+}
+var DEFAULT_HOST = "map.dev";
+function defaultHost() {
+  return (process.env.MAP_HOST || readConfig().host || DEFAULT_HOST).trim().toLowerCase();
+}
+function writeConfig(c) {
+  const p = configPath();
+  mkdirSync2(dirname2(p), { recursive: true });
+  writeFileSync3(p, `${JSON.stringify({ ...readConfig(), ...c }, null, 2)}
+`);
+}
+async function resolveMe(flag) {
+  const pick = (s, where) => {
+    const a = s.trim().toLowerCase();
+    if (!ADDRESS.test(a)) throw new MapError2(`${where} is "${s}", which is not an email address`);
+    return a;
+  };
+  if (flag) return pick(flag, "--from");
+  if (process.env.MAP_FROM) return pick(process.env.MAP_FROM, "MAP_FROM");
+  const t = await transport();
+  const bound = await t.boundAddress?.();
+  if (bound) return pick(bound, `the ${t.name} agent's address`);
+  const dir = findWorkdir();
+  if (dir) {
+    const f = readMeta(dir).from;
+    if (f) return pick(f, `${dir}/.map/meta.json`);
+  }
+  const c = readConfig().from;
+  if (c) return pick(c, configPath());
+  const d = await t.defaultAddress();
+  if (d) return pick(d, `the address of the ${t.name} login`);
+  throw new MapError2(`map does not know your email address. Run map init, pass --from <address>, or set MAP_FROM.`);
+}
+
+// src/mail.ts
+function after(iso) {
+  const t = Date.parse(iso);
+  return Number.isNaN(t) ? iso : new Date(t + 1).toISOString();
+}
+var Mail = class {
+  constructor(me, t) {
+    this.me = me;
+    this.t = t ? Promise.resolve(t) : transport();
+  }
+  t;
+  async send(o) {
+    return (await this.t).send({ from: this.me, fromName: o.fromName, to: o.to, subject: o.subject, body: o.body, attachments: o.attachment ? [o.attachment] : [] });
+  }
+  async waitReply(sentId, from, o) {
+    return (await this.t).waitReply(sentId, { me: this.me, from, ...o });
+  }
+  async get(id) {
+    return (await this.t).get(id);
+  }
+  async download(id, part, out) {
+    return (await this.t).download(id, part, out);
+  }
+  async reply(id, body) {
+    return (await this.t).reply(id, { from: this.me, body });
+  }
+  async list(o = {}) {
+    return (await this.t).list({ me: this.me, ...o });
+  }
+  async tail(o = {}) {
+    return (await this.t).tail({ me: this.me, ...o });
+  }
+};
+
+// src/replies.ts
+function parseLog(body) {
+  const tip = /up to the tip (c\d+-[0-9a-f]{8})/.exec(body)?.[1] ?? null;
+  const lines2 = body.replace(/\r\n?/g, "\n").split("\n");
+  const entries = [];
+  for (let i = 0; i < lines2.length; i++) {
+    const m = /^(c\d+-[0-9a-f]{8}) {2}(\d{4}-\d\d-\d\d \d\d:\d\d) {2}(\S+) {2}approved by (.*)$/.exec(lines2[i]);
+    if (!m) continue;
+    const next = lines2[i + 1] ?? "";
+    const mm = /^ {4}(.*?)(?: \(push (p-[0-9a-f]{8})\))?$/.exec(next);
+    const message = mm ? mm[1] : "";
+    entries.push({ id: m[1], at: m[2], author: m[3], approvedBy: m[4], message: message === "(no message)" ? "" : message, pid: mm?.[2] ?? null });
+  }
+  return { tip: tip ?? entries[0]?.id ?? null, entries };
+}
+function parseStatus(body) {
+  const tip = /^Status\. Tip: (\S+)/m.exec(body)?.[1] ?? null;
+  const lines2 = body.replace(/\r\n?/g, "\n").split("\n");
+  const pushes = [];
+  for (let i = 0; i < lines2.length; i++) {
+    const m = /^ {2}(p-[0-9a-f]{8}) {2}(.+?) {2}(\S+@\S+) {2}(.+?) old$/.exec(lines2[i]);
+    if (!m) continue;
+    const subject = /^ {4}(.*)$/.exec(lines2[i + 1] ?? "")?.[1] ?? "";
+    pushes.push({ pid: m[1], state: m[2], author: m[3], age: m[4], subject: subject === "(no subject)" ? "" : subject });
+  }
+  return { tip, pushes };
+}
+function stripReadHelp(body) {
+  const i = body.indexOf("Read commands: email the repo");
+  return (i === -1 ? body : body.slice(0, i)).replace(/\s+$/, "");
+}
+function quotedBlock(body) {
+  const lines2 = body.replace(/\r\n?/g, "\n").split("\n");
+  const out = [];
+  let started = false;
+  for (const l of lines2) {
+    if (l.startsWith(">")) {
+      started = true;
+      out.push(l.replace(/^> ?/, ""));
+    } else if (started) break;
+  }
+  return out.join("\n").trim();
+}
+function quotedBlocks(body) {
+  const lines2 = body.replace(/\r\n?/g, "\n").split("\n");
+  const out = [];
+  for (let i = 0; i < lines2.length; i++) {
+    if (!lines2[i].startsWith(">")) continue;
+    const buf = [];
+    let j = i;
+    for (; j < lines2.length && lines2[j].startsWith(">"); j++) buf.push(lines2[j].replace(/^> ?/, ""));
+    let k = i - 1;
+    while (k >= 0 && !lines2[k].trim()) k--;
+    out.push({ label: (lines2[k] ?? "").trim().replace(/:$/, ""), text: buf.join("\n").trim() });
+    i = j;
+  }
+  return out;
+}
+function parseVerdict(subject, body) {
+  const s = parseSubject(subject);
+  const b = body.replace(/\r\n?/g, "\n");
+  const pidInBody = /\b(p-[0-9a-f]{8})\b/.exec(b)?.[1];
+  if (!s) return { kind: "other", final: false };
+  switch (s.kind) {
+    case "landed":
+      return { kind: "landed", final: true, cid: s.id, pid: /(?:map|gud) landed push (p-[0-9a-f]{8})/.exec(b)?.[1] ?? pidInBody, merged: /merged your change onto/.test(b) };
+    case "conflict": {
+      const tip = /^Tip commit: (\S+)/m.exec(b)?.[1];
+      let end = b.indexOf("If you still have the repo directory");
+      if (end === -1) end = b.length;
+      const overlaps = b.slice(0, end).split("\n").filter((l) => !/snapshot\.tar\.gz/.test(l) && !/^Nothing was landed\.?$/.test(l.trim())).join("\n").replace(/\n{3,}/g, "\n\n").trim();
+      return { kind: "conflict", final: true, pid: s.id, tip, overlaps };
+    }
+    case "objected": {
+      const lastRound = s.rest === "final" || /the last one/.test(b) || /round 3 of 3/.test(b);
+      const round = Number(/round (\d+) of \d+/.exec(b)?.[1] ?? 0) || void 0;
+      let who = "the reviewer";
+      const owner = /^(\S+@\S+) wrote lines that push/m.exec(b)?.[1];
+      const standing = /the objection of (.+?) still stands/s.exec(b)?.[1];
+      const reviewer = /^The reviewer of (\S+) objected/m.exec(b);
+      if (owner) who = `line owner ${owner}`;
+      else if (standing) who = `line owner${standing.includes(",") ? "s" : ""} ${standing.replace(/\s+/g, " ")}`;
+      else if (reviewer) who = "the reviewer";
+      const blocks = quotedBlocks(b);
+      const reason = blocks.length > 1 && standing ? blocks.map((x) => `${x.label}: ${x.text}`).join("\n") : blocks[0]?.text ?? "";
+      return { kind: "objected", final: true, pid: s.id, round, lastRound: lastRound || s.rest === "final", who, reason: s.rest === "final" && !reason ? "the review is closed after round 3" : reason };
+    }
+    case "rejected":
+      return { kind: "rejected", final: true, pid: s.id, reason: /^Reason: (.*)$/m.exec(b)?.[1] ?? oneLineOf(b) };
+    case "vetoed":
+      return { kind: "vetoed", final: true, pid: s.id, who: /, (\S+@\S+), vetoed push/.exec(b)?.[1], reason: quotedBlock(b) };
+    case "check-failed":
+      return { kind: "check-failed", final: true, pid: s.id, who: /checker of \S+, (\S+@\S+), reported/.exec(b)?.[1], reason: quotedBlock(b) };
+    case "escalated":
+      return { kind: "escalated", final: true, pid: s.id, who: /the objection of (.+?) still stands/s.exec(b)?.[1]?.replace(/\s+/g, " ") };
+    case "not-allowed":
+      return { kind: "not-allowed", final: true, reason: oneLineOf(b) };
+    case "stuck":
+      return { kind: "stuck", final: false, pid: s.id, reason: /^It is waiting on: (.*)$/m.exec(b)?.[1] };
+    default:
+      return { kind: "other", final: false, pid: s.id };
+  }
+}
+function oneLineOf(b) {
+  return b.split("\n").find((l) => l.trim())?.trim() ?? "";
+}
+var ACTION_KINDS = {
+  consent: 'a line owner ask: read it with map show <pid>, then map approve <pid> or map object <pid> "<reason>"',
+  objected: 'your push was objected to: read why with map show <pid>, then map argue <pid> "<why>", or change the files and map send again',
+  escalated: 'escalated to the repo owners: owners run map approve <pid> or map veto <pid> "<reason>"',
+  pending: 'owner review window: map veto <pid> "<reason>" to stop it, map approve <pid> to land it now',
+  confirm: "a confirmation request: reply confirm to accept (see the mail)"
+};
+var VERDICT_KINDS = /* @__PURE__ */ new Set(["landed", "conflict", "rejected", "vetoed", "check-failed", "stuck", "too-late", "not-allowed", "confirmed"]);
+function inboxItem(m) {
+  const s = parseSubject(m.subject);
+  if (!s) return null;
+  const ref = s.kind === "confirm" || s.kind === "confirmed" ? null : s.kind === "event" ? s.ref ?? null : s.id ?? null;
+  const base = { id: m.id, kind: s.kind, pid: ref, repo: m.sender, subject: m.subject, at: m.received_at };
+  if (s.kind in ACTION_KINDS) {
+    const final = s.kind === "objected" && s.rest === "final";
+    const replied = m.awaiting === "them";
+    if (final) return { ...base, action: false, hint: "objected, final: change the files and map send again, or ask a repo owner" };
+    return { ...base, action: !replied, hint: replied ? "you already replied" : ACTION_KINDS[s.kind] };
+  }
+  if (VERDICT_KINDS.has(s.kind)) return { ...base, action: false, hint: s.kind === "landed" ? "landed: map update to get it" : s.kind };
+  return null;
+}
+
+// src/actions.ts
+async function mapMail(mail, o = {}) {
+  const out = [];
+  let cursor;
+  for (let i = 0; i < (o.pages ?? 3); i++) {
+    const r = await mail.list({ limit: 100, cursor });
+    for (const m of r.data) if (isRepoAddress(m.sender) && (!o.repo || m.sender === o.repo) && parseSubject(m.subject)) out.push(m);
+    if (!r.cursor || !r.data.length) break;
+    cursor = r.cursor;
+  }
+  return out;
+}
+function inboxItems(ms, o = {}) {
+  const items = [];
+  for (const m of ms) {
+    const it = inboxItem(m);
+    if (!it) continue;
+    if (!o.all && !it.action) {
+      const t = Date.parse(it.at);
+      if (!(t >= (o.sinceMs ?? Date.now() - 24 * 36e5))) continue;
+    }
+    items.push(it);
+  }
+  return items;
+}
+async function waitInbox(mail, timeoutSec, repo, since) {
+  const until = Date.now() + timeoutSec * 1e3;
+  let cursor;
+  const from = since ?? (/* @__PURE__ */ new Date()).toISOString();
+  for (; ; ) {
+    const left = Math.round((until - Date.now()) / 1e3);
+    if (left <= 0) return [];
+    const r = await mail.tail({ cursor, from, limit: 100, wait: Math.min(30, Math.max(1, left)) });
+    cursor = r.cursor;
+    const fresh = r.data.filter((m) => isRepoAddress(m.sender) && (!repo || m.sender === repo));
+    const items = fresh.map(inboxItem).filter((x) => !!x && (x.action || x.kind !== "stuck"));
+    if (items.length) return items;
+  }
+}
+var TARGETS = {
+  approve: ["consent", "escalated", "pending", "objected", "conflict", "stuck", "check-failed", "vetoed", "received"],
+  object: ["consent"],
+  argue: ["objected"],
+  veto: ["escalated", "pending", "consent", "objected", "stuck", "check-failed", "received"]
+};
+function pickTarget(action, pid, ms) {
+  const mine = ms.filter((m) => parseSubject(m.subject)?.id === pid);
+  if (!mine.length) {
+    throw new MapError2(`no map mail about ${pid} in your mailbox. Check the push id (map inbox lists them) and that you are using the address map wrote to.`);
+  }
+  for (const kind of TARGETS[action]) {
+    const hit = mine.find((m) => parseSubject(m.subject)?.kind === kind);
+    if (!hit) continue;
+    if (action === "argue" && parseSubject(hit.subject)?.rest === "final") {
+      throw new MapError2(`${pid} was objected to in the last round: arguing will not reopen it. Change the files and map send again, or ask a repo owner to approve it.`);
+    }
+    return hit;
+  }
+  const kinds = [...new Set(mine.map((m) => parseSubject(m.subject)?.kind))].join(", ");
+  if (action === "object") throw new MapError2(`map did not ask you to consent to ${pid} (you have: ${kinds}). Only line owners asked for consent can object; repo owners use map veto.`);
+  if (action === "argue") throw new MapError2(`${pid} has no objection to argue with in your mailbox (you have: ${kinds}).`);
+  throw new MapError2(`no map mail about ${pid} that ${action} can answer (you have: ${kinds}).`);
+}
+var WORDS = /^(approve[sd]?|object(s|ed|ion)?|veto(ed|es)?|confirm(ed)?)\b/i;
+function actionBody(action, text2, pid) {
+  const t = text2.trim();
+  switch (action) {
+    case "approve":
+      return `approve${t ? ` ${t}` : ""}
+`;
+    case "object":
+      if (!t) throw new MapError2('say why you object: map object <pid> "<reason>"');
+      return `object: ${t}
+`;
+    case "veto":
+      return `veto${t ? ` ${t}` : ""}
+`;
+    case "argue": {
+      if (!t) throw new MapError2('give your argument: map argue <pid> "<why the objection is wrong>"');
+      const first = t.split("\n").find((l) => l.trim() && !l.trimStart().startsWith(">")) ?? "";
+      return WORDS.test(first.trim()) ? `Argument for ${pid}:
+
+${t}
+` : `${t}
+`;
+    }
+  }
+}
+
+// src/args.ts
+var BOOLEAN = /* @__PURE__ */ new Set(["json", "wait", "all", "help", "h", "no-wait", "version", "yes", "y", "no-skill", "force", "strict"]);
+var VALUE = /* @__PURE__ */ new Set(["from", "repo", "n", "timeout", "bin-dir", "o", "output", "depth", "body-file", "since", "handle", "allow", "host", "adapter", "a", "b", "repo-host", "out", "provider", "seconds", "skills-home", "commit"]);
+var ALIAS = { h: "help", o: "output", y: "yes" };
+function parseArgs(argv) {
+  const pos = [];
+  const flags = {};
+  let ended = false;
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (ended || a === "-" || !a.startsWith("-")) {
+      pos.push(a);
+      continue;
+    }
+    if (a === "--") {
+      ended = true;
+      continue;
+    }
+    const m = /^--?([A-Za-z][A-Za-z-]*)(?:=(.*))?$/s.exec(a);
+    if (!m) {
+      pos.push(a);
+      continue;
+    }
+    const raw = m[1];
+    const key = ALIAS[raw] ?? raw;
+    if (BOOLEAN.has(raw)) {
+      if (m[2] !== void 0) throw new MapError2(`--${raw} takes no value`);
+      flags[key] = true;
+    } else if (VALUE.has(raw)) {
+      const v = m[2] ?? argv[++i];
+      if (v === void 0) throw new MapError2(`--${raw} needs a value`);
+      flags[key] = v;
+    } else {
+      throw new MapError2(`unknown option ${a} (see map help)`);
+    }
+  }
+  const cmd = pos.shift() ?? "";
+  return { cmd, pos, flags };
+}
+function str(p, key) {
+  const v = p.flags[key];
+  return typeof v === "string" ? v : void 0;
+}
+function num(p, key, dflt2) {
+  const v = str(p, key);
+  if (v === void 0) return dflt2;
+  const n = Number(v);
+  if (!Number.isInteger(n) || n <= 0) throw new MapError2(`--${key} must be a positive whole number`);
+  return n;
+}
+function bool(p, key) {
+  return p.flags[key] === true;
+}
+var PID = /^p-[0-9a-f]{8}$/;
+var CID = /^c\d+(?:-[0-9a-f]{8})?$/;
+function pidArg(s) {
+  const v = (s ?? "").trim().toLowerCase();
+  if (!PID.test(v)) throw new MapError2(`"${s ?? ""}" is not a push id (like p-1a2b3c4d)`);
+  return v;
+}
+
+// src/conformance.ts
+import { randomBytes as randomBytes2 } from "node:crypto";
+import { existsSync as existsSync2, mkdirSync as mkdirSync3, mkdtempSync as mkdtempSync3, readdirSync as readdirSync2, readFileSync as readFileSync4, realpathSync, renameSync, statSync, writeFileSync as writeFileSync4 } from "node:fs";
+import { tmpdir as tmpdir3 } from "node:os";
+import { isAbsolute, join as join6, resolve as resolve2 } from "node:path";
+import { fileURLToPath } from "node:url";
+import { crc32, deflateSync } from "node:zlib";
+var CONFORMANCE_VERSION = "1";
+var Skip = class extends Error {
+};
+var sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+function png() {
+  const chunk = (type, data) => {
+    const len = Buffer.alloc(4);
+    len.writeUInt32BE(data.length);
+    const td2 = Buffer.concat([Buffer.from(type, "ascii"), data]);
+    const crc2 = Buffer.alloc(4);
+    crc2.writeUInt32BE(crc32(td2) >>> 0);
+    return Buffer.concat([len, td2, crc2]);
+  };
+  const w = 8;
+  const h = 8;
+  const ihdr = Buffer.alloc(13);
+  ihdr.writeUInt32BE(w, 0);
+  ihdr.writeUInt32BE(h, 4);
+  ihdr[8] = 8;
+  ihdr[9] = 6;
+  const rows = [];
+  for (let y = 0; y < h; y++) rows.push(Buffer.concat([Buffer.from([0]), randomBytes2(w * 4)]));
+  const sig = Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]);
+  return new Uint8Array(Buffer.concat([sig, chunk("IHDR", ihdr), chunk("IDAT", deflateSync(Buffer.concat(rows))), chunk("IEND", Buffer.alloc(0))]));
+}
+function listFiles(dir, rel = "") {
+  const out = [];
+  for (const n of readdirSync2(join6(dir, rel)).sort()) {
+    const r = rel ? `${rel}/${n}` : n;
+    if (r === ".map" || r === ".gud") continue;
+    if (statSync(join6(dir, r)).isDirectory()) out.push(...listFiles(dir, r));
+    else out.push(r);
+  }
+  return out;
+}
+function equalBytes(a, b) {
+  return a.length === b.length && Buffer.compare(Buffer.from(a), Buffer.from(b)) === 0;
+}
+async function runConformance(o) {
+  const log2 = o.log ?? ((s) => say(s));
+  const adapterRef = /[\\/]|\.m?js$/.test(o.adapter) ? resolve2(o.adapter) : o.adapter;
+  process.env.MAP_TRANSPORT = adapterRef;
+  const t = await loadTransport(adapterRef);
+  const desc = await t.describe?.().catch(() => null) ?? { provider: t.name };
+  const A = new Mail(o.a, t);
+  const B = new Mail(o.b, t);
+  const tag = randomBytes2(3).toString("hex");
+  const work = mkdtempSync3(join6(tmpdir3(), `map-conformance-${tag}-`));
+  const checks = [];
+  const report = {
+    suite: `map transport conformance v${CONFORMANCE_VERSION}`,
+    adapter: t.name,
+    provider: desc.provider,
+    providerVersion: desc.version ?? "unknown",
+    mapCli: o.cliVersion,
+    node: process.version,
+    date: (/* @__PURE__ */ new Date()).toISOString(),
+    a: o.a,
+    b: o.b,
+    repo: o.repo ?? null,
+    checks,
+    passed: false
+  };
+  const check = async (id, part, name, fn, needs) => {
+    const missing = needs?.();
+    if (missing) {
+      checks.push({ id, part, name, status: "SKIP", seconds: 0, reason: missing });
+      log2(`SKIP ${id} ${name}: ${missing}`);
+      return false;
+    }
+    log2(`.... ${id} ${name}`);
+    const t0 = Date.now();
+    try {
+      const reason = await fn();
+      checks.push({ id, part, name, status: "PASS", seconds: (Date.now() - t0) / 1e3, reason });
+      log2(`PASS ${id} ${name}: ${reason}`);
+      return true;
+    } catch (e) {
+      const skip = e instanceof Skip;
+      const reason = e.message.split("\n")[0].slice(0, 300);
+      checks.push({ id, part, name, status: skip ? "SKIP" : "FAIL", seconds: (Date.now() - t0) / 1e3, reason });
+      log2(`${skip ? "SKIP" : "FAIL"} ${id} ${name}: ${reason}`);
+      return false;
+    }
+  };
+  const fail = (m) => {
+    throw new Error(m);
+  };
+  const inbound = async (box, subject, timeoutSec = 120) => {
+    const until = Date.now() + timeoutSec * 1e3;
+    for (; ; ) {
+      const { data } = await box.list({ limit: 50 });
+      const hit = data.find((m) => m.subject === subject);
+      if (hit) return hit;
+      if (Date.now() > until) fail(`"${subject}" did not reach ${box.me} within ${timeoutSec} s`);
+      await sleep(2e3);
+    }
+  };
+  const P1 = "1. Interface";
+  const start = new Date(Date.now() - 2e3).toISOString();
+  await check("1.1", P1, "send returns a stable id", async () => {
+    const s1 = `map conformance ${tag} send 1`;
+    const s2 = `map conformance ${tag} send 2`;
+    const id1 = await A.send({ to: o.b, subject: s1, body: "first\n" });
+    const id2 = await A.send({ to: o.b, subject: s2, body: "second\n" });
+    if (typeof id1 !== "string" || !id1 || typeof id2 !== "string" || !id2) fail("send did not return an id");
+    if (id1 === id2) fail(`two sends returned the same id ${id1}`);
+    await inbound(B, s1);
+    await inbound(B, s2);
+    return `two sends gave distinct ids (${id1.slice(0, 8)}..., ${id2.slice(0, 8)}...), both delivered to B; 1.3 waits on such an id`;
+  });
+  await check("1.2", P1, "an attachment round-trips byte for byte with its filename", async () => {
+    const bytes = new Uint8Array(Buffer.concat([Buffer.from([0, 255, 13, 10, 31, 139]), randomBytes2(4090)]));
+    const name = "conformance-blob.bin";
+    const dir = join6(work, "attach");
+    mkdirSync3(dir, { recursive: true });
+    writeFileSync4(join6(dir, name), bytes);
+    const subject = `map conformance ${tag} attachment`;
+    await A.send({ to: o.b, subject, body: "binary attached\n", attachment: join6(dir, name) });
+    const m = await inbound(B, subject);
+    const d = await B.get(m.id);
+    const att = d.attachments.find((x) => x.filename === name);
+    if (!att) fail(`B sees attachments [${d.attachments.map((x) => x.filename).join(", ")}], not ${name}`);
+    const got = await B.download(d.id, att.part_index, join6(dir, "received.bin"));
+    if (!equalBytes(got, bytes)) fail(`B read ${got.length} bytes that differ from the ${bytes.length} sent`);
+    return `${bytes.length} random bytes (with NUL, 0xff, CRLF) arrived as ${name}, identical`;
+  });
+  let threadA = null;
+  await check("1.3", P1, "waitReply returns each reply once, in order, including one that came before the wait", async () => {
+    const subject = `map conformance ${tag} replies`;
+    const sent = await A.send({ to: o.b, subject, body: "reply twice please\n" });
+    const m = await inbound(B, subject);
+    await B.reply(m.id, `reply one ${tag}
+`);
+    await sleep(1500);
+    await B.reply(m.id, `reply two ${tag}
+`);
+    const until = Date.now() + 12e4;
+    for (; ; ) {
+      const { data } = await A.list({ after: start, limit: 50 });
+      if (data.filter((x) => x.sender === o.b && x.subject.includes(`${tag} replies`)).length >= 2) break;
+      if (Date.now() > until) fail("B's two replies did not reach A within 120 s");
+      await sleep(2e3);
+    }
+    const r1 = await A.waitReply(sent, o.b, { timeoutSec: 60 });
+    if (!r1) fail("the first wait found no reply");
+    const r2 = await A.waitReply(sent, o.b, { timeoutSec: 60, since: after(r1.received_at) });
+    if (!r2) fail("the second wait found no second reply");
+    const r3 = await A.waitReply(sent, o.b, { timeoutSec: 5, since: after(r2.received_at) });
+    if (r3) fail(`a third wait returned ${r3.id}, a reply already seen or one never sent`);
+    if (r1.id === r2.id) fail("both waits returned the same reply");
+    const b1 = (await A.get(r1.id)).body_text;
+    const b2 = (await A.get(r2.id)).body_text;
+    if (!b1.includes(`reply one ${tag}`) || !b2.includes(`reply two ${tag}`)) fail("the replies came back out of order");
+    threadA = { sent, copyB: m.id, first: r1 };
+    return "reply one, then reply two, then a timeout; both were already delivered when the waits began";
+  });
+  await check(
+    "1.4",
+    P1,
+    "a reply threads to the message it answers",
+    async () => {
+      const original = await B.get(threadA.copyB);
+      const reply = await A.get(threadA.first.id);
+      if (!original.message_id) fail("the adapter does not report Message-ID, so threading cannot be checked");
+      if (!reply.in_reply_to) fail("the adapter does not report In-Reply-To");
+      const irt = reply.in_reply_to.map((x) => x.trim());
+      if (!irt.includes(original.message_id.trim())) fail(`In-Reply-To is ${irt.join(" ")}, not ${original.message_id}`);
+      if (reply.references && !reply.references.map((x) => x.trim()).includes(original.message_id.trim())) fail("References does not name the original");
+      return `In-Reply-To and References name ${original.message_id}; 2.4 and 2.5 show map matching such replies to their push`;
+    },
+    () => threadA ? null : "needs 1.3"
+  );
+  await check("1.5", P1, "the inbox (list and tail) holds only mail to my own address", async () => {
+    const lists = [
+      ["list A", (await A.list({ after: start, limit: 100 })).data],
+      ["tail A", (await A.tail({ from: start, limit: 100 })).data],
+      ["list B", (await B.list({ after: start, limit: 100 })).data]
+    ];
+    for (const [what, rows] of lists) {
+      const me = what.endsWith("A") ? o.a : o.b;
+      if (!rows.length) fail(`${what} is empty, though mail was delivered`);
+      const missing = rows.filter((r) => !r.recipient);
+      if (missing.length) fail(`${what}: the adapter does not report recipients`);
+      const other = rows.find((r) => r.recipient !== me);
+      if (other) fail(`${what} holds mail to ${other.recipient}`);
+    }
+    if (lists[0][1].some((r) => /send 1$/.test(r.subject))) fail("A's inbox shows the mail A sent to B");
+    return `${lists.map(([w, r]) => `${w}: ${r.length}`).join(", ")}; every row is to its own address`;
+  });
+  await check("1.6", P1, "a wait that times out is a timeout, not an error", async () => {
+    const sent = await A.send({ to: o.b, subject: `map conformance ${tag} nobody answers`, body: "no reply expected\n" });
+    const t0 = Date.now();
+    const r = await A.waitReply(sent, o.b, { timeoutSec: 5 });
+    if (r) fail(`the wait returned ${r.id}`);
+    return `waitReply returned null after ${((Date.now() - t0) / 1e3).toFixed(1)} s with a 5 s timeout`;
+  });
+  await check("1.7", P1, "search finds mail by its words, only in my own mailbox", async () => {
+    const word = `zq${tag}word`;
+    const subject = `map conformance ${tag} search`;
+    await A.send({ to: o.b, subject, body: `The marker ${word} is in this body.
+` });
+    const m = await inbound(B, subject);
+    const t0 = Date.now();
+    let hits = [];
+    let command = "";
+    for (; ; ) {
+      const r = await t.search({ me: o.b, q: word, to: o.b, limit: 10 });
+      hits = r.data;
+      command = r.command ?? "";
+      if (hits.length || Date.now() - t0 > 6e4) break;
+      await sleep(3e3);
+    }
+    if (!hits.some((h) => h.id === m.id)) fail(`a search for ${word} did not return B's mail`);
+    if (hits.some((h) => h.recipient && h.recipient !== o.b)) fail("the search returned mail to another address");
+    const bySubject = await t.search({ me: o.b, subject: `${tag} search`, to: o.b, limit: 10 });
+    if (!bySubject.data.some((h) => h.id === m.id)) fail("a subject search did not return it");
+    return `found by a body word and by subject${command ? ` (${command.slice(0, 80)})` : ""}`;
+  });
+  const P2 = "2. Flow";
+  const self = realpathSync(fileURLToPath(import.meta.url));
+  const bin2 = join6(work, "bin");
+  mkdirSync3(bin2);
+  writeFileSync4(join6(bin2, "map"), `#!/bin/sh
+exec "${process.execPath}" "${self}" "$@"
+`, { mode: 493 });
+  const baseEnv = { ...process.env, PATH: `${bin2}:${process.env.PATH}`, MAP_WAIT_SECONDS: "900" };
+  delete baseEnv.MAP_NO_WAIT;
+  const sh = async (who, cwd, cmd, ...args) => {
+    const r = await run2(cmd, args, { cwd, env: { ...baseEnv, MAP_FROM: who } });
+    return { code: r.code, out: r.out, err: r.err, all: `${r.out}
+${r.err}` };
+  };
+  const must = async (who, cwd, cmd, ...args) => {
+    const r = await sh(who, cwd, cmd, ...args);
+    if (r.code !== 0) fail(`${cmd} ${args.join(" ")} failed: ${r.all.trim().split("\n").slice(-3).join(" / ")}`);
+    return r;
+  };
+  const landed = (all) => /LANDED (p-[0-9a-f]{8}) as (c\d+-[0-9a-f]{8})/.exec(all);
+  const sendLanded = async (who, cwd, subject) => {
+    const r = await sh(who, cwd, "map", "send", subject);
+    const m = landed(r.all);
+    if (r.code !== 0 || !m) fail(`map send did not land: ${r.all.trim().split("\n").filter((l) => l.startsWith("map:")).slice(-3).join(" / ")}`);
+    return { pid: m[1], cid: m[2] };
+  };
+  const caughtUp = async (who, cwd) => {
+    await must(who, cwd, "map", "update");
+    const d = await must(who, cwd, "map", "diff");
+    if (d.out.trim()) fail(`map diff still shows changes after map update: ${d.out.slice(0, 120)}`);
+  };
+  const da = join6(work, "a");
+  const db = join6(work, "b");
+  let repo = o.repo ?? "";
+  await check("2.0", P2, "create a test repo by email (B owns it, A may push)", async () => {
+    if (o.repo) return `using the given repo ${o.repo} (B must own it and A must be allowed)`;
+    const name = `conf${tag}`;
+    const args = ["create", name, "--allow", o.a, "--host", o.host, "--json"];
+    if (o.handle) args.push("--handle", o.handle);
+    else args.push("--handle", `gc${randomBytes2(3).toString("hex")}`);
+    const r = await must(o.b, work, "map", ...args);
+    repo = JSON.parse(r.out).address;
+    report.repo = repo;
+    return `created ${repo} through new@${o.host}`;
+  });
+  const needRepo = () => repo ? null : "needs a repo (2.0)";
+  let notes = "";
+  const ok21 = await check(
+    "2.1",
+    P2,
+    "A gets the code, edits, sends: landed; map update leaves nothing to send",
+    async () => {
+      await must(o.a, work, "map", "get", repo, "a");
+      notes = ["line one by A", "line two by A", "line three by A", "line four by A", "line five by A", ""].join("\n");
+      mkdirSync3(join6(da, "docs"), { recursive: true });
+      writeFileSync4(join6(da, "notes.txt"), notes);
+      writeFileSync4(join6(da, "docs", "old.md"), "# Notes\n\nThis file is renamed by check 2.3.\n");
+      const l = await sendLanded(o.a, da, "Add notes and docs");
+      await caughtUp(o.a, da);
+      return `landed ${l.pid} as ${l.cid}; after map update, map diff is empty`;
+    },
+    needRepo
+  );
+  const ok22 = await check(
+    "2.2",
+    P2,
+    "B sends a stale change: conflict; map update marks the overlap; resolved and sent: landed",
+    async () => {
+      await must(o.b, work, "map", "get", repo, "b");
+      writeFileSync4(join6(da, "notes.txt"), notes.replace("line one by A", "line one, edited by A"));
+      await sendLanded(o.a, da, "Edit line one");
+      await caughtUp(o.a, da);
+      writeFileSync4(join6(db, "notes.txt"), notes.replace("line one by A", "line one, edited by B"));
+      const c = await sh(o.b, db, "map", "send", "Edit line one differently");
+      if (c.code !== 1 || !/CONFLICT on (p-[0-9a-f]{8})/.test(c.all) || !c.all.includes("notes.txt")) fail(`expected a conflict naming notes.txt, got exit ${c.code}`);
+      const pid = /CONFLICT on (p-[0-9a-f]{8})/.exec(c.all)[1];
+      const u = await sh(o.b, db, "map", "update");
+      const marked = readFileSync4(join6(db, "notes.txt"), "utf8");
+      if (u.code === 0 || !/^<<<<<<< /m.test(marked) || !marked.includes("line one, edited by A") || !marked.includes("line one, edited by B")) fail("map update did not mark the overlap in notes.txt");
+      notes = notes.replace("line one by A", "line one, edited by A and B");
+      writeFileSync4(join6(db, "notes.txt"), notes);
+      const l = await sendLanded(o.b, db, "Edit line one, merged");
+      await caughtUp(o.b, db);
+      return `${pid} got a conflict naming notes.txt; map update wrote markers; after resolving, ${l.pid} landed as ${l.cid}`;
+    },
+    () => needRepo() ?? (ok21 ? null : "needs 2.1")
+  );
+  const pixel = png();
+  await check(
+    "2.3",
+    P2,
+    "a binary file and a rename land byte for byte (checked in a fresh map get)",
+    async () => {
+      await must(o.a, da, "map", "update");
+      mkdirSync3(join6(da, "assets"), { recursive: true });
+      writeFileSync4(join6(da, "assets", "pixel.png"), pixel);
+      renameSync(join6(da, "docs", "old.md"), join6(da, "docs", "new.md"));
+      const l = await sendLanded(o.a, da, "Add a pixel and rename the docs");
+      await caughtUp(o.a, da);
+      await must(o.a, work, "map", "get", repo, "c");
+      const dc = join6(work, "c");
+      if (!equalBytes(new Uint8Array(readFileSync4(join6(dc, "assets", "pixel.png"))), pixel)) fail("assets/pixel.png differs in the fresh copy");
+      if (existsSync2(join6(dc, "docs", "old.md")) || !existsSync2(join6(dc, "docs", "new.md"))) fail("the rename did not land");
+      const files = listFiles(da);
+      if (files.join() !== listFiles(dc).join()) fail("A's folder and a fresh copy hold different files");
+      for (const f of files) if (!equalBytes(new Uint8Array(readFileSync4(join6(da, f))), new Uint8Array(readFileSync4(join6(dc, f))))) fail(`${f} differs between A's folder and a fresh copy`);
+      return `${l.pid} landed as ${l.cid}; a fresh map get has the same ${files.length} files byte for byte (pixel.png ${pixel.length} bytes)`;
+    },
+    () => needRepo() ?? (ok22 ? null : "needs 2.2")
+  );
+  const window = Math.max(5, o.consentWindow ?? 5);
+  const consentOn = await check(
+    "2.4a",
+    P2,
+    `B, the owner, turns on line owner consent (${window} min window) with map settings`,
+    async () => {
+      const r = await must(o.b, db, "map", "settings", repo, "Map-Consent: owners", `Map-Consent-Window: ${window}`);
+      if (!/Line owner consent:\s*\n\s*owners/.test(r.out)) fail(`the settings ack does not show consent on: ${r.out.slice(0, 200)}`);
+      return "the settings ack shows line owner consent: owners";
+    },
+    () => needRepo() ?? (ok22 ? null : "needs 2.2")
+  );
+  const consentAsk = async (seen, round, timeoutSec = 900) => {
+    const until = Date.now() + timeoutSec * 1e3;
+    for (; ; ) {
+      const r = await sh(o.a, da, "map", "inbox", "--json", "--repo", repo);
+      if (r.code === 0) {
+        const items = JSON.parse(r.out).items;
+        const hit = items.find((i) => i.kind === "consent" && i.action && !seen.includes(i.pid) && (!round || parseSubject(i.subject)?.fields.round === round));
+        if (hit) return { pid: hit.pid, id: hit.id };
+      }
+      if (Date.now() > until) fail(`no consent ask reached A within ${timeoutSec} s`);
+      await sleep(5e3);
+    }
+  };
+  let firstAsk = "";
+  const ok24 = await check(
+    "2.4",
+    P2,
+    "B changes a line A wrote: A gets a consent ask, and map approve lands it",
+    async () => {
+      await must(o.b, db, "map", "update");
+      notes = notes.replace("line three by A", "line three, edited by B");
+      writeFileSync4(join6(db, "notes.txt"), notes);
+      const send = sh(o.b, db, "map", "send", "Edit line three");
+      const ask = await consentAsk([]);
+      firstAsk = ask.pid;
+      await must(o.a, da, "map", "approve", ask.pid, "--repo", repo);
+      const r = await send;
+      const l = landed(r.all);
+      if (r.code !== 0 || !l) fail(`B's send did not land after the approve: exit ${r.code}`);
+      if (l[1] !== ask.pid) fail(`A was asked about ${ask.pid} but ${l[1]} landed`);
+      await caughtUp(o.b, db);
+      return `A got [map consent ${ask.pid}]; map approve landed it as ${l[2]}`;
+    },
+    () => consentOn ? null : "needs 2.4a"
+  );
+  let objected = "";
+  await check(
+    "2.5",
+    P2,
+    "A objects to a later B change with map object, B argues with map argue, the argument reaches that push",
+    async () => {
+      notes = notes.replace("line four by A", "line four, edited by B");
+      writeFileSync4(join6(db, "notes.txt"), notes);
+      const send = sh(o.b, db, "map", "send", "Edit line four");
+      const ask = await consentAsk([firstAsk]);
+      await must(o.a, da, "map", "object", ask.pid, `conformance objection ${tag}`, "--repo", repo);
+      const r = await send;
+      if (r.code !== 1 || !r.all.includes(`OBJECTED: line owner ${o.a} objected to ${ask.pid}`)) fail(`B's send did not report A's objection: exit ${r.code}`);
+      if (!r.all.includes(`conformance objection ${tag}`)) fail("B's send did not show A's reason");
+      const argument = `conformance argument ${tag}: line four reads better this way`;
+      await must(o.b, db, "map", "argue", ask.pid, argument, "--repo", repo);
+      const again = await consentAsk([], "2");
+      if (again.pid !== ask.pid) fail(`the round 2 ask is about ${again.pid}, not ${ask.pid}`);
+      const body = (await A.get(again.id)).body_text;
+      if (!body.includes(`conformance argument ${tag}`)) fail("the round 2 ask does not quote B's argument");
+      objected = ask.pid;
+      await must(o.a, da, "map", "approve", ask.pid, "--repo", repo);
+      const w = await sh(o.b, db, "map", "wait", ask.pid, "--seconds", "600");
+      if (w.code !== 0 || !landed(w.all)) fail(`map wait did not return the landing after A's approve: exit ${w.code}`);
+      return `B saw A's objection to ${ask.pid}; B's argument came back to A in [map consent ${ask.pid}] round=2; after A's approve, map wait returned LANDED`;
+    },
+    () => ok24 ? null : "needs 2.4"
+  );
+  await check(
+    "2.6",
+    P2,
+    "history is mail: map history finds the objection, map log lists the commits",
+    async () => {
+      const h = await must(o.b, db, "map", "history", `conformance objection ${tag}`, "--json");
+      const items = JSON.parse(h.out).items;
+      if (!items.some((i) => i.kind === "objected" && i.what.includes(objected))) fail(`map history did not find the objected mail about ${objected}`);
+      const lg = await must(o.a, da, "map", "log", "--json", "-n", "20");
+      const j = JSON.parse(lg.out);
+      if (j.entries.length < 5) fail(`map log listed ${j.entries.length} commits, expected at least 5`);
+      return `history found [map objected ${objected}] by searching B's mailbox; log listed ${j.entries.length} commits (${j.source === "mailbox" ? "from commit mail in this account" : "from the repo's reply to a Map-Log mail"})`;
+    },
+    () => objected ? null : "needs 2.5"
+  );
+  const P3 = "3. Security";
+  await check(
+    "3.1",
+    P3,
+    "a From display name naming the owner (B) does not make A an owner",
+    async () => {
+      const rule = `*@forged-${tag}.example`;
+      const subject = `map conformance ${tag} forged settings`;
+      const body = `Map-Allow: ${rule}
+`;
+      await A.send({ fromName: o.b, to: o.b, subject, body });
+      const copy = await B.get((await inbound(B, subject)).id);
+      const shown2 = copy.from_header ? `From: ${copy.from_header}` : "the adapter does not report the From header";
+      if (copy.from_header && !copy.from_header.includes(o.b)) throw new Skip(`the adapter did not send the display name (${shown2})`);
+      const sentAt = new Date(Date.now() - 2e3).toISOString();
+      await A.send({ fromName: o.b, to: repo, subject, body });
+      await sleep(45e3);
+      const s = await must(o.b, db, "map", "settings", repo);
+      if (!/Contributor rules:/.test(s.out)) fail("the owner could not read the settings to compare");
+      if (s.out.includes(rule)) fail(`the repo applied ${rule} from the forged mail`);
+      const answers = (await A.list({ after: sentAt, limit: 50 })).data.filter((m) => m.sender === repo && m.subject.endsWith(subject));
+      const ack = answers.length ? (await A.get(answers[0].id)).body_text : "";
+      if (/settings of .* changed\./.test(ack)) fail("the repo acknowledged the forged settings as an owner's");
+      return `${shown2}; ${rule} was not applied (${answers.length ? "A was answered as a non-owner" : "the mail was dropped"})`;
+    },
+    () => needRepo() ?? (ok22 ? null : "needs 2.2")
+  );
+  report.passed = checks.every((c) => c.status === "PASS");
+  return report;
+}
+function markdown(r) {
+  const rows = r.checks.map((c) => `| ${c.id} | ${c.name} | ${c.status} | ${c.seconds.toFixed(1)} s | ${c.reason.replace(/\|/g, "\\|")} |`);
+  const counts = (s) => r.checks.filter((c) => c.status === s).length;
+  return `# map transport conformance: ${r.adapter}
+
+- Suite: ${r.suite}
+- Adapter: \`${r.adapter}\`
+- Provider: ${r.provider}, version ${r.providerVersion}
+- map CLI: ${r.mapCli}; Node ${r.node}
+- Date: ${r.date}
+- Mailboxes: A ${r.a}, B ${r.b}
+- Repo: ${r.repo ?? "(none)"}
+- Result: ${r.passed ? "PASS" : "FAIL"} (${counts("PASS")} passed, ${counts("FAIL")} failed, ${counts("SKIP")} skipped)
+
+| # | Check | Result | Time | Reason |
+| --- | --- | --- | --- | --- |
+${rows.join("\n")}
+`;
+}
+async function conformanceMain(argv, cliVersion) {
+  const s = (k) => typeof argv.flags[k] === "string" ? argv.flags[k] : void 0;
+  if (argv.pos[0] !== "transport") throw new MapError2("usage: map-conformance transport --adapter <primitive|path> --a <address> --b <address> [--repo-host map.dev] [--repo <address>] [--json] [--out <file>]");
+  const adapter = s("adapter") ?? "primitive";
+  const a = s("a")?.toLowerCase();
+  const b = s("b")?.toLowerCase();
+  if (!a || !b || a === b) throw new MapError2("give two different mailboxes the adapter can send from: --a <address> --b <address>");
+  const r = await runConformance({
+    adapter,
+    a,
+    b,
+    host: s("repo-host") ?? defaultHost(),
+    repo: s("repo"),
+    handle: s("handle"),
+    cliVersion,
+    log: argv.flags.json ? (x) => process.stderr.write(`${x}
+`) : void 0
+  });
+  const md = markdown(r);
+  const out = s("out");
+  if (out) writeFileSync4(isAbsolute(out) ? out : resolve2(out), argv.flags.json ? `${JSON.stringify(r, null, 2)}
+` : md);
+  process.stdout.write(argv.flags.json ? `${JSON.stringify(r, null, 2)}
+` : `
+${md}`);
+  return r.passed ? 0 : 1;
+}
+
+// src/history.ts
+var sentVisible = false;
+var SENT_VISIBLE_NOTE = "Search covers mail you received and mail you sent. It sees the repo's own mail (commit log, reviews, verdicts to others) only from the account that hosts the repo.";
+var NOT_VISIBLE = "Search reads inbound mail only. It cannot see mail you sent (your changes, arguments and replies) unless the repo copied it back to you, and it sees the repo's own mail (commit log, reviews, verdicts to others) only from the account that hosts the repo.";
+var NOISE = /* @__PURE__ */ new Set(["log", "snapshot", "status", "settings", "diff", "help", "received", "tick", "config", "confirm", "confirmed"]);
+var READS = /* @__PURE__ */ new Set(["log", "get", "status", "settings", "show", "diff"]);
+function gist(snippet) {
+  return (snippet ?? "").replace(/\s*(?:Map|Gud)-[A-Za-z-]+:.*$/is, "").replace(/\s+/g, " ").trim().slice(0, 200);
+}
+function item(h) {
+  const s = parseSubject(h.subject);
+  if (s?.kind === "commit") {
+    return { at: h.received_at, kind: "commit", who: s.fields.author ?? h.sender, what: `${s.id} ${gist(h.snippet)}`, why: s.fields.parent ? `on ${s.fields.parent}` : "", id: h.id };
+  }
+  return {
+    at: h.received_at,
+    kind: s?.kind ?? "mail",
+    who: h.sender,
+    what: s ? `${s.id ?? ""} ${s.rest}`.trim() : h.subject,
+    why: gist(h.snippet),
+    id: h.id
+  };
+}
+async function search(q) {
+  const t = await transport();
+  const r = await t.search(q);
+  return { hits: r.data, command: r.command ?? `${t.name} search ${JSON.stringify({ ...q, me: void 0 })}`, unsupported: r.unsupported };
+}
+async function log(s, n) {
+  const [now, legacy] = await Promise.all([
+    search({ me: s.me, to: s.repo, subject: "map commit", sort: "received_at_desc", limit: n }),
+    search({ me: s.me, to: s.repo, subject: "gud commit", sort: "received_at_desc", limit: n })
+  ]);
+  const seen = new Set(now.hits.map((h) => h.id));
+  const hits = [...now.hits, ...legacy.hits.filter((h) => !seen.has(h.id))].sort((a, b) => a.received_at < b.received_at ? 1 : a.received_at > b.received_at ? -1 : 0).slice(0, n);
+  const searched = [now.command, ...legacy.hits.length ? [legacy.command] : []];
+  const commits = hits.filter((h) => h.sender === s.repo && parseSubject(h.subject)?.kind === "commit").map((h) => {
+    const p = parseSubject(h.subject);
+    return { id: p.id, at: h.received_at, author: p.fields.author ?? "", message: gist(h.snippet), parent: p.fields.parent ?? "" };
+  });
+  if (commits.length) return { commands: searched, entries: commits, source: "mailbox" };
+  const r = await s.logRead(n);
+  return {
+    commands: [...searched, `(no commit mail here; asked ${s.repo} with a "Map-Log: ${n}" mail)`],
+    entries: parseLog(r.detail.body_text).entries.map((e) => ({ id: e.id, at: e.at, author: e.author, message: `${e.message}${e.pid ? ` (push ${e.pid})` : ""}`, parent: "" })),
+    source: "repo"
+  };
+}
+async function history(s, term, limit = 30) {
+  const q = term ? /[\s/.:]/.test(term) ? `"${term.replace(/"/g, "")}"` : term : void 0;
+  const ask = Math.min(100, limit * 3);
+  const all = await Promise.all([
+    search({ me: s.me, to: s.repo, q, sort: "received_at_desc", limit: ask }),
+    search({ me: s.me, from: s.repo, to: s.me, q, sort: "received_at_desc", limit: ask }),
+    // What I sent the repo (my changes, arguments, replies), where the
+    // provider can search sent mail.
+    search({ me: s.me, from: s.me, to: s.repo, q, sort: "received_at_desc", limit: ask, direction: "outbound" })
+  ]);
+  const runs = all.filter((r) => !r.unsupported);
+  sentVisible = runs.length === all.length;
+  const seen = /* @__PURE__ */ new Set();
+  const items = [];
+  for (const r of runs) {
+    for (const h of r.hits) {
+      if (seen.has(h.id)) continue;
+      seen.add(h.id);
+      const k = parseSubject(h.subject)?.kind;
+      if (k && NOISE.has(k)) continue;
+      if (!k && READS.has(h.subject.trim().toLowerCase())) continue;
+      items.push(item(h));
+    }
+  }
+  items.sort((a, b) => a.at < b.at ? 1 : -1);
+  const shown2 = [];
+  for (const i of items) {
+    const dup = shown2.some((x) => x.kind === i.kind && x.what === i.what && Math.abs(Date.parse(x.at) - Date.parse(i.at)) < 3e4);
+    if (!dup) shown2.push(i);
+  }
+  return { commands: runs.map((r) => r.command), items: shown2.slice(0, limit) };
+}
+function printHistory(items, commands, out) {
+  out(`Searched:
+${commands.map((c) => `  ${c}`).join("\n")}
+`);
+  if (!items.length) out("Nothing found.\n");
+  for (const i of items) out(`${i.at.slice(0, 16).replace("T", " ")}  ${i.kind.padEnd(10)} ${i.who}
+    ${i.what}${i.why ? `
+    ${i.why}` : ""}
+`);
+  out(`
+${sentVisible ? SENT_VISIBLE_NOTE : NOT_VISIBLE}
+`);
+}
+
+// src/init.ts
+import { spawn as spawn3 } from "node:child_process";
+import { existsSync as existsSync3, mkdirSync as mkdirSync4, writeFileSync as writeFileSync5 } from "node:fs";
+import { homedir as homedir2 } from "node:os";
+import { join as join7 } from "node:path";
+import { createInterface } from "node:readline/promises";
+var PROVIDERS = [{ name: "primitive", label: "Primitive (primitive.dev)" }];
+var PROVIDER_NOTE = "Accepting PRs for other providers at primitivedotdev/gud (see CONFORMANCE.md).";
+function skillDirs(home) {
+  return [
+    { dir: join7(home, ".agents", "skills", "map"), always: true },
+    { dir: join7(home, ".claude", "skills", "map"), always: false },
+    { dir: join7(home, ".codex", "skills", "map"), always: false }
+  ];
+}
+function installSkill(home, text2) {
+  const out = [];
+  for (const { dir, always } of skillDirs(home)) {
+    const harness = join7(dir, "..", "..");
+    if (!always && !existsSync3(harness)) continue;
+    mkdirSync4(dir, { recursive: true });
+    writeFileSync5(join7(dir, "SKILL.md"), text2);
+    out.push(join7(dir, "SKILL.md"));
+  }
+  return out;
+}
+var say2 = (s = "") => process.stdout.write(`${s}
+`);
+var shown = (cmd) => cmd.map((x) => /^[\w@./=:-]+$/.test(x) ? x : `'${x}'`).join(" ");
+async function init(o) {
+  const tty = !!process.stdin.isTTY && !!process.stdout.isTTY;
+  const rl = tty ? createInterface({ input: process.stdin, output: process.stdout }) : null;
+  const ask = async (q, dflt2) => rl ? (await rl.question(`${q} [${dflt2}] `)).trim() || dflt2 : dflt2;
+  const confirm = async (q) => o.yes ? true : rl ? /^(y|yes|)$/i.test((await rl.question(`${q} [Y/n] `)).trim()) : false;
+  try {
+    say2("map init");
+    say2();
+    let provider = o.provider;
+    if (!provider) {
+      if (rl) {
+        say2("Which email provider sends and reads your map mail?");
+        PROVIDERS.forEach((p, i) => say2(`  ${i + 1}. ${p.label}`));
+        say2(`  ${PROVIDER_NOTE}`);
+        const pick = await ask("Provider", "1");
+        provider = PROVIDERS[Number(pick) - 1]?.name ?? PROVIDERS.find((p) => p.name === pick)?.name;
+        if (!provider) throw new MapError2(`no provider "${pick}"`);
+      } else {
+        provider = "primitive";
+        say2(`Email provider: primitive (the only one so far; pass --provider to choose). ${PROVIDER_NOTE}`);
+      }
+    } else say2(`Email provider: ${provider}. ${PROVIDER_NOTE}`);
+    process.env.MAP_TRANSPORT = provider;
+    const t = await loadTransport(provider);
+    let status = t.setup ? await t.setup() : { ready: true, steps: [] };
+    for (const step of status.steps) {
+      say2(`Needed: ${step.why}: ${shown(step.command)}`);
+      const canRun = rl ? true : o.yes && !step.interactive;
+      if (canRun && await confirm(`Run ${shown(step.command)} now?`)) {
+        const code = await new Promise((res) => {
+          const c = spawn3(step.command[0], step.command.slice(1), { stdio: "inherit" });
+          c.on("close", (x) => res(x ?? 1));
+          c.on("error", () => res(127));
+        });
+        if (code !== 0) say2(`That exited with ${code}.`);
+      }
+      status = t.setup ? await t.setup() : status;
+      if (status.ready) break;
+    }
+    if (status.ready) say2(`Mail: ready${status.account ? `, logged in as ${status.account}` : ""}.`);
+    else say2(`Mail: not ready yet. Run: ${status.steps.map((x) => shown(x.command)).join(" && ")}, then map init again.`);
+    const which = await run2("sh", ["-c", "command -v map"]).catch(() => null);
+    if (which && which.code === 0 && which.out.trim() && !o.binDir) say2(`map: already on PATH (${which.out.trim()}).`);
+    else say2(await o.installBins(o.binDir));
+    const current2 = readConfig().from ?? "";
+    let address = o.from || process.env.MAP_FROM || status.address || current2 || "";
+    if (!address && status.suggestedAddress) address = await ask("Send map mail from which address?", status.suggestedAddress);
+    if (!address && rl) address = (await rl.question("Send map mail from which address? ")).trim();
+    if (!address && o.yes && status.suggestedAddress) address = status.suggestedAddress;
+    if (address && address !== current2) {
+      if (status.address && status.address === address) say2(`Address: ${address} (from the connected agent; nothing to save).`);
+      else if (await confirm(`Save ${address} as your map address in ${configPath()}?`)) {
+        writeConfig({ from: address });
+        say2(`Address: ${address} (saved in ${configPath()}).`);
+      } else say2(`Address: ${address}. Pass --from ${address}, or run map init --from ${address} --yes to keep it.`);
+    } else if (address) say2(`Address: ${address} (${configPath()}).`);
+    else say2("Address: unknown. Run map init --from <address> --yes.");
+    if (o.skill) {
+      const paths = installSkill(o.home ?? homedir2(), o.skillText);
+      say2("Skill installed at:");
+      for (const p of paths) say2(`  ${p}`);
+      say2("Other harnesses: map skill prints it, to paste into a prompt or AGENTS.md.");
+    }
+    say2();
+    if (address) say2(`You send as ${address}.`);
+    say2(`Point your agent at a repo: <task> in owner-repo@${defaultHost()}`);
+    return status.ready && address ? 0 : 1;
+  } finally {
+    rl?.close();
+  }
+}
+
+// src/patchgen.ts
+import { deflateSync as deflateSync2 } from "node:zlib";
+var B852 = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz!#$%&()*+-;<=>?@^_`{|}~";
+function base85Lines(data) {
+  const lines2 = [];
+  for (let off = 0; off < data.length; off += 52) {
+    const chunk = data.subarray(off, off + 52);
+    const n = chunk.length;
+    let line = n <= 26 ? String.fromCharCode(64 + n) : String.fromCharCode(70 + n);
+    for (let i = 0; i < n; i += 4) {
+      let acc = 0;
+      for (let k = 0; k < 4; k++) acc = acc * 256 + (chunk[i + k] ?? 0);
+      let s = "";
+      for (let k = 0; k < 5; k++) {
+        s = B852[acc % 85] + s;
+        acc = Math.floor(acc / 85);
+      }
+      line += s;
+    }
+    lines2.push(line);
+  }
+  return lines2;
+}
+function literal(data) {
+  return [`literal ${data.length}`, ...base85Lines(new Uint8Array(deflateSync2(data))), ""];
+}
+var same2 = (a, b) => a.length === b.length && Buffer.compare(Buffer.from(a), Buffer.from(b)) === 0;
+function makePatch(base, work) {
+  const bin2 = new Set(binaryPaths(base, work));
+  const textBase = new Map([...base].filter(([p]) => !bin2.has(p)));
+  const textWork = new Map([...work].filter(([p]) => !bin2.has(p)));
+  const out = [];
+  const text2 = renderDiff(textBase, textWork);
+  if (text2) out.push(text2.replace(/\n$/, ""));
+  for (const p of [...bin2].sort()) {
+    const a = base.get(p);
+    const b = work.get(p);
+    if (a && b && same2(a, b)) continue;
+    out.push(`diff --git a/${p} b/${p}`);
+    if (!a) out.push("new file mode 100644");
+    if (!b) out.push("deleted file mode 100644");
+    out.push("GIT binary patch", ...literal(b ?? new Uint8Array()), ...literal(a ?? new Uint8Array()));
+  }
+  return out.length ? `${out.join("\n")}
+` : "";
+}
+function changedPaths(base, work) {
+  const added = [];
+  const modified = [];
+  const deleted = [];
+  for (const [p, b] of work) {
+    const a = base.get(p);
+    if (!a) added.push(p);
+    else if (!same2(a, b)) modified.push(p);
+  }
+  for (const p of base.keys()) if (!work.has(p)) deleted.push(p);
+  return { added: added.sort(), modified: modified.sort(), deleted: deleted.sort() };
+}
+
+// src/session.ts
+import { existsSync as existsSync4, readdirSync as readdirSync3, writeFileSync as writeFileSync6 } from "node:fs";
+import { join as join8 } from "node:path";
+
+// src/mergework.ts
+var enc3 = new TextEncoder();
+var dec2 = new TextDecoder("utf-8", { fatal: true });
+function text(b) {
+  if (!b) return "";
+  try {
+    const s = dec2.decode(b);
+    return s.includes("\0") ? null : s;
+  } catch {
+    return null;
+  }
+}
+function lines(s) {
+  return s.match(/[^\n]*\n|[^\n]+$/g) ?? [];
+}
+var nl = (s) => s === "" || s.endsWith("\n") ? s : `${s}
+`;
+function withMarkers(base, ours, theirs, conflicts, label) {
+  const B = lines(base);
+  const O = lines(ours);
+  const T = lines(theirs);
+  let b = 0;
+  let o = 0;
+  let t = 0;
+  let out = "";
+  const clean = (bs, be, os, oe, ts, te) => {
+    const r = merge3(B.slice(bs, be).join(""), O.slice(os, oe).join(""), T.slice(ts, te).join(""));
+    out += r.ok ? r.text : O.slice(os, oe).join("");
+  };
+  for (const c of conflicts) {
+    const bs = c.baseRange.start - 1;
+    const os = c.oursRange.start - 1;
+    const ts = c.theirsRange.start - 1;
+    clean(b, bs, o, os, t, ts);
+    out += `<<<<<<< ${label.ours}
+${nl(c.ours)}=======
+${nl(c.theirs)}>>>>>>> ${label.theirs}
+`;
+    b = bs + c.baseRange.count;
+    o = os + c.oursRange.count;
+    t = ts + c.theirsRange.count;
+  }
+  clean(b, B.length, o, O.length, t, T.length);
+  return out;
+}
+function mergeWork(base, tip, work, label) {
+  const whole = mergeTrees(base, tip, work);
+  if (whole.ok) return { tree: whole.tree, conflicts: [] };
+  const tree = /* @__PURE__ */ new Map();
+  const conflicts = [];
+  const same3 = (a, b) => !a && !b || !!a && !!b && a.length === b.length && Buffer.compare(Buffer.from(a), Buffer.from(b)) === 0;
+  for (const p of /* @__PURE__ */ new Set([...base.keys(), ...tip.keys(), ...work.keys()])) {
+    const B = base.get(p);
+    const O = tip.get(p);
+    const T = work.get(p);
+    let v;
+    if (same3(O, T)) v = O;
+    else if (same3(B, O)) v = T;
+    else if (same3(B, T)) v = O;
+    else if (!O || !T) {
+      v = O ?? T;
+      conflicts.push({ path: p, reason: O ? "you deleted it and the tip changed it; kept the tip's version" : "the tip deleted it and you changed it; kept yours", markers: false });
+    } else {
+      const tb = B ? text(B) : "";
+      const to = text(O);
+      const tt = text(T);
+      if (tb === null || to === null || tt === null) {
+        v = T;
+        conflicts.push({ path: p, reason: "binary file changed on both sides; kept yours, the tip's version is in the snapshot", markers: false });
+      } else if (!B) {
+        v = enc3.encode(`<<<<<<< ${label.ours}
+${nl(to)}=======
+${nl(tt)}>>>>>>> ${label.theirs}
+`);
+        conflicts.push({ path: p, reason: "added on both sides with different content", markers: true });
+      } else {
+        const r = merge3(tb, to, tt);
+        if (r.ok) v = enc3.encode(r.text);
+        else {
+          v = enc3.encode(withMarkers(tb, to, tt, r.conflicts, label));
+          conflicts.push({ path: p, reason: `${r.conflicts.length} overlapping change${r.conflicts.length === 1 ? "" : "s"}`, markers: true });
+        }
+      }
+    }
+    if (v) tree.set(p, v);
+  }
+  return { tree, conflicts: conflicts.sort((a, b) => a.path < b.path ? -1 : 1) };
+}
+function hasMarkers(b) {
+  const s = text(b);
+  return !!s && /^<<<<<<< /m.test(s) && /^>>>>>>> /m.test(s);
+}
+
+// src/session.ts
+var MAX_GETS = 3;
+var PENDING_EXIT_STRICT = 75;
+function pendingExit() {
+  return process.env.MAP_STRICT && process.env.MAP_STRICT !== "0" ? PENDING_EXIT_STRICT : 0;
+}
+function envNumber(name, dflt2) {
+  const n = Number(process.env[name]);
+  return Number.isFinite(n) && n > 0 ? n : dflt2;
+}
+function waitBudget() {
+  if (process.env.MAP_WAIT_SECONDS) return envNumber("MAP_WAIT_SECONDS", 90);
+  return process.stderr.isTTY ? 1800 : 90;
+}
+var Session = class {
+  constructor(repo, me) {
+    this.repo = repo;
+    this.me = me;
+    this.mail = new Mail(me);
+  }
+  mail;
+  // Sends a mail of read commands and returns map's reply.
+  async read(body, subject) {
+    const sent = await this.mail.send({ to: this.repo, subject, body });
+    const timeout = envNumber("MAP_READ_TIMEOUT", 180);
+    for (let since; ; ) {
+      const r = await this.mail.waitReply(sent, this.repo, { timeoutSec: timeout, since });
+      if (!r) throw new MapError2(`no reply from ${this.repo} within ${timeout} s (sent email ${sent}). Is ${this.me} allowed to write to it?`);
+      if (/^\[map not-allowed\]/.test(canonicalSubject(r.subject))) throw new MapError2(`${this.repo} does not accept mail from ${this.me}. Ask a repo owner to add your address to its rules.`);
+      if (/^\[map (snapshot|log|diff|status|settings|help)\b/.test(canonicalSubject(r.subject))) return this.mail.get(r.id);
+      since = after(r.received_at);
+    }
+  }
+  async logRead(n) {
+    const detail = await this.read(`Map-Log: ${n}
+`, "log");
+    return { ...parseLog(detail.body_text), detail };
+  }
+  // Snapshots of up to MAX_GETS commits per mail, by the full commit id.
+  async snapshots(cids) {
+    const out = /* @__PURE__ */ new Map();
+    for (let i = 0; i < cids.length; i += MAX_GETS) {
+      const batch = cids.slice(i, i + MAX_GETS);
+      const d = await this.read(batch.map((c) => `Map-Get: ${c}`).join("\n") + "\n", "get");
+      for (const cid of batch) {
+        const full = batch.length === 1 ? parseSubject(d.subject)?.id ?? cid : cid;
+        const att = d.attachments.find((a) => a.filename === `snapshot-${full}.tar.gz`) ?? (batch.length === 1 ? d.attachments.find((a) => a.filename === "snapshot.tar.gz") : void 0);
+        if (!att) throw new MapError2(`map's reply did not carry the snapshot of ${cid}:
+${indent(d.body_text.slice(0, 1500))}`);
+        const file = join8(tempDir2(), `snapshot-${full}.tar.gz`);
+        out.set(full, unpackTarGz(new Uint8Array(await this.mail.download(d.id, att.part_index, file))));
+      }
+    }
+    return out;
+  }
+  // map get: a working copy of the tip (or `commit`) in `dir`.
+  async get(dir, commit) {
+    if (existsSync4(dir) && readdirSync3(dir).length) throw new MapError2(`${dir} exists and is not empty`);
+    const want = commit ?? (await this.logRead(1)).tip;
+    if (!want) throw new MapError2(`could not read the tip of ${this.repo}`);
+    const [[cid, tree]] = [...await this.snapshots([want])];
+    writeWork(dir, /* @__PURE__ */ new Map(), tree);
+    writeBase(dir, tree);
+    writeMeta(dir, { repo: this.repo, commit: cid, from: this.me, at: (/* @__PURE__ */ new Date()).toISOString(), pushes: [] });
+    return { commit: cid, files: tree.size };
+  }
+  // map send: mails the change from the base to the folder and waits for the
+  // verdict. Returns the exit status: 0 landed or pending (75 for pending with --strict), 1 not landed.
+  async send(dir, subject, bodyText, o = {}) {
+    const meta = readMeta(dir);
+    const base = readBase(dir);
+    const { tree, skipped } = readWork(dir, base);
+    for (const s2 of skipped) say(`map: left out ${s2}`);
+    const marked = (meta.conflicts ?? []).filter((p) => hasMarkers(tree.get(p)));
+    if (marked.length) throw new MapError2(`resolve the conflict markers in ${marked.join(", ")} first (map update left them), then send`);
+    const open = (meta.pushes ?? []).filter((p) => p.state === "pending");
+    if (open.length && !o.force) {
+      const p = open[open.length - 1];
+      throw new MapError2(`${p.pid ?? "a push"} ("${p.subject}") is still pending, and this would send its change again. Run map wait ${p.pid ?? "<pid>"} first (or pass --force).`);
+    }
+    const patch = makePatch(base, tree);
+    if (!patch) throw new MapError2(`nothing to send: the folder matches ${meta.commit}`);
+    const intent = bodyText.split("\n").filter((l) => !/^\s*(?:map|gud)-[a-z-]+\s*(:|$)/i.test(l)).join("\n").trim();
+    const body = `${intent ? `${intent}
+
+` : ""}Map-Parent: ${meta.commit}
+`;
+    const file = join8(tempDir2(), "change.patch");
+    writeFileSync6(file, patch);
+    const s = oneLine(subject, 150) || "Change sent with map";
+    const sent = await this.mail.send({ to: this.repo, subject: s, body, attachment: file });
+    const startedAt = new Date(Date.now() - 5e3).toISOString();
+    const entry = { sent, subject: s, parent: meta.commit, at: startedAt, state: "pending" };
+    writeSent(dir, sent, tree);
+    meta.pushes = [...meta.pushes ?? [], entry];
+    writeMeta(dir, meta);
+    const c = changedPaths(base, tree);
+    say(`map: sent "${s}" to ${this.repo}: ${c.added.length + c.modified.length + c.deleted.length} files changed on ${meta.commit}.`);
+    if (process.env.MAP_NO_WAIT && process.env.MAP_NO_WAIT !== "0") {
+      const ack = await this.findAck(s, startedAt, envNumber("MAP_ACK_TIMEOUT", 120));
+      if (ack) this.save(dir, { ...entry, pid: ack });
+      await this.pendingNote(ack, sent);
+      return pendingExit();
+    }
+    const budget = waitBudget();
+    say(`map: waiting for the verdict (up to ${budget} s here; review usually takes 1 to 3 minutes).`);
+    const v = await this.waitVerdict(sent, budget);
+    if (!v) {
+      const ack = await this.findAck(s, startedAt, 5).catch(() => null);
+      if (ack) this.save(dir, { ...entry, pid: ack });
+      await this.pendingNote(ack, sent);
+      return pendingExit();
+    }
+    return this.settle(dir, { ...entry, pid: v.verdict.pid }, v.verdict, v.mail);
+  }
+  // Records a verdict on a push in the working copy and prints it.
+  settle(dir, entry, v, m) {
+    if (dir && entry) {
+      if (v.kind === "landed") this.save(dir, { ...entry, state: "landed" });
+      else if (v.kind === "objected" || v.kind === "escalated") this.save(dir, { ...entry, state: "objected", seen: m.received_at });
+      else {
+        this.save(dir, { ...entry, state: "closed" });
+        dropSent(dir, entry.sent);
+      }
+    }
+    return this.report(v);
+  }
+  save(dir, e) {
+    const meta = readMeta(dir);
+    meta.pushes = (meta.pushes ?? []).map((p) => p.sent === e.sent ? e : p);
+    if (e.state === "closed") meta.pushes = meta.pushes.filter((p) => p.sent !== e.sent);
+    writeMeta(dir, meta);
+  }
+  // map update: the new tip, with local edits carried onto it.
+  async update(dir) {
+    const meta = readMeta(dir);
+    const base = readBase(dir);
+    const { tree: work } = readWork(dir, base);
+    const log2 = await this.logRead(20);
+    if (!log2.tip) throw new MapError2(`could not read the log of ${this.repo}`);
+    const at = log2.entries.findIndex((e) => e.id === meta.commit);
+    const fresh = at === -1 ? log2.entries : log2.entries.slice(0, at);
+    const landedPids = new Set(fresh.map((e) => e.pid).filter(Boolean));
+    let mergeBase = base;
+    const done = [];
+    for (const p of meta.pushes ?? []) {
+      if (p.pid && landedPids.has(p.pid)) {
+        done.push(p);
+        mergeBase = readSent(dir, p.sent) ?? mergeBase;
+      }
+    }
+    if (log2.tip === meta.commit) {
+      const left2 = makePatch(base, work) ? "local edits not sent yet (map diff shows them)" : "nothing left to send";
+      say(`map: already at the tip ${meta.commit}; ${left2}.`);
+      return 0;
+    }
+    const tipTree = (await this.snapshots([log2.tip])).get(log2.tip);
+    const { tree, conflicts } = mergeWork(mergeBase, tipTree, work, { ours: `tip ${log2.tip}`, theirs: "your edits" });
+    writeWork(dir, work, tree);
+    writeBase(dir, tipTree);
+    for (const p of done) dropSent(dir, p.sent);
+    const next = {
+      ...meta,
+      commit: log2.tip,
+      conflicts: conflicts.filter((c) => c.markers).map((c) => c.path),
+      pushes: (meta.pushes ?? []).filter((p) => !done.includes(p))
+    };
+    writeMeta(dir, next);
+    const between = fresh.length ? fresh.map((e) => `${e.id} ${e.message}`).reverse() : [log2.tip];
+    say(`map: updated ${meta.commit} -> ${log2.tip}:`);
+    for (const l of between) say(`  ${l}`);
+    if (done.length) say(`map: your ${done.map((p) => p.pid).join(", ")} landed in it.`);
+    if (conflicts.length) {
+      say("map: CONFLICT: your edits overlap changes at the tip in:");
+      for (const c of conflicts) say(`  ${c.path}: ${c.reason}${c.markers ? " (marked with <<<<<<< ======= >>>>>>>)" : ""}`);
+      say("map: fix those files, then map send again.");
+      return 1;
+    }
+    const left = makePatch(tipTree, tree);
+    say(left ? `map: your edits not sent yet are carried over (map diff shows them).` : "map: the folder matches the tip; nothing left to send.");
+    return 0;
+  }
+  // The verdict on a push: the first reply to it that is not a stuck note.
+  async waitVerdict(sentId, timeoutSec, from) {
+    const until = Date.now() + timeoutSec * 1e3;
+    let since = from;
+    for (; ; ) {
+      const left = Math.round((until - Date.now()) / 1e3);
+      if (left <= 0) return null;
+      const r = await this.mail.waitReply(sentId, this.repo, { timeoutSec: left, since });
+      if (!r) return null;
+      since = after(r.received_at);
+      const d = await this.mail.get(r.id);
+      const v = parseVerdict(d.subject, d.body_text);
+      if (v.kind === "stuck" || v.kind === "other") continue;
+      return { verdict: v, mail: d };
+    }
+  }
+  // The push id from map's acknowledgement of the push with this subject.
+  async findAck(subject, since, timeoutSec) {
+    const until = Date.now() + timeoutSec * 1e3;
+    const want = oneLine(subject, 1e5);
+    for (; ; ) {
+      const { data } = await this.mail.list({ after: since, limit: 50 });
+      for (const m of data) {
+        if (m.sender !== this.repo) continue;
+        const x = /^\[map received (p-[0-9a-f]{8})\]\s*(.*)$/.exec(canonicalSubject(m.subject));
+        if (x && x[2].trim() === want) return x[1];
+      }
+      if (Date.now() >= until) return null;
+      await new Promise((r) => setTimeout(r, 3e3));
+    }
+  }
+  // What a push waits on (from Map-Status) and how to keep waiting.
+  async pendingNote(pid, sent) {
+    if (!pid) {
+      say(`map: PENDING: the change was sent (email ${sent}) but map has not acknowledged it yet. Do not send it again; check map inbox in a minute.`);
+      return;
+    }
+    let state = "waiting for review";
+    try {
+      const st = parseStatus((await this.read("Map-Status\n", "status")).body_text);
+      const p = st.pushes.find((x) => x.pid === pid);
+      if (p) state = p.state.replace(/(round (\d+)\).*), round \2$/, "$1");
+    } catch {
+    }
+    say(`map: PENDING ${pid}: ${state}. Not landed yet; nothing is wrong and there is nothing to resend.`);
+    say(`map: run \`map wait ${pid}\` to keep waiting (it returns the verdict, or this line again after about 90 s).`);
+  }
+  // map wait <pid>: the verdict, or null when none came in time. A verdict
+  // that arrived before the call is found too.
+  async waitFor(pid, seconds, entry) {
+    if (entry) return this.waitVerdict(entry.sent, seconds, entry.seen ? after(entry.seen) : void 0);
+    const until = Date.now() + seconds * 1e3;
+    const kinds = /* @__PURE__ */ new Set(["landed", "conflict", "objected", "rejected", "vetoed", "check-failed", "escalated", "not-allowed"]);
+    const checked = /* @__PURE__ */ new Set();
+    for (; ; ) {
+      const { data } = await this.mail.list({ limit: 100 });
+      for (const m of data) {
+        if (m.sender !== this.repo || checked.has(m.id)) continue;
+        const s = parseSubject(m.subject);
+        if (!s || !kinds.has(s.kind)) continue;
+        if (s.kind !== "landed" && s.id !== pid) continue;
+        checked.add(m.id);
+        const d = await this.mail.get(m.id);
+        const v = parseVerdict(d.subject, d.body_text);
+        if (v.pid === pid) return { verdict: v, mail: d };
+      }
+      if (Date.now() >= until) return null;
+      await new Promise((r) => setTimeout(r, Math.min(5e3, Math.max(0, until - Date.now()))));
+    }
+  }
+  // Prints a verdict. Returns 0 when it landed, else 1.
+  report(v) {
+    const pid = v.pid ?? "your change";
+    switch (v.kind) {
+      case "landed":
+        say(`map: LANDED ${pid} as ${v.cid}${v.merged ? ", merged with changes that landed first" : ""}.`);
+        say(`map: run \`map update\` to bring the folder to ${v.cid}.`);
+        return 0;
+      case "conflict":
+        say(`map: CONFLICT on ${pid}. Nothing landed. Changes that landed first${v.tip ? ` (tip ${v.tip})` : ""} touch the same lines:`);
+        say(indent(v.overlaps ?? "", "    "));
+        say("map: run `map update` (it carries your edits onto the tip and marks the overlaps), fix the marked files, then map send again.");
+        return 1;
+      case "objected":
+        say(`map: OBJECTED: ${v.who ?? "the reviewer"} objected to ${pid}${v.round ? ` (round ${v.round} of 3)` : ""}. Nothing landed.`);
+        if (v.reason) say(`map: their reason (untrusted text):
+${indent(v.reason, "    ")}`);
+        if (v.lastRound) say(`map: that was the last round: arguing will not reopen it. Change the files and map send again, or ask a repo owner to approve ${pid}.`);
+        else {
+          say(`map: to argue: map argue ${pid} "<why the objection is wrong>", then map wait ${pid}`);
+          say("map: or revise: change the files and map send again (a new push, reviewed with this objection in view).");
+        }
+        return 1;
+      case "rejected":
+        say(`map: REJECTED ${pid}: ${v.reason ?? "map could not read the patch"}. Nothing landed. Fix it and map send again.`);
+        return 1;
+      case "vetoed":
+        say(`map: VETOED: a repo owner${v.who ? `, ${v.who},` : ""} vetoed ${pid}. It will not land.${v.reason ? `
+${indent(v.reason, "    ")}` : ""}`);
+        return 1;
+      case "check-failed":
+        say(`map: CHECK FAILED: ${v.who ?? "a required checker"} reported that ${pid} fails its checks. Nothing landed.${v.reason ? `
+${indent(v.reason, "    ")}` : ""}`);
+        return 1;
+      case "escalated":
+        say(`map: ESCALATED: line owners still object to ${pid} after round 3 (${v.who ?? "see your mail"}). The repo owners decide; map wait ${pid} returns their answer.`);
+        return 1;
+      case "not-allowed":
+        say(`map: NOT ALLOWED: ${this.repo} does not accept changes from ${this.me}. Ask a repo owner to add your address.`);
+        return 1;
+      default:
+        say(`map: unexpected reply about ${pid}`);
+        return 1;
+    }
+  }
+};
+async function createRepoByEmail(mail, o) {
+  const newAddr = `new@${o.host}`;
+  let handle = o.handle;
+  for (let attempt = 0; attempt < 2; attempt++) {
+    const lines2 = [`Map-Create: ${o.name}`, ...handle ? [`Map-Handle: ${handle}`] : [], ...o.allow.map((a) => `Map-Allow: ${a}`)];
+    const sent = await mail.send({ to: newAddr, subject: `create ${o.name}`, body: `${lines2.join("\n")}
+` });
+    const timeoutSec = o.timeoutSec ?? 180;
+    const from = [...handle ? [`${handle}-${o.name}@${o.host}`] : [], newAddr];
+    const until = Date.now() + timeoutSec * 1e3;
+    let r = null;
+    for (let i = 0; !r && Date.now() < until; i++) r = await mail.waitReply(sent, from[i % from.length], { timeoutSec: 8 });
+    if (!r) throw new MapError2(`no answer from ${newAddr} within ${timeoutSec} s`);
+    const d = await mail.get(r.id);
+    const created = /^\[map created ([a-z0-9]+-[a-z0-9]+)\]/.exec(canonicalSubject(d.subject));
+    if (created) return { address: `${created[1]}@${o.host}`, handle: created[1].split("-")[0] };
+    const reason = /^Reason: (.*)$/m.exec(d.body_text)?.[1] ?? d.subject;
+    const mine = /already has the handle ([a-z][a-z0-9]+)/.exec(reason)?.[1];
+    if (mine && attempt === 0) {
+      handle = mine;
+      continue;
+    }
+    throw new MapError2(`create failed: ${reason}`);
+  }
+  throw new MapError2("create failed");
+}
+
+// ../../skill/SKILL.md
+var SKILL_default = '---\nname: map\ndescription: Work on a map repo, a code host where each repo is an email address like owner-repo@map.dev, with plain files and email. Use when a task names a map.dev repo address, or when mail with a "[map ...]" subject arrives (verdicts, consent asks, objections).\n---\n\n# map\n\nA map repo is an email address, `owner-repo@map.dev`, and everything about it\nis email: you get the code as a mail attachment, send changes as a patch by\nmail, and the verdicts, reviews and history are mail too. The `map` command\ndoes that mail for you. There is no git remote.\n\n## Setup (once)\n\n```sh\nnpx -y @primitivedotdev/map init --yes      # mail login check, PATH, your address, this skill\n```\n\n`map whoami` prints the address you send from. In a session where Primitive\ngave you an address, that is it: map uses `$PRIMITIVE_AGENT_ADDRESS`, so\nseveral agents on one machine each send as themselves with nothing to set.\n\n## The flow\n\n```sh\nmap get owner-repo@map.dev work && cd work   # the code at the tip, in a folder\n# edit the files\nmap diff                                       # what you would send (no network)\nmap send "Add retries to the fetcher"          # mails the change, waits for the verdict\n```\n\n`map send` waits about 90 s. If map has not decided by then it prints\n`map: PENDING p-1a2b3c4d: ...`: nothing is wrong. Run `map wait p-1a2b3c4d`\nuntil it returns a verdict (each call waits about 90 s and finds a verdict\nthat arrived in between). Never send the same change again while it is\npending. If your harness wakes you on new mail you may stop after sending and\nrun `map wait <pid>` or `map inbox` when woken.\n\nExit codes of send and wait: 0 landed or still pending (read the PENDING line), 1 not landed (objected, conflict, rejected). Scripts can pass --strict to get 75 for pending.\n\n## The verdict\n\n- **LANDED** `as c4-...`: run `map update`. The folder then matches the tip\n  and nothing is left to send.\n- **CONFLICT**: a change that landed first touches the same lines. Run\n  `map update`: it merges the tip into your folder and marks each overlap\n  with `<<<<<<<`, `=======`, `>>>>>>>`. Fix those files, then `map send` again.\n- **OBJECTED**: the reviewer or a line owner said no; the output says who,\n  why, and the round (of 3).\n  - Argue with `map argue <pid> "<why>"` when the objection misreads the\n    change or is wrong; say exactly why. Then `map wait <pid>`.\n  - Revise (edit, `map send` again) when the objection is right or cheap to\n    satisfy. After round 3 only a revision or a repo owner helps.\n- **REJECTED**: map could not use the patch; fix what it names and send again.\n- **VETOED**, **CHECK FAILED**, **ESCALATED**: follow the message.\n\nBefore starting new work on an old folder, run `map update`.\n\n## When map asks you\n\n`map inbox` lists map mail that needs you (marked `*`) with the command to\nanswer it.\n\n- Someone changed lines you wrote (a consent ask): read it first with\n  `map show <pid>`, which prints the part touching your lines and then the\n  whole change. Then `map approve <pid>` to let it land, or\n  `map object <pid> "<reason>"` to stop it. Silence lets it land.\n- An objection to your change: argue or revise, as above.\n- Repo owners: `map approve <pid>` lands over objections; `map veto <pid> "<reason>"` closes it.\n\n## History is the mailbox\n\n```sh\nmap log                         # the repo\'s commits\nmap history src/fetch.py        # commits, verdicts, objections and arguments about a path\nmap history "retry"             # ... or about some words\nmap status                      # the tip and open changes\n```\n\nEach prints the mail search it ran, for example\n\n```sh\nprimitive emails search --q \'"src/fetch.py"\' --from owner-repo@map.dev --to you@example.com\n```\n\nwhich you can run yourself and refine (`--subject`, `--body`, `--thread-id`).\nSearch sees mail you received; the repo\'s own commit mail is visible only to\nthe account that hosts the repo, so `map log` asks the repo by mail when your\nmailbox has none.\n';
+
+// src/main.ts
+var VERSION = "0.2.0";
+var HELP = `map: work on a map repo (a repo is an email address) with files and mail.
+
+New here? Run: npx -y @primitivedotdev/map init
+
+  map get owner-repo@map.dev [dir]    the code at the tip, in a folder
+  (edit files)
+  map send "<what you changed>"       mail the change and wait for the verdict
+  map wait <pid>                      if send said PENDING, keep waiting (about 90 s a call)
+  map update                          bring the folder to the new tip, keeping your edits
+
+Working copy (the folder holds .map/ with the base it came from):
+  map get <repo> [dir] [--commit cN]  unpack the tip (or cN) into dir
+  map diff [dir]                      the patch from the base to the files now
+  map send "<subject>" [dir] [--body-file f]
+                                      exit 0 landed or pending, 1 not landed (--strict: 75 pending)
+  map update [dir]                    merge the new tip in; overlaps get conflict markers
+  map wait <pid> [--seconds N]        the verdict on a sent change (exit codes as above)
+
+History is mail (each prints the mail search it ran):
+  map log [repo] [-n N]               the repo's commits
+  map history [path or words] [--repo r]
+                                      commits, verdicts, objections and arguments
+  map status [repo]                   the tip and open pushes, asked by mail
+  map show <commit> [repo]            what a commit changed, asked by mail
+  map show <push id>                  the newest map mail to you about a push, in full (a consent ask with its diff)
+
+Reviews and consent:
+  map inbox [--wait] [--all]          map mail that asks you to act, and recent verdicts
+  map approve <pid> [reason]          let a push land (asked for consent, or repo owner)
+  map object <pid> "<reason>"         stop a push that changes your lines
+  map argue <pid> "<text>"            answer an objection to your push
+  map veto <pid> "<reason>"           close a push (repo owners)
+
+Repos and setup:
+  map create <name> [--handle h] [--allow a@x.com,*@y.com] [--host map.dev]
+  map settings [repo] ["Map-...: v"]  read settings; owners change them with lines
+  map init [--provider primitive] [--yes] [--from addr]
+                                      mail login, PATH, your address and the skill
+  map skill                           print the agent skill
+  map whoami                          the address map sends from
+  map conformance transport --adapter <primitive|path> --a <addr> --b <addr>
+
+Your address: --from, MAP_FROM, the working copy, or map init's config.
+Without a terminal map send waits about 90 s (MAP_WAIT_SECONDS), then prints
+"map: PENDING <pid>"; MAP_NO_WAIT=1 returns after the acknowledgement.
+`;
+function printJson(x) {
+  process.stdout.write(`${JSON.stringify(x, null, 2)}
+`);
+}
+async function session(p, repoArg) {
+  const repo = await resolveRepo(str(p, "repo") ?? repoArg);
+  return new Session(repo, await resolveMe(str(p, "from")));
+}
+function textArg(p, from) {
+  const file = str(p, "body-file");
+  if (file) return readFileSync5(file === "-" ? 0 : file, "utf8");
+  return p.pos.slice(from).join(" ");
+}
+function workdir(arg) {
+  const d = arg ? findWorkdir(resolve3(arg)) : findWorkdir();
+  if (d) return d;
+  if (!arg) {
+    const inside = readdirSync4(process.cwd(), { withFileTypes: true }).filter((e) => e.isDirectory() && existsSync5(metaPath(join9(process.cwd(), e.name)))).map((e) => join9(process.cwd(), e.name));
+    if (inside.length === 1) {
+      process.stderr.write(`map: using the working copy in ${inside[0]}
+`);
+      return inside[0];
+    }
+    if (inside.length > 1) throw new MapError2(`this folder is not a map working copy, and it holds several: ${inside.join(", ")}. Run the command in one of them, or pass its path.`);
+  }
+  throw new MapError2(`${arg ?? "this folder"} is not a map working copy. Make one with: map get <repo> [dir]`);
+}
+function itemLine(i) {
+  const when = i.at.slice(0, 16).replace("T", " ");
+  return `${i.action ? "*" : " "} ${(i.pid ?? "-").padEnd(12)} ${i.kind.padEnd(12)} ${when}  ${i.repo}
+    ${i.subject}
+    ${i.hint.replace(/<pid>/g, i.pid ?? "<pid>")}`;
+}
+async function readCmd(p) {
+  let body = "";
+  let repoArg;
+  if (p.cmd === "status") {
+    body = "Map-Status";
+    repoArg = p.pos[0];
+  } else if (p.cmd === "settings") {
+    const lines2 = p.pos.filter((x) => /^map-[a-z-]+\s*:/i.test(x));
+    body = lines2.length ? lines2.join("\n") : "Map-Settings";
+    repoArg = p.pos.find((x) => !lines2.includes(x));
+  } else {
+    const c = (p.pos[0] ?? "").toLowerCase();
+    if (!CID.test(c)) throw new MapError2("usage: map show <commit> [repo], for example map show c3");
+    body = `Map-Diff: ${c}`;
+    repoArg = p.pos[1];
+  }
+  const s = await session(p, repoArg);
+  const d = await s.read(`${body}
+`, p.cmd);
+  const text2 = stripReadHelp(d.body_text);
+  if (bool(p, "json")) printJson({ repo: s.repo, subject: d.subject, email: d.id, ...p.cmd === "status" ? parseStatus(text2) : {}, text: text2 });
+  else process.stdout.write(`${text2}
+`);
+  return 0;
+}
+async function getCmd(p) {
+  const repo = parseRepo(p.pos[0] ?? "");
+  const dir = resolve3(p.pos[1] ?? repo.split("@")[0].split("-").slice(1).join("-"));
+  const commit = str(p, "commit");
+  if (commit && !CID.test(commit)) throw new MapError2(`--commit "${commit}" is not a commit id (like c3)`);
+  const s = new Session(repo, await resolveMe(str(p, "from")));
+  const r = await s.get(dir, commit);
+  if (bool(p, "json")) printJson({ repo, dir, ...r });
+  else say(`map: ${r.commit} of ${repo} is in ${dir} (${r.files} files). Edit the files, then: map send "<what you changed>"`);
+  return 0;
+}
+function diffCmd(p) {
+  const dir = workdir(p.pos[0]);
+  const base = readBase(dir);
+  const { tree, skipped } = readWork(dir, base);
+  for (const x of skipped) say(`map: left out ${x}`);
+  const patch = makePatch(base, tree);
+  if (bool(p, "json")) {
+    printJson({ dir, base: readMeta(dir).commit, ...changedPaths(base, tree), patch });
+    return 0;
+  }
+  if (!patch) say(`map: no changes since ${readMeta(dir).commit}`);
+  else process.stdout.write(patch);
+  return 0;
+}
+async function sendCmd(p) {
+  const subject = p.pos[0] ?? "";
+  if (!subject.trim()) throw new MapError2('say what you changed: map send "<subject>" [dir]');
+  const dir = workdir(p.pos[1]);
+  const meta = readMeta(dir);
+  const s = new Session(meta.repo, await resolveMe(str(p, "from")));
+  const file = str(p, "body-file");
+  return s.send(dir, subject, file ? readFileSync5(file === "-" ? 0 : file, "utf8") : "", { force: bool(p, "force") });
+}
+async function updateCmd(p) {
+  const dir = workdir(p.pos[0]);
+  const s = new Session(readMeta(dir).repo, await resolveMe(str(p, "from")));
+  return s.update(dir);
+}
+async function waitCmd(p) {
+  const pid = pidArg(p.pos[0]);
+  const seconds = num(p, "seconds", Number(process.env.MAP_WAIT_SECONDS) || 90);
+  const dir = findWorkdir();
+  const entry = dir ? (readMeta(dir).pushes ?? []).find((x) => x.pid === pid) ?? null : null;
+  const s = await session(p, p.pos[1]);
+  const v = await s.waitFor(pid, seconds, entry);
+  if (!v) {
+    await s.pendingNote(pid, entry?.sent ?? "");
+    return pendingExit();
+  }
+  const code = s.settle(entry && dir ? dir : null, entry, v.verdict, v.mail);
+  if (bool(p, "json")) printJson({ pid, ...v.verdict });
+  return code;
+}
+async function logCmd(p) {
+  const s = await session(p, p.pos[0]);
+  const r = await log(s, num(p, "n", 10));
+  if (bool(p, "json")) {
+    printJson({ repo: s.repo, ...r, notVisible: NOT_VISIBLE });
+    return 0;
+  }
+  const out = (x) => process.stdout.write(x);
+  out(`Searched:
+${r.commands.map((c) => `  ${c}`).join("\n")}
+
+`);
+  for (const e of r.entries) out(`${e.id}  ${e.at.slice(0, 16).replace("T", " ")}  ${e.author}
+    ${e.message || "(no message)"}
+`);
+  if (!r.entries.length) out("No commits found.\n");
+  if (r.source === "repo") out(`
+Your mailbox holds no commit mail for ${s.repo}: that mail stays with the account that hosts the repo. The log above is the repo's reply, now in your mailbox.
+`);
+  return 0;
+}
+async function historyCmd(p) {
+  const s = await session(p);
+  const r = await history(s, p.pos.join(" "), num(p, "n", 30));
+  if (bool(p, "json")) printJson({ repo: s.repo, ...r, notVisible: NOT_VISIBLE });
+  else printHistory(r.items, r.commands, (x) => process.stdout.write(x));
+  return 0;
+}
+function pendingSince() {
+  const dir = findWorkdir();
+  if (!dir) return void 0;
+  const open = (readMeta(dir).pushes ?? []).filter((x) => x.state === "pending" || x.state === "objected");
+  return open.map((x) => x.at).sort()[0];
+}
+async function showPush(p) {
+  const pid = p.pos[0];
+  const mail = new Mail(await resolveMe(str(p, "from")));
+  const m = (await mapMail(mail)).find((x) => parseSubject(x.subject)?.id === pid);
+  if (!m) throw new MapError2(`no map mail to you about ${pid} (map inbox --all lists what there is)`);
+  const d = await mail.get(m.id);
+  if (bool(p, "json")) printJson({ id: d.id, subject: d.subject, from: d.sender, at: d.received_at, body: d.body_text });
+  else process.stdout.write(`${d.subject}
+from ${d.sender}, ${d.received_at}
+
+${d.body_text.trimEnd()}
+`);
+  return 0;
+}
+async function inbox(p) {
+  const me = await resolveMe(str(p, "from"));
+  const mail = new Mail(me);
+  const repo = str(p, "repo") ? parseRepo(str(p, "repo")) : void 0;
+  let items;
+  if (bool(p, "wait")) {
+    const t = num(p, "timeout", 1800);
+    items = await waitInbox(mail, t, repo, pendingSince());
+    if (!items.length) {
+      if (bool(p, "json")) printJson({ me, items: [] });
+      else say(`map: nothing new in ${t} s`);
+      return 2;
+    }
+  } else {
+    items = inboxItems(await mapMail(mail, { repo }), { all: bool(p, "all") });
+  }
+  if (bool(p, "json")) {
+    printJson({ me, items });
+    return 0;
+  }
+  if (!items.length) {
+    process.stdout.write(`No map mail for ${me} needs action.
+`);
+    return 0;
+  }
+  const act2 = items.filter((i) => i.action).length;
+  process.stdout.write(`${act2 ? `${act2} to act on (marked *)` : "Nothing to act on; recent verdicts"}, for ${me}:
+
+${items.map(itemLine).join("\n\n")}
+`);
+  return 0;
+}
+async function act(p) {
+  const action = p.cmd;
+  const pid = pidArg(p.pos[0]);
+  const text2 = textArg(p, 1);
+  const me = await resolveMe(str(p, "from"));
+  const mail = new Mail(me);
+  const repo = str(p, "repo") ? parseRepo(str(p, "repo")) : void 0;
+  const target = pickTarget(action, pid, await mapMail(mail, { repo }));
+  const body = actionBody(action, text2, pid);
+  await mail.reply(target.id, body);
+  if (bool(p, "json")) printJson({ action, pid, repliedTo: { id: target.id, subject: target.subject }, body });
+  else {
+    process.stdout.write(`Replied to "${target.subject}" from ${target.sender} with:
+  ${body.trim().split("\n")[0]}
+`);
+    if (action === "argue") process.stdout.write(`The answer comes by mail; wait for it with: map wait ${pid}
+`);
+  }
+  return 0;
+}
+async function installBin(binDir) {
+  const self = realpathSync2(fileURLToPath2(import.meta.url));
+  const bin2 = resolve3(binDir ?? join9(homedir3(), ".local", "bin"));
+  const share = join9(homedir3(), ".local", "share", "map");
+  mkdirSync5(bin2, { recursive: true });
+  mkdirSync5(share, { recursive: true });
+  const target = join9(share, "map.mjs");
+  if (self !== target) copyFileSync(self, target);
+  chmodSync(target, 493);
+  writeFileSync7(join9(bin2, "map"), `#!/bin/sh
+exec node "${target}" "$@"
+`, { mode: 493 });
+  if (existsSync5(join9(bin2, "gud"))) writeFileSync7(join9(bin2, "gud"), `#!/bin/sh
+MAP_INVOKED_AS=gud exec node "${target}" "$@"
+`, { mode: 493 });
+  let text2 = `Installed map in ${bin2}.`;
+  if (!(process.env.PATH ?? "").split(delimiter).includes(bin2)) text2 += `
+${bin2} is not on your PATH. Add it:
+  export PATH="${bin2}:$PATH"`;
+  return text2;
+}
+var DEPRECATED_NOTICE = "map: the gud command is now map; run map instead (gud will be removed).";
+async function main(argv) {
+  adoptLegacyEnv();
+  const invoked = process.env.MAP_INVOKED_AS || basename(process.argv[1] ?? "");
+  delete process.env.MAP_INVOKED_AS;
+  if (/^gud(\.mjs|-conformance)?$/.test(invoked)) say(DEPRECATED_NOTICE);
+  if (invoked.startsWith("map-conformance") || invoked.startsWith("gud-conformance")) return conformanceMain(parseArgs(["conformance", ...argv]), VERSION);
+  const p = parseArgs(argv);
+  if (bool(p, "strict")) process.env.MAP_STRICT = "1";
+  if (bool(p, "version") || p.cmd === "version") {
+    process.stdout.write(`${VERSION}
+`);
+    return 0;
+  }
+  if (p.cmd === "" || p.cmd === "help" || bool(p, "help")) {
+    process.stdout.write(HELP);
+    return 0;
+  }
+  switch (p.cmd) {
+    case "get":
+      return getCmd(p);
+    case "diff":
+      return diffCmd(p);
+    case "send":
+      return sendCmd(p);
+    case "update":
+      return updateCmd(p);
+    case "wait":
+      return waitCmd(p);
+    case "log":
+      return logCmd(p);
+    case "history":
+      return historyCmd(p);
+    case "show":
+      if (/^p-[0-9a-f]{8}$/.test(p.pos[0] ?? "")) return showPush(p);
+      return readCmd(p);
+    case "status":
+    case "settings":
+      return readCmd(p);
+    case "inbox":
+      return inbox(p);
+    case "approve":
+    case "object":
+    case "argue":
+    case "veto":
+      return act(p);
+    case "whoami": {
+      process.stdout.write(`${await resolveMe(str(p, "from"))}
+`);
+      return 0;
+    }
+    case "create": {
+      const name = (p.pos[0] ?? "").toLowerCase();
+      if (!/^[a-z][a-z0-9]{1,30}$/.test(name)) throw new MapError2("usage: map create <name> [--handle h] [--allow rules] (names are 2 to 31 lowercase letters and digits)");
+      const me = await resolveMe(str(p, "from"));
+      const allow = (str(p, "allow") ?? "").split(",").map((x) => x.trim()).filter(Boolean);
+      const r = await createRepoByEmail(new Mail(me), { name, handle: str(p, "handle"), allow, host: str(p, "host") ?? defaultHost() });
+      if (bool(p, "json")) printJson({ ...r, owner: me, allow });
+      else process.stdout.write(`Created ${r.address}; you (${me}) own it.
+Get it with: map get ${r.address}
+`);
+      return 0;
+    }
+    case "init":
+      return init({
+        provider: str(p, "provider"),
+        yes: bool(p, "yes"),
+        from: str(p, "from"),
+        binDir: str(p, "bin-dir"),
+        home: str(p, "skills-home"),
+        skill: !bool(p, "no-skill"),
+        skillText: SKILL_default,
+        installBins: installBin
+      });
+    case "skill":
+      process.stdout.write(SKILL_default);
+      return 0;
+    case "conformance":
+      return conformanceMain(p, VERSION);
+    default:
+      throw new MapError2(`unknown command "${p.cmd}" (see map help)`);
+  }
+}
+var isMain = (() => {
+  try {
+    return !!process.argv[1] && realpathSync2(process.argv[1]) === realpathSync2(fileURLToPath2(import.meta.url));
+  } catch {
+    return false;
+  }
+})();
+if (isMain || process.env.MAP_FORCE_MAIN) {
+  main(process.argv.slice(2)).then(
+    (code) => {
+      process.exitCode = code;
+    },
+    (e) => {
+      if (e instanceof MapError2 || e?.name === "TransportError") say(`map: ${e.message}`);
+      else say(`map: unexpected error: ${e?.stack ?? String(e)}`);
+      process.exitCode = e instanceof MapError2 ? e.code : 1;
+    }
+  );
+}
+export {
+  DEPRECATED_NOTICE,
+  HELP,
+  main
+};