claude-highlight 1.0.0

package/dist/claude-highlight.js

@@ -0,0 +1,2282 @@
+#!/usr/bin/env bun
+// @bun
+
+// src/claude-highlight.ts
+import { existsSync, mkdirSync, openSync, readFileSync, statSync, writeFileSync, writeSync } from "fs";
+import { basename, dirname, resolve } from "path";
+
+// src/util.ts
+import { homedir } from "os";
+import { join } from "path";
+function configFile(app) {
+  const base = process.env["XDG_CONFIG_HOME"] || join(process.env["HOME"] || homedir(), ".config");
+  return join(base, app, "config.json");
+}
+function decodeIgnore(buf) {
+  let out = "";
+  const n = buf.length;
+  let i = 0;
+  while (i < n) {
+    const b = buf[i] ?? 0;
+    if (b < 128) {
+      out += String.fromCharCode(b);
+      i++;
+      continue;
+    }
+    let len, cp;
+    if (b >= 194 && b <= 223) {
+      len = 2;
+      cp = b & 31;
+    } else if (b >= 224 && b <= 239) {
+      len = 3;
+      cp = b & 15;
+    } else if (b >= 240 && b <= 244) {
+      len = 4;
+      cp = b & 7;
+    } else {
+      i++;
+      continue;
+    }
+    if (i + len > n)
+      break;
+    let ok = true;
+    for (let k = 1;k < len; k++) {
+      const c = buf[i + k] ?? 128;
+      if ((c & 192) !== 128) {
+        ok = false;
+        break;
+      }
+      cp = cp << 6 | c & 63;
+    }
+    if (!ok) {
+      i++;
+      continue;
+    }
+    if (len === 3 && (cp < 2048 || cp >= 55296 && cp <= 57343))
+      ok = false;
+    if (len === 4 && (cp < 65536 || cp > 1114111))
+      ok = false;
+    if (!ok) {
+      i++;
+      continue;
+    }
+    out += String.fromCodePoint(cp);
+    i += len;
+  }
+  return out;
+}
+function environ() {
+  const out = {};
+  for (const [key, value] of Object.entries(process.env)) {
+    if (value !== undefined)
+      out[key] = value;
+  }
+  return out;
+}
+
+// src/highlight_filter.ts
+var WORD_TAIL = /[A-Za-z0-9'_-]+$/;
+var TRANSPARENT = /^\x1b\[\d*[GC]$/;
+var MAX_HOLD = 48;
+var EMPTY = Buffer.alloc(0);
+var SPACE = Buffer.from(" ", "latin1");
+function finditer(pat, s) {
+  const re = pat.global ? pat : new RegExp(pat.source, pat.flags + "g");
+  re.lastIndex = 0;
+  const out = [];
+  let m;
+  while ((m = re.exec(s)) !== null) {
+    out.push({ start: m.index, end: m.index + m[0].length });
+    if (m[0].length === 0)
+      re.lastIndex += 1;
+  }
+  return out;
+}
+function asciiReplace(b) {
+  return b.toString("latin1").replace(/[\u0080-\u00ff]/g, "\uFFFD");
+}
+var isDigits = (s) => /^[0-9]+$/.test(s);
+
+class AnsiHighlighter {
+  rules;
+  onlyUnstyled;
+  rewrites = [];
+  alt = false;
+  holdPrefixes = null;
+  restore = Buffer.from("\x1B[39m", "latin1");
+  state = "GROUND";
+  raw = [];
+  text = [];
+  segs = [];
+  fg = null;
+  bg = null;
+  constructor(rules, onlyUnstyled = true) {
+    this.rules = rules;
+    this.onlyUnstyled = onlyUnstyled;
+  }
+  noteSgr(seq) {
+    if (seq[seq.length - 1] !== 109)
+      return;
+    const params = asciiReplace(seq.subarray(2, seq.length - 1));
+    const toks = params ? params.split(";") : ["0"];
+    let i = 0;
+    while (i < toks.length) {
+      const t = toks[i] || "0";
+      const n = isDigits(t) ? Number(t) : -1;
+      if (n === 0) {
+        this.fg = null;
+        this.bg = null;
+      } else if (n === 39) {
+        this.fg = null;
+      } else if (n === 49) {
+        this.bg = null;
+      } else if (n >= 30 && n <= 37 || n >= 90 && n <= 97) {
+        this.fg = t;
+      } else if (n >= 40 && n <= 47 || n >= 100 && n <= 107) {
+        this.bg = t;
+      } else if (n === 38 || n === 48) {
+        const attr = n === 38 ? "fg" : "bg";
+        if (i + 1 < toks.length && toks[i + 1] === "5") {
+          this[attr] = toks.slice(i, i + 3).join(";");
+          i += 2;
+        } else if (i + 1 < toks.length && toks[i + 1] === "2") {
+          this[attr] = toks.slice(i, i + 5).join(";");
+          i += 4;
+        }
+      }
+      i += 1;
+    }
+  }
+  noteMode(seq) {
+    const last = seq[seq.length - 1];
+    if (last !== 104 && last !== 108 || !seq.includes(63))
+      return;
+    const nums = asciiReplace(seq.subarray(3, seq.length - 1)).split(";");
+    if (nums.some((n) => n === "1049" || n === "1047" || n === "47"))
+      this.alt = last === 104;
+  }
+  pushText() {
+    if (this.text.length) {
+      const styled = this.fg !== null || this.bg !== null;
+      this.segs.push({ data: Buffer.from(this.text), kind: "t", styled });
+      this.text = [];
+    }
+  }
+  static width(kind, data) {
+    return kind === "t" ? data.length : kind === "jump" ? 1 : 0;
+  }
+  static visible(segs) {
+    return Buffer.concat(segs.map((s) => s.kind === "t" ? s.data : s.kind === "jump" ? SPACE : EMPTY));
+  }
+  static split(segs, vpos) {
+    const before = [];
+    const after = [];
+    let seen = 0;
+    for (const s of segs) {
+      const width = AnsiHighlighter.width(s.kind, s.data);
+      if (seen >= vpos && width) {
+        after.push(s);
+      } else if (seen + width <= vpos) {
+        before.push(s);
+      } else if (s.kind !== "t") {
+        after.push(s);
+      } else {
+        const cut = vpos - seen;
+        before.push({ data: s.data.subarray(0, cut), kind: s.kind, styled: s.styled });
+        after.push({ data: s.data.subarray(cut), kind: s.kind, styled: s.styled });
+      }
+      seen += width;
+    }
+    return [before, after];
+  }
+  render(segs) {
+    if (segs.length === 0)
+      return EMPTY;
+    let work = segs;
+    if (this.rewrites.length && !this.alt) {
+      work = segs.map((s) => s.kind === "t" ? { data: this.rewrite(s.data), kind: s.kind, styled: s.styled } : s);
+    }
+    const raw = Buffer.concat(work.map((s) => s.data));
+    const vis = AnsiHighlighter.visible(work);
+    const visStr = vis.toString("latin1");
+    const blocked = [];
+    let seen = 0;
+    for (const s of work) {
+      const w = AnsiHighlighter.width(s.kind, s.data);
+      if (s.kind === "t" && s.styled)
+        blocked.push([seen, seen + w]);
+      seen += w;
+    }
+    const spans = [];
+    for (const { pat, style } of this.rules) {
+      for (const m of finditer(pat, visStr)) {
+        if (this.onlyUnstyled && blocked.some(([a, b]) => a < m.end && m.start < b))
+          continue;
+        if (!spans.some(([a, b]) => a < m.end && m.start < b)) {
+          let end = m.end;
+          while (end > m.start && visStr.charCodeAt(end - 1) === 32)
+            end -= 1;
+          spans.push([m.start, end, style]);
+        }
+      }
+    }
+    if (spans.length === 0)
+      return raw;
+    const marks = new Map;
+    const mark = (pos, b) => {
+      marks.set(pos, Buffer.concat([marks.get(pos) ?? EMPTY, b]));
+    };
+    for (const [a, b, style] of spans) {
+      mark(a, style);
+      mark(b, this.restore);
+    }
+    const out = [];
+    let vpos = 0;
+    for (const s of work) {
+      if (s.kind !== "t") {
+        const mk = marks.get(vpos);
+        if (mk !== undefined) {
+          out.push(mk);
+          marks.delete(vpos);
+        }
+        out.push(s.data);
+        vpos += AnsiHighlighter.width(s.kind, s.data);
+      } else {
+        const t = s.data;
+        let i = 0;
+        const hits = [...marks.keys()].filter((k) => vpos <= k && k <= vpos + t.length).sort((x, y) => x - y);
+        for (const pos of hits) {
+          const cut = pos - vpos;
+          out.push(t.subarray(i, cut));
+          out.push(marks.get(pos) ?? EMPTY);
+          marks.delete(pos);
+          i = cut;
+        }
+        out.push(t.subarray(i));
+        vpos += t.length;
+      }
+    }
+    const tail = marks.get(vpos);
+    if (tail !== undefined)
+      out.push(tail);
+    return Buffer.concat(out);
+  }
+  rewrite(text) {
+    let s = text.toString("latin1");
+    for (const { pat, repl } of this.rewrites) {
+      pat.lastIndex = 0;
+      s = s.replace(pat, repl);
+    }
+    return Buffer.from(s, "latin1");
+  }
+  flushText(hold) {
+    this.pushText();
+    const segs = this.segs;
+    if (segs.length === 0)
+      return EMPTY;
+    const vis = AnsiHighlighter.visible(segs);
+    const visStr = vis.toString("latin1");
+    let start = vis.length;
+    if (hold && vis.length) {
+      if (this.holdPrefixes !== null) {
+        for (let pos = Math.max(0, vis.length - MAX_HOLD);pos < vis.length; pos++) {
+          const tail = decodeIgnore(vis.subarray(pos)).toLowerCase();
+          if (tail && this.holdPrefixes.has(tail)) {
+            start = pos;
+            break;
+          }
+        }
+      } else {
+        const m = WORD_TAIL.exec(visStr);
+        if (m && vis.length - m.index <= MAX_HOLD)
+          start = m.index;
+      }
+      if (start < vis.length) {
+        for (const { pat } of this.rules) {
+          for (const m of finditer(pat, visStr)) {
+            if (m.start < start && start < m.end)
+              start = m.start;
+          }
+        }
+      }
+    }
+    const [emit, keep] = AnsiHighlighter.split(segs, start);
+    this.segs = keep;
+    return this.render(emit);
+  }
+  feed(chunk) {
+    const out = [];
+    for (const b of chunk) {
+      if (this.state === "GROUND") {
+        if (b === 27) {
+          this.state = "ESC";
+          this.raw = [b];
+        } else {
+          this.text.push(b);
+          if (b === 10 || b === 13 || b === 8 || b === 9) {
+            out.push(this.flushText(false));
+          }
+        }
+        continue;
+      }
+      this.raw.push(b);
+      if (this.state === "ESC") {
+        if (b === 91) {
+          this.state = "CSI";
+        } else if (b === 93) {
+          this.state = "OSC";
+        } else if (b === 80 || b === 88 || b === 94 || b === 95) {
+          this.state = "DCS";
+        } else if (b >= 32 && b <= 47) {
+          this.state = "ESCI";
+        } else {
+          out.push(this.flushText(false));
+          out.push(Buffer.from(this.raw));
+          this.state = "GROUND";
+          this.raw = [];
+        }
+      } else if (this.state === "CSI") {
+        if (b >= 64 && b <= 126) {
+          const seq = Buffer.from(this.raw);
+          if (TRANSPARENT.test(seq.toString("latin1"))) {
+            this.pushText();
+            this.segs.push({ data: seq, kind: "jump", styled: false });
+          } else if (b === 109) {
+            this.pushText();
+            this.noteSgr(seq);
+            this.segs.push({ data: seq, kind: "sgr", styled: false });
+          } else {
+            this.noteMode(seq);
+            out.push(this.flushText(false));
+            out.push(seq);
+          }
+          this.state = "GROUND";
+          this.raw = [];
+        }
+      } else if (this.state === "ESCI") {
+        if (b >= 48 && b <= 126) {
+          out.push(this.flushText(false));
+          out.push(Buffer.from(this.raw));
+          this.state = "GROUND";
+          this.raw = [];
+        }
+      } else {
+        const n = this.raw.length;
+        if (b === 7 || n >= 2 && this.raw[n - 2] === 27 && this.raw[n - 1] === 92) {
+          out.push(this.flushText(false));
+          out.push(Buffer.from(this.raw));
+          this.state = "GROUND";
+          this.raw = [];
+        }
+      }
+    }
+    out.push(this.flushText(true));
+    return Buffer.concat(out);
+  }
+  drain(force = true) {
+    if (this.state !== "GROUND" && !force)
+      return EMPTY;
+    return this.flushText(!force);
+  }
+}
+
+// src/hedge_lexicon.ts
+var LEXICON = {
+  inference: [
+    "likely",
+    "probably",
+    "presumably",
+    "most likely",
+    "chances are",
+    "i suspect",
+    "i'd (?:guess|bet|expect)",
+    "my guess",
+    "i imagine",
+    "chances? (?:are|of)",
+    "chances are"
+  ],
+  appearance: [
+    "seems?(?: (?:to|like|that))?",
+    "appears?(?: (?:to|that))?",
+    "looks like",
+    "apparently",
+    "ostensibly",
+    "supposedly",
+    "as far as i can tell",
+    "from what i can see",
+    "on the surface"
+  ],
+  assumption: [
+    "assuming",
+    "i(?:'m| am) assuming",
+    "assumption",
+    "presuming",
+    "if i'm right",
+    "in theory",
+    "in principle",
+    "on paper",
+    "should (?:work|be|already|still)",
+    "ought to",
+    "by design",
+    "mostly"
+  ],
+  modal: [
+    "might",
+    "may (?:be|have|not|still|need|want|require)",
+    "could be",
+    "can be",
+    "possibly",
+    "potentially",
+    "perhaps",
+    "conceivably"
+  ],
+  unknown: [
+    "not sure",
+    "unsure",
+    "unclear",
+    "hard to say",
+    "i don'?t know",
+    "can'?t tell",
+    "can'?t verify",
+    "couldn'?t verify",
+    "can'?t (?:test|check|confirm|reproduce|measure|be sure)",
+    "couldn'?t (?:test|check|confirm|reproduce)",
+    "no (?:easy )?way to (?:test|check|reproduce)",
+    "no way to (?:know|tell|check)",
+    "unverified",
+    "untested",
+    "haven'?t (?:tested|verified|checked|run|confirmed)",
+    "didn'?t (?:test|verify|check|run|confirm)",
+    "without (?:testing|running|checking)",
+    "needs? (?:testing|verification|confirmation)",
+    "i'd need to (?:check|verify|test|look)"
+  ],
+  vagueness: [
+    "roughly",
+    "approximately",
+    "about \\d",
+    "or so",
+    "a (?:few|couple)",
+    "several",
+    "various",
+    "some(?:what)?",
+    "generally",
+    "typically",
+    "usually",
+    "often",
+    "in most cases",
+    "more or less",
+    "basically",
+    "essentially",
+    "effectively",
+    "pretty much"
+  ],
+  overclaim: [
+    "definitely",
+    "certainly",
+    "obviously",
+    "clearly",
+    "of course",
+    "without a doubt",
+    "guaranteed",
+    "always works",
+    "never fails",
+    "trivially",
+    "simply (?:add|change|run|do)",
+    "just (?:add|change|run|do)"
+  ],
+  softener: [
+    "a bit",
+    "slightly",
+    "somewhat",
+    "fairly",
+    "relatively",
+    "more or less",
+    "kind of",
+    "sort of",
+    "to some extent",
+    "at least in",
+    "for the most part"
+  ]
+};
+function expand(term) {
+  const chAt = (s, i) => i < s.length ? s.charAt(i) : "";
+  function seq(i, stop) {
+    let out = [""];
+    while (i < term.length && (stop === null || !stop.includes(chAt(term, i)))) {
+      const c = chAt(term, i);
+      if (c === "(") {
+        let [alts, ni] = alternatives(i + 3);
+        i = ni + 1;
+        if (i < term.length && chAt(term, i) === "?") {
+          i += 1;
+          alts = [...alts, ""];
+        }
+        out = out.flatMap((a) => alts.map((b) => a + b));
+      } else if (c === "\\") {
+        const nxt = chAt(term, i + 1);
+        if (nxt === "")
+          throw new Error("trailing backslash");
+        const pool = nxt === "d" ? "0123456789" : nxt;
+        out = out.flatMap((a) => [...pool].map((d) => a + d));
+        i += 2;
+      } else if (chAt(term, i + 1) === "?") {
+        out = [...out.map((a) => a + c), ...out];
+        i += 2;
+      } else {
+        out = out.map((a) => a + c);
+        i += 1;
+      }
+    }
+    return [out, i];
+  }
+  function alternatives(i) {
+    const alts = [];
+    while (true) {
+      const [opts, ni] = seq(i, "|)");
+      alts.push(...opts);
+      if (ni < term.length && chAt(term, ni) === "|") {
+        i = ni + 1;
+        continue;
+      }
+      return [alts, ni];
+    }
+  }
+  return seq(0, null)[0];
+}
+function userPattern(term) {
+  return term.startsWith("re:") ? term.slice(3) : term.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function literals(extra = []) {
+  const out = new Set;
+  for (const terms of [...Object.values(LEXICON), extra]) {
+    for (const t of terms) {
+      try {
+        for (const x of expand(t))
+          if (x.length > 0)
+            out.add(x.toLowerCase());
+      } catch {}
+    }
+  }
+  return out;
+}
+function growablePrefixes(extra = []) {
+  const lits = literals(extra);
+  const out = new Set;
+  for (const lit of lits) {
+    for (let n = 1;n < lit.length; n++)
+      out.add(lit.slice(0, n));
+  }
+  return out;
+}
+
+// src/screen_model.ts
+var CSI = /\x1b\[([\x30-\x3f]*)([\x20-\x2f]*)([\x40-\x7e])/y;
+var FRAME_END = /\x1b\[\?2026l/g;
+var PARTIAL_CSI = /^\x1b\[[\x30-\x3f]*[\x20-\x2f]*$/;
+var MAX_FIX = 4096;
+var MAX_PENDING = 4096;
+var RULE_CHARS = new Set("\u2500\u2501\u254C\u254D\u2504\u2505\u2508\u2509\u2502\u2503\u256D\u256E\u2570\u256F\u250C\u2510\u2514\u2518\u251C\u2524\u252C\u2534\u253C");
+var BOTTOM_CHROME = 10;
+var MAX_COMPOSER = 24;
+var WIDE = [
+  4352,
+  4447,
+  8986,
+  8987,
+  9001,
+  9002,
+  9193,
+  9196,
+  9200,
+  9200,
+  9203,
+  9203,
+  9725,
+  9726,
+  9748,
+  9749,
+  9776,
+  9783,
+  9800,
+  9811,
+  9855,
+  9855,
+  9866,
+  9871,
+  9875,
+  9875,
+  9889,
+  9889,
+  9898,
+  9899,
+  9917,
+  9918,
+  9924,
+  9925,
+  9934,
+  9934,
+  9940,
+  9940,
+  9962,
+  9962,
+  9970,
+  9971,
+  9973,
+  9973,
+  9978,
+  9978,
+  9981,
+  9981,
+  9989,
+  9989,
+  9994,
+  9995,
+  10024,
+  10024,
+  10060,
+  10060,
+  10062,
+  10062,
+  10067,
+  10069,
+  10071,
+  10071,
+  10133,
+  10135,
+  10160,
+  10160,
+  10175,
+  10175,
+  11035,
+  11036,
+  11088,
+  11088,
+  11093,
+  11093,
+  11904,
+  11929,
+  11931,
+  12019,
+  12032,
+  12245,
+  12272,
+  12350,
+  12353,
+  12438,
+  12441,
+  12543,
+  12549,
+  12591,
+  12593,
+  12686,
+  12688,
+  12773,
+  12783,
+  12830,
+  12832,
+  12871,
+  12880,
+  42124,
+  42128,
+  42182,
+  43360,
+  43388,
+  44032,
+  55203,
+  63744,
+  64255,
+  65040,
+  65049,
+  65072,
+  65106,
+  65108,
+  65126,
+  65128,
+  65131,
+  65281,
+  65376,
+  65504,
+  65510,
+  94176,
+  94180,
+  94192,
+  94193,
+  94208,
+  100343,
+  100352,
+  101589,
+  101631,
+  101640,
+  110576,
+  110579,
+  110581,
+  110587,
+  110589,
+  110590,
+  110592,
+  110882,
+  110898,
+  110898,
+  110928,
+  110930,
+  110933,
+  110933,
+  110948,
+  110951,
+  110960,
+  111355,
+  119552,
+  119638,
+  119648,
+  119670,
+  126980,
+  126980,
+  127183,
+  127183,
+  127374,
+  127374,
+  127377,
+  127386,
+  127488,
+  127490,
+  127504,
+  127547,
+  127552,
+  127560,
+  127568,
+  127569,
+  127584,
+  127589,
+  127744,
+  127776,
+  127789,
+  127797,
+  127799,
+  127868,
+  127870,
+  127891,
+  127904,
+  127946,
+  127951,
+  127955,
+  127968,
+  127984,
+  127988,
+  127988,
+  127992,
+  128062,
+  128064,
+  128064,
+  128066,
+  128252,
+  128255,
+  128317,
+  128331,
+  128334,
+  128336,
+  128359,
+  128378,
+  128378,
+  128405,
+  128406,
+  128420,
+  128420,
+  128507,
+  128591,
+  128640,
+  128709,
+  128716,
+  128716,
+  128720,
+  128722,
+  128725,
+  128727,
+  128732,
+  128735,
+  128747,
+  128748,
+  128756,
+  128764,
+  128992,
+  129003,
+  129008,
+  129008,
+  129292,
+  129338,
+  129340,
+  129349,
+  129351,
+  129535,
+  129648,
+  129660,
+  129664,
+  129673,
+  129679,
+  129734,
+  129742,
+  129756,
+  129759,
+  129769,
+  129776,
+  129784,
+  131072,
+  196605,
+  196608,
+  262141
+];
+var ZERO = /[\p{Mn}\p{Me}\p{Cf}]/u;
+var ZERO_EXTRA = new Set([
+  5909,
+  5940,
+  6980,
+  7082,
+  7154,
+  7155,
+  12334,
+  12335,
+  43347,
+  43456,
+  70080,
+  70197,
+  70477,
+  70607,
+  71350,
+  71997,
+  73537,
+  94192,
+  94193,
+  119141,
+  119142,
+  119149,
+  119150,
+  119151,
+  119152,
+  119153,
+  119154
+].map((c) => String.fromCodePoint(c)));
+function cellWidth(ch) {
+  const cp = ch.codePointAt(0) ?? 0;
+  if (cp < 173)
+    return 1;
+  if (ZERO.test(ch) || ZERO_EXTRA.has(ch))
+    return 0;
+  let lo = 0, hi = WIDE.length / 2 - 1;
+  while (lo <= hi) {
+    const mid = lo + hi >> 1;
+    if (cp < WIDE[mid * 2])
+      hi = mid - 1;
+    else if (cp > WIDE[mid * 2 + 1])
+      lo = mid + 1;
+    else
+      return 2;
+  }
+  return 1;
+}
+
+class ScreenModel {
+  palette;
+  rows;
+  cols;
+  chars;
+  fg;
+  ours;
+  rule;
+  x;
+  y;
+  curFg;
+  curOurs;
+  saved;
+  top;
+  bot;
+  alt;
+  wrapPending;
+  dirty;
+  pending;
+  inFrame;
+  constructor(rows, cols, palette = []) {
+    this.palette = new Set(palette);
+    this.resize(rows, cols);
+  }
+  resize(rows, cols) {
+    this.rows = Math.max(rows, 1);
+    this.cols = Math.max(cols, 1);
+    this.invalidate();
+  }
+  invalidate() {
+    this.chars = Array.from({ length: this.rows }, () => new Array(this.cols).fill(null));
+    this.fg = Array.from({ length: this.rows }, () => new Array(this.cols).fill(null));
+    this.ours = Array.from({ length: this.rows }, () => new Array(this.cols).fill(false));
+    this.rule = new Array(this.rows).fill(null);
+    this.x = this.y = 0;
+    this.curFg = null;
+    this.curOurs = false;
+    this.saved = [0, 0, null];
+    this.top = 0;
+    this.bot = this.rows - 1;
+    this.alt = false;
+    this.wrapPending = false;
+    this.dirty = new Set;
+    this.pending = Buffer.alloc(0);
+    this.inFrame = false;
+  }
+  blankRow() {
+    return [
+      new Array(this.cols).fill(null),
+      new Array(this.cols).fill(null),
+      new Array(this.cols).fill(false)
+    ];
+  }
+  set(x, ch) {
+    this.chars[this.y][x] = ch;
+    this.fg[this.y][x] = this.curFg;
+    this.ours[this.y][x] = this.curOurs;
+    this.dirty.add(this.y);
+    this.rule[this.y] = null;
+  }
+  put(text) {
+    for (const ch of text) {
+      const w = cellWidth(ch);
+      if (w === 0)
+        continue;
+      if (this.wrapPending || this.x + w > this.cols) {
+        this.x = 0;
+        this.index();
+        this.wrapPending = false;
+      }
+      this.set(this.x, ch);
+      if (w === 2 && this.x + 1 < this.cols)
+        this.set(this.x + 1, "");
+      this.x += w;
+      if (this.x >= this.cols) {
+        this.x = this.cols - 1;
+        this.wrapPending = true;
+      }
+    }
+  }
+  index() {
+    if (this.y === this.bot)
+      this.scroll(1);
+    else
+      this.y = Math.min(this.y + 1, this.rows - 1);
+  }
+  scroll(n, up = true) {
+    for (let k = 0;k < Math.max(n, 1); k++) {
+      const [c, f, o] = this.blankRow();
+      if (up) {
+        this.chars.splice(this.top, 1);
+        this.chars.splice(this.bot, 0, c);
+        this.fg.splice(this.top, 1);
+        this.fg.splice(this.bot, 0, f);
+        this.ours.splice(this.top, 1);
+        this.ours.splice(this.bot, 0, o);
+      } else {
+        this.chars.splice(this.bot, 1);
+        this.chars.splice(this.top, 0, c);
+        this.fg.splice(this.bot, 1);
+        this.fg.splice(this.top, 0, f);
+        this.ours.splice(this.bot, 1);
+        this.ours.splice(this.top, 0, o);
+      }
+    }
+    for (let y = this.top;y <= this.bot; y++)
+      this.dirty.add(y);
+    this.rule = new Array(this.rows).fill(null);
+  }
+  sgr(params) {
+    const toks = params ? params.split(";") : ["0"];
+    let i = 0;
+    while (i < toks.length) {
+      const t = toks[i] || "0";
+      const n = /^[0-9]+$/.test(t) ? parseInt(t, 10) : -1;
+      if (n === 0 || n === 39) {
+        this.curFg = null;
+      } else if (n >= 30 && n <= 37 || n >= 90 && n <= 97) {
+        this.curFg = t;
+      } else if (n === 38) {
+        if (toks[i + 1] === "5") {
+          this.curFg = toks.slice(i, i + 3).join(";");
+          i += 2;
+        } else if (toks[i + 1] === "2") {
+          this.curFg = toks.slice(i, i + 5).join(";");
+          i += 4;
+        }
+      }
+      i += 1;
+    }
+    this.curOurs = this.curFg !== null && this.palette.has(this.curFg);
+  }
+  erase(cells) {
+    for (const x of cells) {
+      this.chars[this.y][x] = " ";
+      this.fg[this.y][x] = null;
+      this.ours[this.y][x] = false;
+    }
+    this.dirty.add(this.y);
+    this.rule[this.y] = null;
+  }
+  csi(priv, fin, params) {
+    const parts = params ? params.split(";") : [];
+    const nums = parts.map((p) => /^[0-9]+$/.test(p) ? parseInt(p, 10) : 0);
+    const a = nums.length ? nums[0] : 0;
+    if (priv) {
+      if ((fin === "h" || fin === "l") && parts.some((p) => p === "1049" || p === "1047" || p === "47")) {
+        this.invalidate();
+        this.alt = fin === "h";
+      } else if ((fin === "h" || fin === "l") && parts.includes("2026")) {
+        this.inFrame = fin === "h";
+      }
+      return;
+    }
+    if (fin === "H" || fin === "f") {
+      this.y = Math.max(0, Math.min(nums.length ? nums[0] - 1 : 0, this.rows - 1));
+      this.x = Math.max(0, Math.min(nums.length > 1 ? nums[1] - 1 : 0, this.cols - 1));
+      this.wrapPending = false;
+    } else if (fin === "A") {
+      this.y = Math.max(0, this.y - Math.max(a, 1));
+      this.wrapPending = false;
+    } else if (fin === "B") {
+      this.y = Math.min(this.rows - 1, this.y + Math.max(a, 1));
+      this.wrapPending = false;
+    } else if (fin === "C") {
+      this.x = Math.min(this.cols - 1, this.x + Math.max(a, 1));
+      this.wrapPending = false;
+    } else if (fin === "D") {
+      this.x = Math.max(0, this.x - Math.max(a, 1));
+      this.wrapPending = false;
+    } else if (fin === "E") {
+      this.y = Math.min(this.rows - 1, this.y + Math.max(a, 1));
+      this.x = 0;
+    } else if (fin === "F") {
+      this.y = Math.max(0, this.y - Math.max(a, 1));
+      this.x = 0;
+    } else if (fin === "G") {
+      this.x = Math.max(0, Math.min((a || 1) - 1, this.cols - 1));
+      this.wrapPending = false;
+    } else if (fin === "d") {
+      this.y = Math.max(0, Math.min((a || 1) - 1, this.rows - 1));
+    } else if (fin === "K") {
+      if (a === 1)
+        this.erase(span(0, this.x + 1));
+      else if (a === 2)
+        this.erase(span(0, this.cols));
+      else
+        this.erase(span(this.x, this.cols));
+    } else if (fin === "J") {
+      if (a === 2 || a === 3) {
+        for (let y = 0;y < this.rows; y++) {
+          this.y = y;
+          this.erase(span(0, this.cols));
+        }
+        this.y = 0;
+      } else if (a === 0) {
+        this.erase(span(this.x, this.cols));
+        const keep = this.y;
+        for (let y = keep + 1;y < this.rows; y++) {
+          this.y = y;
+          this.erase(span(0, this.cols));
+        }
+        this.y = keep;
+      }
+    } else if (fin === "X") {
+      this.erase(span(this.x, Math.min(this.x + Math.max(a, 1), this.cols)));
+    } else if (fin === "S") {
+      this.scroll(a, true);
+    } else if (fin === "T") {
+      this.scroll(a, false);
+    } else if (fin === "L" || fin === "M") {
+      const n = Math.max(a, 1);
+      for (let k = 0;k < n; k++) {
+        const [c, f, o] = this.blankRow();
+        const at = fin === "L" ? this.y : this.bot;
+        const from = fin === "L" ? this.bot : this.y;
+        this.chars.splice(from, 1);
+        this.chars.splice(at, 0, c);
+        this.fg.splice(from, 1);
+        this.fg.splice(at, 0, f);
+        this.ours.splice(from, 1);
+        this.ours.splice(at, 0, o);
+      }
+      for (let y = this.y;y <= this.bot; y++)
+        this.dirty.add(y);
+      this.rule = new Array(this.rows).fill(null);
+    } else if (fin === "P" || fin === "@") {
+      const n = Math.max(a, 1);
+      const chars = this.chars[this.y], fg = this.fg[this.y], ours = this.ours[this.y];
+      if (fin === "P") {
+        chars.splice(this.x, n);
+        while (chars.length < this.cols)
+          chars.push(null);
+        fg.splice(this.x, n);
+        while (fg.length < this.cols)
+          fg.push(null);
+        ours.splice(this.x, n);
+        while (ours.length < this.cols)
+          ours.push(false);
+      } else {
+        for (let k = 0;k < n; k++) {
+          chars.splice(this.x, 0, null);
+          chars.pop();
+          fg.splice(this.x, 0, null);
+          fg.pop();
+          ours.splice(this.x, 0, false);
+          ours.pop();
+        }
+      }
+      this.dirty.add(this.y);
+      this.rule[this.y] = null;
+    } else if (fin === "r") {
+      this.top = Math.max(0, nums.length ? nums[0] - 1 : 0);
+      this.bot = Math.min(this.rows - 1, nums.length > 1 ? nums[1] - 1 : this.rows - 1);
+      if (this.top >= this.bot) {
+        this.top = 0;
+        this.bot = this.rows - 1;
+      }
+      this.x = this.y = 0;
+    } else if (fin === "m") {
+      this.sgr(params);
+    }
+  }
+  static partialUtf8(data) {
+    for (let back = 1;back <= Math.min(4, data.length); back++) {
+      const b = data[data.length - back];
+      if (b < 128)
+        return 0;
+      if (b >= 192) {
+        const need = b < 224 ? 2 : b < 240 ? 3 : 4;
+        return back < need ? back : 0;
+      }
+    }
+    return 0;
+  }
+  feed(data) {
+    if (this.pending.length) {
+      data = Buffer.concat([this.pending, data]);
+      this.pending = Buffer.alloc(0);
+    }
+    const s = data.toString("latin1");
+    let i = 0;
+    const n = data.length;
+    while (i < n) {
+      const b = data[i];
+      if (b === 27) {
+        CSI.lastIndex = i;
+        const m = CSI.exec(s);
+        if (m) {
+          const p = m[1];
+          const priv = "?><=".includes(p.slice(0, 1)) ? p.slice(0, 1) : "";
+          this.csi(priv, m[3], p.slice(priv.length));
+          i = CSI.lastIndex;
+          continue;
+        }
+        const nxt = data[i + 1];
+        if (nxt === undefined || nxt === 91 && PARTIAL_CSI.test(s.slice(i))) {
+          return this.hold(data.subarray(i));
+        }
+        if (nxt >= 32 && nxt <= 47) {
+          let j = i + 1;
+          while (j < n && data[j] >= 32 && data[j] <= 47)
+            j++;
+          if (j >= n)
+            return this.hold(data.subarray(i));
+          i = j + 1;
+          continue;
+        }
+        if (nxt === 80 || nxt === 88 || nxt === 94 || nxt === 95 || nxt === 93) {
+          const bel = s.indexOf("\x07", i + 2);
+          const st = s.indexOf("\x1B\\", i + 2);
+          const ends = [bel, st].filter((j) => j !== -1);
+          if (!ends.length)
+            return this.hold(data.subarray(i));
+          const end = Math.min(...ends);
+          i = end + (end === bel ? 1 : 2);
+          continue;
+        }
+        if (nxt === 55) {
+          this.saved = [this.x, this.y, this.curFg];
+        } else if (nxt === 56) {
+          [this.x, this.y, this.curFg] = this.saved;
+          this.curOurs = this.curFg !== null && this.palette.has(this.curFg);
+        } else if (nxt === 77) {
+          if (this.y === this.top)
+            this.scroll(1, false);
+          else
+            this.y = Math.max(0, this.y - 1);
+        }
+        i += 2;
+        continue;
+      }
+      if (b === 10) {
+        this.index();
+        this.wrapPending = false;
+        i += 1;
+        continue;
+      }
+      if (b === 13) {
+        this.x = 0;
+        this.wrapPending = false;
+        i += 1;
+        continue;
+      }
+      if (b === 8) {
+        this.x = Math.max(0, this.x - 1);
+        this.wrapPending = false;
+        i += 1;
+        continue;
+      }
+      if (b === 9) {
+        this.x = Math.min(this.cols - 1, (Math.floor(this.x / 8) + 1) * 8);
+        i += 1;
+        continue;
+      }
+      let j = i;
+      while (j < n && data[j] >= 32 && data[j] !== 27)
+        j++;
+      if (j === i) {
+        i += 1;
+        continue;
+      }
+      let run = data.subarray(i, j);
+      if (j === n) {
+        const cut = ScreenModel.partialUtf8(run);
+        if (cut) {
+          const hold = run.subarray(run.length - cut);
+          run = run.subarray(0, run.length - cut);
+          this.put(run.toString("utf8"));
+          return this.hold(hold);
+        }
+      }
+      this.put(run.toString("utf8"));
+      i = j;
+    }
+  }
+  hold(tail) {
+    this.pending = tail.length <= MAX_PENDING ? Buffer.from(tail) : Buffer.alloc(0);
+  }
+  isRule(y) {
+    const cached = this.rule[y];
+    if (cached !== null && cached !== undefined)
+      return cached;
+    let marks = 0, other = 0;
+    for (const c of this.chars[y]) {
+      if (c !== null && RULE_CHARS.has(c))
+        marks += 1;
+      else if (c !== null && c !== "" && c !== " ") {
+        other += 1;
+        break;
+      }
+    }
+    const v = other === 0 && marks >= this.cols * 0.8;
+    this.rule[y] = v;
+    return v;
+  }
+  composerRows() {
+    const rules = [];
+    for (let y = this.rows - 1;y > Math.max(this.rows - 32, -1); y--) {
+      if (this.isRule(y))
+        rules.push(y);
+    }
+    const low = rules[0];
+    if (low === undefined || low < this.rows - BOTTOM_CHROME)
+      return [];
+    let top = low;
+    for (const y of rules.slice(1)) {
+      if (low - y <= MAX_COMPOSER) {
+        top = y;
+        break;
+      }
+    }
+    return span(top, this.rows);
+  }
+  rowBytes(y) {
+    const parts = [];
+    const idx = [];
+    const row = this.chars[y];
+    for (let x = 0;x < row.length; x++) {
+      const ch = row[x];
+      if (ch === "")
+        continue;
+      const enc = Buffer.from(ch ? ch : " ", "utf8");
+      parts.push(enc);
+      for (let k = 0;k < enc.length; k++)
+        idx.push(x);
+    }
+    return [Buffer.concat(parts), idx];
+  }
+  desired(y, rules, onlyUnstyled, offLimits = []) {
+    if (offLimits.includes(y)) {
+      return new Array(this.cols).fill(null);
+    }
+    const [buf, idx] = this.rowBytes(y);
+    const text = buf.toString("latin1");
+    const want = new Array(this.cols).fill(null);
+    for (const { pat, style } of rules) {
+      const fg = style.subarray(2, style.length - 1).toString("latin1");
+      for (const m of text.matchAll(pat)) {
+        const start = m.index;
+        let end = start + m[0].length;
+        while (end > start && text[end - 1] === " ")
+          end -= 1;
+        if (end <= start)
+          continue;
+        const cells = span(idx[start], idx[end - 1] + 1);
+        if (cells.some((c) => want[c] !== null))
+          continue;
+        if (onlyUnstyled && cells.some((c) => this.fg[y][c] !== null && !this.ours[y][c])) {
+          continue;
+        }
+        for (const c of cells)
+          want[c] = fg;
+      }
+    }
+    return want;
+  }
+  corrections(rules, onlyUnstyled = true) {
+    if (!this.alt || this.dirty.size === 0)
+      return Buffer.alloc(0);
+    const rows = [...this.dirty].sort((p, q) => p - q);
+    this.dirty = new Set;
+    const offLimits = this.composerRows();
+    const out = [];
+    let len = 0, spent = false;
+    for (const y of rows) {
+      if (spent) {
+        this.dirty.add(y);
+        continue;
+      }
+      if (!this.ours[y].some((v) => v))
+        continue;
+      const want = this.desired(y, rules, onlyUnstyled, offLimits);
+      let x = 0;
+      while (x < this.cols) {
+        if (!(this.ours[y][x] && this.fg[y][x] !== want[x])) {
+          x += 1;
+          continue;
+        }
+        let start = x;
+        const target = want[x];
+        while (x < this.cols && this.ours[y][x] && this.fg[y][x] !== want[x] && want[x] === target)
+          x += 1;
+        if (this.chars[y][start] === "" && start)
+          start -= 1;
+        const text = this.chars[y].slice(start, x).filter((c) => c !== "" && c !== null).join("");
+        if (!text)
+          continue;
+        const fix = Buffer.concat([
+          Buffer.from(`\x1B[${y + 1};${start + 1}H`, "latin1"),
+          Buffer.from(target ? `\x1B[${target}m` : "\x1B[39m", "latin1"),
+          Buffer.from(text, "utf8")
+        ]);
+        if (len + fix.length > MAX_FIX) {
+          this.dirty.add(y);
+          spent = true;
+          break;
+        }
+        out.push(fix);
+        len += fix.length;
+        for (let c = start;c < x; c++) {
+          this.fg[y][c] = target;
+          this.ours[y][c] = target !== null;
+        }
+      }
+    }
+    if (!len)
+      return Buffer.alloc(0);
+    return Buffer.concat([
+      Buffer.from("\x1B7\x1B[?7l", "latin1"),
+      ...out,
+      Buffer.from("\x1B[?7h\x1B8", "latin1")
+    ]);
+  }
+  reconcile(data, rules, onlyUnstyled = true) {
+    if (!data.length)
+      return data;
+    const out = [];
+    let i = 0;
+    for (const m of data.toString("latin1").matchAll(FRAME_END)) {
+      const seg = data.subarray(i, m.index);
+      this.feed(seg);
+      out.push(seg);
+      out.push(this.corrections(rules, onlyUnstyled));
+      const mark = data.subarray(m.index, m.index + m[0].length);
+      out.push(mark);
+      this.feed(mark);
+      i = m.index + m[0].length;
+    }
+    const tail = data.subarray(i);
+    this.feed(tail);
+    out.push(tail);
+    if (tail.length && !this.inFrame) {
+      out.push(this.corrections(rules, onlyUnstyled));
+    }
+    return Buffer.concat(out);
+  }
+}
+function span(a, b) {
+  const out = [];
+  for (let i = a;i < b; i++)
+    out.push(i);
+  return out;
+}
+
+// src/pty.ts
+import { closeSync } from "fs";
+
+// src/sysffi.ts
+import { dlopen, FFIType } from "bun:ffi";
+var APPLE_VARARGS = process.platform === "darwin" && process.arch === "arm64";
+var IOCTL_PAD = [
+  FFIType.u64,
+  FFIType.u64,
+  FFIType.u64,
+  FFIType.u64,
+  FFIType.u64,
+  FFIType.u64
+];
+var IOCTL = {
+  ioctl: {
+    args: APPLE_VARARGS ? [FFIType.i32, FFIType.u64, ...IOCTL_PAD, FFIType.ptr] : [FFIType.i32, FFIType.u64, FFIType.ptr],
+    returns: FFIType.i32
+  }
+};
+var CORE = {
+  read: { args: [FFIType.i32, FFIType.ptr, FFIType.u64], returns: FFIType.i64 },
+  write: { args: [FFIType.i32, FFIType.ptr, FFIType.u64], returns: FFIType.i64 },
+  close: { args: [FFIType.i32], returns: FFIType.i32 },
+  kill: { args: [FFIType.i32, FFIType.i32], returns: FFIType.i32 },
+  tcgetattr: { args: [FFIType.i32, FFIType.ptr], returns: FFIType.i32 },
+  tcsetattr: { args: [FFIType.i32, FFIType.i32, FFIType.ptr], returns: FFIType.i32 },
+  cfmakeraw: { args: [FFIType.ptr], returns: FFIType.i32 }
+};
+var OPENPTY = {
+  openpty: {
+    args: [FFIType.ptr, FFIType.ptr, FFIType.ptr, FFIType.ptr, FFIType.ptr],
+    returns: FFIType.i32
+  }
+};
+function bind(symbols) {
+  return symbols;
+}
+function load() {
+  if (process.platform === "darwin") {
+    const lib = dlopen("/usr/lib/libSystem.dylib", { ...CORE, ...IOCTL, ...OPENPTY });
+    const syms = bind(lib.symbols);
+    return { core: syms, openpty: syms };
+  }
+  const core = bind(dlopen("libc.so.6", { ...CORE, ...IOCTL }).symbols);
+  for (const name of ["libc.so.6", "libutil.so.1", "libutil.so"]) {
+    try {
+      return { core, openpty: bind(dlopen(name, OPENPTY).symbols) };
+    } catch {}
+  }
+  throw new Error("openpty not found in libc.so.6, libutil.so.1 or libutil.so");
+}
+var ffi = load();
+var TCSANOW = 0;
+var TIOCGWINSZ = process.platform === "darwin" ? 1074295912 : 21523;
+var TIOCSWINSZ = process.platform === "darwin" ? 2148037735 : 21524;
+var SIGWINCH = 28;
+var SIGHUP = 1;
+var SIGTERM = 15;
+function saveAndSetRawStdin() {
+  const cur = Buffer.alloc(128);
+  if (ffi.core.tcgetattr(0, cur) !== 0)
+    return null;
+  const saved = Buffer.from(cur);
+  ffi.core.cfmakeraw(cur);
+  ffi.core.tcsetattr(0, TCSANOW, cur);
+  return saved;
+}
+function restoreStdin(saved) {
+  ffi.core.tcsetattr(0, TCSANOW, saved);
+}
+function setWinsize(master, rows, cols) {
+  const ws = Buffer.alloc(8);
+  ws.writeUInt16LE(Math.max(rows, 1) & 65535, 0);
+  ws.writeUInt16LE(Math.max(cols, 1) & 65535, 2);
+  return ioctlPtr(master, TIOCSWINSZ, ws);
+}
+function ioctlPtr(fd, request, arg) {
+  return APPLE_VARARGS ? ffi.core.ioctl(fd, BigInt(request), 0n, 0n, 0n, 0n, 0n, 0n, arg) : ffi.core.ioctl(fd, BigInt(request), arg);
+}
+function getWinsize(fd) {
+  const ws = Buffer.alloc(8);
+  if (ioctlPtr(fd, TIOCGWINSZ, ws) !== 0)
+    return null;
+  return [ws.readUInt16LE(0), ws.readUInt16LE(2)];
+}
+function writeAll(fd, data) {
+  let off = 0;
+  while (off < data.length) {
+    const n = Number(ffi.core.write(fd, data.subarray(off), data.length - off));
+    if (n <= 0)
+      return;
+    off += n;
+  }
+}
+var SLEEPER = new Int32Array(new SharedArrayBuffer(4));
+function sleepSync(ms) {
+  Atomics.wait(SLEEPER, 0, 0, ms);
+}
+
+// src/pty.ts
+function workerUrl(name) {
+  return new URL(`./${name}${import.meta.url.endsWith(".ts") ? ".ts" : ".js"}`, import.meta.url);
+}
+function ptySpawn(file, args, opts) {
+  const m = Buffer.alloc(4);
+  const s = Buffer.alloc(4);
+  const name = Buffer.alloc(128);
+  const ws = Buffer.alloc(8);
+  ws.writeUInt16LE(Math.max(opts.rows, 1) & 65535, 0);
+  ws.writeUInt16LE(Math.max(opts.cols, 1) & 65535, 2);
+  const rc = ffi.openpty.openpty(m, s, name, null, ws);
+  if (rc !== 0)
+    throw new Error(`openpty failed (${rc})`);
+  const master = m.readInt32LE(0);
+  const slave = s.readInt32LE(0);
+  const proc = Bun.spawn([file, ...args], {
+    stdin: slave,
+    stdout: slave,
+    stderr: slave,
+    env: opts.env ?? environ(),
+    ...opts.cwd === undefined ? {} : { cwd: opts.cwd }
+  });
+  closeSync(slave);
+  const reader = new Worker(workerUrl("pty-read-worker"));
+  const writer = new Worker(workerUrl("pty-write-worker"));
+  let dataCb = null;
+  let markDrained = () => {};
+  const drained = new Promise((res) => {
+    markDrained = res;
+  });
+  reader.addEventListener("message", (event) => {
+    const chunk = event.data;
+    if (chunk === null)
+      markDrained();
+    else
+      dataCb?.(Buffer.from(chunk));
+  });
+  const exited = (async () => Number(await proc.exited))();
+  let reading = false;
+  return {
+    pid: proc.pid,
+    get exited() {
+      return exited;
+    },
+    get drained() {
+      return drained;
+    },
+    write(data) {
+      writer.postMessage({ fd: master, data: new Uint8Array(data) });
+    },
+    onData(cb) {
+      dataCb = cb;
+      if (!reading) {
+        reading = true;
+        reader.postMessage({ fd: master });
+      }
+    },
+    resize(rows, cols) {
+      setWinsize(master, rows, cols);
+      try {
+        proc.kill(SIGWINCH);
+      } catch {}
+    },
+    kill(signal = SIGTERM) {
+      try {
+        proc.kill(signal);
+      } catch {}
+    },
+    destroy() {
+      try {
+        proc.kill(SIGHUP);
+      } catch {}
+      try {
+        closeSync(master);
+      } catch {}
+      markDrained();
+      reader.terminate();
+      writer.terminate();
+    }
+  };
+}
+
+// src/json.ts
+function isObject(v) {
+  return typeof v === "object" && v !== null && v !== undefined && !Array.isArray(v);
+}
+function parseJson(text) {
+  try {
+    return JSON.parse(text);
+  } catch {
+    return null;
+  }
+}
+function truthy(v) {
+  if (v === null || v === false)
+    return false;
+  if (typeof v === "number")
+    return v !== 0;
+  if (typeof v === "string")
+    return v.length > 0;
+  if (Array.isArray(v))
+    return v.length > 0;
+  if (typeof v === "object")
+    return Object.keys(v).length > 0;
+  return v;
+}
+
+// src/claude-highlight.ts
+var DOC = `claude-highlight \u2014 run Claude Code behind a PTY that colors epistemic markers.
+
+    claude-highlight [any claude args...]
+
+Spawns the real \`claude\` on a pseudo-terminal and forwards bytes both ways,
+injecting SGR color around matched words on the way out. Because SGR is
+zero-width, the child's layout math is untouched \u2014 see highlight_filter.ts.
+
+Hotkey (default F9, or bind cmd+/ in Ghostty \u2014 see README) opens a plugin
+menu to toggle categories live. Config lives at
+~/.config/claude-highlight/config.json and is re-read whenever it changes.
+`;
+var CONFIG = configFile("claude-highlight");
+var HOTKEY = "\x1B[20~";
+var PASTE_ON = "\x1B[200~";
+var PASTE_MARK = /\x1b\[20[01]~/g;
+var IDLE = 20;
+var FORCE_IDLE = 300;
+var REPAINT_IDLE = 500;
+var DEFAULT_STYLES = {
+  inference: { color: "38;5;203", on: true, desc: "hedged claim (likely, probably)" },
+  unknown: { color: "38;5;170", on: true, desc: "admitted gap (untested, can't verify)" },
+  assumption: { color: "38;5;214", on: true, desc: "unverified premise (assuming, in theory)" },
+  appearance: { color: "38;5;179", on: true, desc: "impression (seems, looks like)" },
+  overclaim: { color: "38;5;51", on: true, desc: "unearned certainty (obviously, clearly)" },
+  modal: { color: "38;5;33", on: false, desc: "possibility (might, could be)" },
+  vagueness: { color: "38;5;99", on: false, desc: "imprecision (roughly, several)" },
+  softener: { color: "38;5;105", on: false, desc: "hedge-after-the-fact (a bit, fairly)" }
+};
+var ORDER = Object.keys(DEFAULT_STYLES);
+function wordlist(x) {
+  if (typeof x === "string")
+    return [x];
+  return Array.isArray(x) ? x.map((w) => String(w)) : [];
+}
+function text(v, fallback) {
+  return v === undefined ? fallback : String(v);
+}
+function loadConfig() {
+  const parsed = existsSync(CONFIG) ? parseJson(readFileSync(CONFIG, "utf8")) : null;
+  const user = isObject(parsed) ? parsed : {};
+  const catsRaw = user["categories"];
+  const cats = isObject(catsRaw) ? catsRaw : {};
+  const customRaw = user["custom"];
+  const customObj = isObject(customRaw) ? customRaw : {};
+  const cfg = {};
+  for (const cat of ORDER) {
+    const dflt = DEFAULT_STYLES[cat];
+    const specRaw = cats[cat];
+    const spec = isObject(specRaw) ? specRaw : {};
+    const on = spec["on"];
+    cfg[cat] = {
+      ...spec,
+      color: text(spec["color"], dflt.color),
+      on: on === undefined ? dflt.on : truthy(on),
+      desc: text(spec["desc"], dflt.desc),
+      add: wordlist(spec["add"])
+    };
+  }
+  const custom = {};
+  for (const [name, specRaw] of Object.entries(customObj)) {
+    if (!isObject(specRaw))
+      continue;
+    const on = specRaw["on"];
+    custom[name] = {
+      color: text(specRaw["color"], "38;5;99"),
+      on: on === undefined ? true : truthy(on),
+      desc: text(specRaw["desc"], "custom"),
+      terms: wordlist(specRaw["terms"])
+    };
+    if (name in cfg)
+      continue;
+    cfg[name] = { ...custom[name], add: custom[name].terms };
+  }
+  const cfgAll = {
+    categories: cfg,
+    custom,
+    annotations: truthy(user["annotations"] ?? true),
+    prose_only: truthy(user["prose_only"] ?? true),
+    idle_repaint: truthy(user["idle_repaint"] ?? false)
+  };
+  if (!existsSync(CONFIG)) {
+    mkdirSync(dirname(CONFIG), { recursive: true });
+    writeFileSync(CONFIG, JSON.stringify(cfgAll, null, 2));
+  }
+  return cfgAll;
+}
+function selfName() {
+  const argv0 = process.argv[1] ?? "";
+  const base = basename(argv0);
+  const typed = process.env["_"];
+  const candidates = [
+    ...typed === undefined ? [] : [basename(typed)],
+    base,
+    base.replace(/\.[jt]s$/, "")
+  ];
+  for (const name of candidates) {
+    const found = Bun.which(name);
+    if (!found)
+      continue;
+    try {
+      const a = statSync(found), b = statSync(resolve(argv0));
+      if (a.ino === b.ino && a.dev === b.dev)
+        return name;
+    } catch {}
+  }
+  return argv0;
+}
+function buildRewrites() {
+  return [{ pat: /\bclaude(?= --resume\b)/g, repl: toLatin1(selfName()) }];
+}
+function toLatin1(s) {
+  return Buffer.from(s, "utf8").toString("latin1");
+}
+function categoryTerms(cat, c) {
+  const terms = [...LEXICON[cat] ?? []];
+  const bad = [];
+  for (const word of c.add) {
+    const frag = userPattern(word);
+    try {
+      new RegExp(frag);
+    } catch {
+      bad.push(word);
+      continue;
+    }
+    terms.push(frag);
+  }
+  return [terms, bad];
+}
+function userFragments(cfg) {
+  const out = [];
+  for (const [cat, c] of Object.entries(cfg.categories)) {
+    out.push(...categoryTerms(cat, c)[0].slice((LEXICON[cat] ?? []).length));
+  }
+  return out;
+}
+function rejectedTerms(cfg) {
+  const out = {};
+  for (const [cat, c] of Object.entries(cfg.categories)) {
+    const bad = categoryTerms(cat, c)[1];
+    if (bad.length)
+      out[cat] = bad;
+  }
+  return out;
+}
+function paintPalette(cfg) {
+  const out = new Set(Object.values(cfg.categories).map((c) => c.color));
+  out.add("38;5;203");
+  return out;
+}
+function buildRules(cfg) {
+  const rules = [];
+  for (const [cat, c] of Object.entries(cfg.categories)) {
+    if (!c.on)
+      continue;
+    const [terms] = categoryTerms(cat, c);
+    if (!terms.length)
+      continue;
+    const pat = "\\b(?:" + terms.join("|") + ")\\b";
+    rules.push({
+      pat: new RegExp(toLatin1(pat), "gi"),
+      style: Buffer.from(`\x1B[${c.color}m`, "latin1")
+    });
+  }
+  if (cfg.annotations) {
+    rules.push({
+      pat: /\[[^\]\n]{1,80}\]\((?:low certainty|assumed|unverified)\)/g,
+      style: Buffer.from("\x1B[38;5;203m", "latin1")
+    });
+  }
+  return rules;
+}
+var REPAINT_HOLD = 80;
+function forceRepaint(pty, rows, cols) {
+  pty.resize(Math.max(rows - 1, 1), cols);
+  sleepSync(REPAINT_HOLD);
+  pty.resize(rows, cols);
+}
+var TRUECOLOR = ["truecolor", "24bit"].includes((process.env["COLORTERM"] ?? "").toLowerCase());
+var UNICODE = (process.env["LC_ALL"] || process.env["LC_CTYPE"] || process.env["LANG"] || "utf-8").toLowerCase().replace(/-/g, "").includes("utf8");
+var c_ = (trueSeq, indexed) => TRUECOLOR ? trueSeq : indexed;
+var PANEL_BG = c_("48;2;38;42;64", "48;5;236");
+var PANEL_FG = c_("38;2;205;212;232", "38;5;252");
+var PANEL_DIM = c_("38;2;132;140;170", "38;5;245");
+var BORDER_FG = c_("38;2;122;162;247", "38;5;75");
+var TITLE_BG = c_("48;2;122;162;247", "48;5;75");
+var TITLE_FG = c_("38;2;16;18;28", "38;5;235");
+var SEL_BG = c_("48;2;64;74;112", "48;5;238");
+var SEL_FG = c_("38;2;255;255;255", "38;5;255");
+var SEL_BAR = c_("38;2;255;214;102", "38;5;221");
+var G = UNICODE ? {
+  tl: "\u256D",
+  tr: "\u256E",
+  bl: "\u2570",
+  br: "\u256F",
+  h: "\u2500",
+  v: "\u2502",
+  vsel: "\u2503",
+  mark: " \u25B8 ",
+  swatch: "\u2588\u2588",
+  up: "\u2191\u2193",
+  dot: "\xB7"
+} : {
+  tl: "+",
+  tr: "+",
+  bl: "+",
+  br: "+",
+  h: "-",
+  v: "|",
+  vsel: "|",
+  mark: " > ",
+  swatch: "##",
+  up: "up/dn",
+  dot: "-"
+};
+function row(segments, width, bg) {
+  let out = `\x1B[${bg}m`;
+  let used = 0;
+  for (const [raw, fg] of segments) {
+    if (used >= width)
+      break;
+    const text = raw.slice(0, width - used);
+    used += text.length;
+    out += (fg ? `\x1B[${fg}m` : "") + text;
+  }
+  return out + " ".repeat(Math.max(0, width - used)) + "\x1B[0m";
+}
+function menuLines(cfg, cols, sel) {
+  const w = Math.max(46, cols - 1);
+  const inner = w - 2;
+  const title = ` claude-highlight ${G["dot"]} plugins `;
+  const lines = [
+    row([
+      [G["tl"], BORDER_FG],
+      [title, null],
+      [G["h"].repeat(Math.max(0, inner - title.length)), BORDER_FG],
+      [G["tr"], BORDER_FG]
+    ], w, TITLE_BG + ";" + TITLE_FG)
+  ];
+  const cats = Object.keys(cfg.categories);
+  for (let i = 0;i < cats.length; i++) {
+    const cat = cats[i];
+    const c = cfg.categories[cat];
+    const selected = i === sel;
+    const bg = selected ? SEL_BG : PANEL_BG;
+    const fg = selected ? SEL_FG : PANEL_FG;
+    lines.push(row([
+      [selected ? G["vsel"] : G["v"], selected ? SEL_BAR : BORDER_FG],
+      [selected ? G["mark"] : " ".repeat(G["mark"].length), selected ? SEL_FG : PANEL_DIM],
+      [`[${c.on ? "on " : "off"}] `, fg],
+      [G["swatch"], c.color],
+      [` ${cat.padEnd(11)}`, fg],
+      [c.desc, selected ? fg : PANEL_DIM]
+    ], w - 1, bg) + `\x1B[${bg}m\x1B[${BORDER_FG}m` + G["v"] + "\x1B[0m");
+  }
+  const hint = ` ${G["up"]} move ${G["dot"]} space / enter toggle ` + `${G["dot"]} q / esc / F9 close `;
+  lines.push(row([
+    [G["bl"], BORDER_FG],
+    [hint, TITLE_FG],
+    [G["h"].repeat(Math.max(0, inner - hint.length)), BORDER_FG],
+    [G["br"], BORDER_FG]
+  ], w, TITLE_BG));
+  return lines;
+}
+function drawMenu(cfg, rows, cols, sel) {
+  const lines = menuLines(cfg, cols, sel);
+  const top = Math.max(rows - lines.length, 0);
+  const out = ["\x1B7", "\x1B[?25l"];
+  lines.forEach((text, i) => out.push(`\x1B[${top + i + 1};1H\x1B[2K` + text));
+  out.push("\x1B8");
+  writeAll(1, Buffer.from(out.join(""), "utf8"));
+}
+var PALETTE = [
+  [
+    "reds \u2014 loudest, for the claim you most want to catch",
+    "inference",
+    [203, 196, 202, 209, 167, 174, 210, 168]
+  ],
+  [
+    "pinks and magentas \u2014 loud but not alarming",
+    "unknown",
+    [170, 176, 177, 183, 213, 205, 141, 218]
+  ],
+  [
+    "ambers and yellows \u2014 warm, reads as 'check this'",
+    "assumption",
+    [214, 215, 220, 221, 222, 178, 136, 223]
+  ],
+  [
+    "golds and tans \u2014 quieter warmth, good for a busy category",
+    "appearance",
+    [179, 180, 187, 144, 137, 173, 143, 229]
+  ],
+  [
+    "cyans and teals \u2014 cold, opposite end from the reds",
+    "overclaim",
+    [51, 45, 44, 80, 87, 116, 73, 37]
+  ],
+  [
+    "greens",
+    "unused \u2014 free for a category of your own",
+    [71, 78, 108, 114, 150, 84, 42, 155]
+  ],
+  [
+    "blues and violets \u2014 cool, and nothing in warm prose competes with them",
+    "modal, vagueness, softener",
+    [33, 39, 99, 105, 27, 63, 93, 135]
+  ]
+];
+function paletteLines(cfg, cols, full = false) {
+  const out = ["", "  in use now"];
+  for (const [cat, c] of Object.entries(cfg.categories)) {
+    const state = c.on ? "on " : "off";
+    out.push(`    \x1B[${c.color}m${cat.padEnd(11)}\x1B[0m ${state}  ` + `${c.color.padEnd(10)} ${c.desc}`);
+  }
+  out.push("", "  to change one, edit the config -- it is re-read live, so the next", "  line Claude Code prints already has the new colour:", "", `    ${CONFIG}`, '    { "categories": { "assumption": { "color": "38;5;220" } } }');
+  const word = "mostly";
+  const cell = word.length + 5;
+  const perRow = Math.max(1, Math.floor((cols - 6) / cell));
+  for (const [title, who, codes] of PALETTE) {
+    out.push("", `  ${title}`, `    (${who})`);
+    for (let i = 0;i < codes.length; i += perRow) {
+      const line = codes.slice(i, i + perRow).map((n) => `\x1B[38;5;${n}m${word}\x1B[39m ${String(n).padEnd(3)} `).join("");
+      out.push("    " + line);
+    }
+  }
+  if (full) {
+    out.push("", "  the whole 256-colour ramp");
+    for (let base = 16;base < 256; base += 12) {
+      let line = "";
+      for (let n = base;n < Math.min(base + 12, 256); n++) {
+        line += `\x1B[38;5;${n}m\u2588\u2588\x1B[39m${String(n).padEnd(4)}`;
+      }
+      out.push("    " + line);
+    }
+  }
+  out.push("");
+  return out;
+}
+function selftest(cfg) {
+  const hl = new AnsiHighlighter(buildRules(cfg), cfg.prose_only);
+  const samples = [
+    ["prose", "", "It seems likely this is probably fine, assuming nothing breaks."],
+    ["bold prose", "\x1B[1m", "That seems untested and I can't verify it.\x1B[22m"],
+    ["admissions", "", "I can't test this for you; the result is unverified."],
+    ["overclaim", "", "Obviously this clearly works and definitely always will."],
+    ["inline code", "\x1B[38;2;177;185;249m", "it seems likely here\x1B[39m"],
+    ["fenced code", "\x1B[32m", "# it seems likely that this is code\x1B[39m"],
+    [
+      "user message",
+      "\x1B[48;2;55;55;55m\x1B[38;2;255;255;255m",
+      "it seems likely this is what you typed\x1B[0m"
+    ]
+  ];
+  const out = [
+    Buffer.from(`
+  claude-highlight self-test - top four lines should show color,`, "latin1"),
+    Buffer.from(`  bottom three should be untouched.
+`, "latin1")
+  ];
+  for (const [label, prefix, text] of samples) {
+    const body = Buffer.from(prefix + text, "latin1");
+    out.push(Buffer.concat([
+      Buffer.from(`  ${label.padEnd(13)}`, "latin1"),
+      hl.feed(body),
+      hl.drain(),
+      Buffer.from("\x1B[0m", "latin1")
+    ]));
+  }
+  out.push(Buffer.alloc(0));
+  const bad = rejectedTerms(cfg);
+  if (Object.keys(bad).length) {
+    out.push(Buffer.from("  \x1B[38;5;203mrejected config words (invalid patterns):\x1B[39m", "latin1"));
+    for (const [cat, words] of Object.entries(bad)) {
+      out.push(Buffer.from(`    ${cat}: ${words.join(", ")}`, "utf8"));
+    }
+    out.push(Buffer.alloc(0));
+  }
+  for (const [cat, c] of Object.entries(cfg.categories)) {
+    const state = c.on ? "on " : "off";
+    const extra = c.add.length;
+    const tag = extra ? `  +${extra} from config` : "";
+    out.push(Buffer.from(`  \x1B[${c.color}m${cat.padEnd(11)}\x1B[0m ${state}  ${c.desc}${tag}`, "utf8"));
+  }
+  writeAll(1, Buffer.concat([joinBuf(out, `
+`), Buffer.from(`
+`, "latin1")]));
+  return 0;
+}
+function joinBuf(parts, sep) {
+  const s = Buffer.from(sep, "latin1");
+  const out = [];
+  parts.forEach((p, i) => {
+    if (i)
+      out.push(s);
+    out.push(p);
+  });
+  return Buffer.concat(out);
+}
+function parseArgs(argv) {
+  const a = {
+    hlHelp: false,
+    hlSelftest: false,
+    hlMenu: false,
+    hlPalette: null,
+    hlRecord: null,
+    rest: []
+  };
+  for (let i = 0;i < argv.length; i++) {
+    const arg = argv[i];
+    const eq = arg.indexOf("=");
+    const name = eq === -1 ? arg : arg.slice(0, eq);
+    const inline = eq === -1 ? null : arg.slice(eq + 1);
+    if (name === "--hl-help")
+      a.hlHelp = true;
+    else if (name === "--hl-selftest")
+      a.hlSelftest = true;
+    else if (name === "--hl-menu")
+      a.hlMenu = true;
+    else if (name === "--hl-palette") {
+      if (inline !== null)
+        a.hlPalette = inline;
+      else {
+        const next = argv[i + 1];
+        if (next !== undefined && !next.startsWith("-")) {
+          a.hlPalette = next;
+          i++;
+        } else
+          a.hlPalette = "curated";
+      }
+    } else if (name === "--hl-record") {
+      if (inline !== null)
+        a.hlRecord = inline;
+      else if (argv[i + 1] !== undefined) {
+        a.hlRecord = argv[i + 1];
+        i++;
+      }
+    } else {
+      a.rest.push(arg);
+    }
+  }
+  return a;
+}
+function stdoutCols() {
+  const sz = getWinsize(1);
+  if (sz && sz[1])
+    return sz[1];
+  return Number(process.env["COLUMNS"]) || 100;
+}
+async function main(argv) {
+  const known = parseArgs(argv);
+  if (known.hlHelp) {
+    writeAll(1, Buffer.from(DOC + `
+`, "utf8"));
+    return 0;
+  }
+  let cfg = loadConfig();
+  if (known.hlSelftest)
+    return selftest(cfg);
+  if (known.hlPalette) {
+    writeAll(1, Buffer.from(paletteLines(cfg, stdoutCols(), known.hlPalette === "all").join(`
+`), "utf8"));
+    return 0;
+  }
+  if (known.hlMenu) {
+    writeAll(1, Buffer.from(`
+` + menuLines(cfg, stdoutCols(), 0).join(`
+`) + `
+
+`, "utf8"));
+    return 0;
+  }
+  let mtime = existsSync(CONFIG) ? statSync(CONFIG).mtimeMs : 0;
+  const hl = new AnsiHighlighter(buildRules(cfg), cfg.prose_only);
+  hl.rewrites = buildRewrites();
+  hl.holdPrefixes = growablePrefixes(userFragments(cfg));
+  const screen = new ScreenModel(24, 80, paintPalette(cfg));
+  const child = process.env["CLAUDE_HIGHLIGHT_CMD"] ?? "claude";
+  const recRaw = known.hlRecord === null ? null : openSync(known.hlRecord + ".raw", "w");
+  const recOut = known.hlRecord === null ? null : openSync(known.hlRecord + ".out", "w");
+  let [rows, cols] = getWinsize(1) ?? [24, 80];
+  const pty = ptySpawn(child, known.rest, { rows, cols, env: environ() });
+  screen.resize(rows, cols);
+  const old = saveAndSetRawStdin();
+  process.on("SIGWINCH", () => {
+    const sz = getWinsize(1);
+    [rows, cols] = sz ?? [24, 80];
+    pty.resize(rows, cols);
+    screen.resize(rows, cols);
+  });
+  let menu = false, sel = 0, pendingIn = "", pasting = false;
+  let repainted = true;
+  let lastData = performance.now();
+  let sawData = false;
+  let stdinOpen = true;
+  const emit = (out) => {
+    if (!out.length)
+      return;
+    writeAll(1, out);
+    if (recOut !== null)
+      writeSync(recOut, out);
+  };
+  const closeMenu = () => {
+    menu = false;
+    screen.invalidate();
+    writeAll(1, Buffer.from("\x1B[?25h", "latin1"));
+    writeFileSync(CONFIG, JSON.stringify(cfg, null, 2));
+    mtime = statSync(CONFIG).mtimeMs;
+    forceRepaint(pty, rows, cols);
+  };
+  pty.onData((data) => {
+    sawData = true;
+    lastData = performance.now();
+    repainted = false;
+    if (recRaw !== null)
+      writeSync(recRaw, data);
+    if (!menu) {
+      emit(screen.reconcile(hl.feed(data), hl.rules, hl.onlyUnstyled));
+    } else {
+      hl.feed(data);
+      screen.invalidate();
+    }
+  });
+  const onStdin = (data) => {
+    sawData = true;
+    let buf = pendingIn + data.toString("latin1");
+    pendingIn = "";
+    if (menu) {
+      if (buf.includes(PASTE_ON)) {
+        closeMenu();
+      } else {
+        for (const key of buf.match(/\x1b\[[A-D]|[\s\S]/g) ?? []) {
+          const cats = Object.keys(cfg.categories);
+          if (key === "\x1B[A")
+            sel = (sel - 1 + cats.length) % cats.length;
+          else if (key === "\x1B[B")
+            sel = (sel + 1) % cats.length;
+          else if (key === " " || key === "\r" || key === `
+`) {
+            const cat = cats[sel];
+            cfg.categories[cat].on = !cfg.categories[cat].on;
+            hl.rules = buildRules(cfg);
+          } else if (key === "q" || key === "\x1B") {
+            closeMenu();
+            break;
+          }
+        }
+        if (menu)
+          drawMenu(cfg, rows, cols, sel);
+        return;
+      }
+    }
+    const toChild = [];
+    let pos = 0, opened = false;
+    PASTE_MARK.lastIndex = 0;
+    for (const m of buf.matchAll(PASTE_MARK)) {
+      let seg = buf.slice(pos, m.index);
+      if (!pasting && seg.includes(HOTKEY)) {
+        seg = seg.split(HOTKEY).join("");
+        opened = true;
+      }
+      toChild.push(seg + m[0]);
+      pasting = m[0] === PASTE_ON;
+      pos = m.index + m[0].length;
+    }
+    buf = buf.slice(pos);
+    if (!pasting && buf.includes(HOTKEY)) {
+      buf = buf.split(HOTKEY).join("");
+      opened = true;
+    }
+    if (opened) {
+      menu = true;
+      sel = 0;
+      screen.invalidate();
+      drawMenu(cfg, rows, cols, sel);
+    }
+    for (let n = 1;n < (pasting ? 0 : HOTKEY.length); n++) {
+      if (buf.endsWith(HOTKEY.slice(0, n))) {
+        pendingIn = buf.slice(buf.length - n);
+        buf = buf.slice(0, buf.length - n);
+        break;
+      }
+    }
+    if (buf)
+      toChild.push(buf);
+    if (toChild.length)
+      pty.write(Buffer.from(toChild.join(""), "latin1"));
+  };
+  const stdinReader = new Worker(workerUrl("pty-read-worker"));
+  stdinReader.addEventListener("message", (event) => {
+    const chunk = event.data;
+    if (chunk === null)
+      stdinOpen = false;
+    else if (stdinOpen)
+      onStdin(Buffer.from(chunk));
+  });
+  stdinReader.postMessage({ fd: 0 });
+  const tick = () => {
+    if (sawData) {
+      sawData = false;
+      return;
+    }
+    const now = performance.now();
+    emit(screen.reconcile(hl.drain(now - lastData > FORCE_IDLE), hl.rules, hl.onlyUnstyled));
+    if (cfg.idle_repaint && !menu && !repainted && now - lastData > REPAINT_IDLE) {
+      repainted = true;
+      forceRepaint(pty, rows, cols);
+    }
+    if (existsSync(CONFIG) && statSync(CONFIG).mtimeMs !== mtime) {
+      mtime = statSync(CONFIG).mtimeMs;
+      cfg = loadConfig();
+      hl.rules = buildRules(cfg);
+      hl.onlyUnstyled = cfg.prose_only;
+      hl.holdPrefixes = growablePrefixes(userFragments(cfg));
+      hl.rewrites = buildRewrites();
+      screen.palette = paintPalette(cfg);
+    }
+  };
+  const timer = setInterval(tick, IDLE);
+  await pty.drained;
+  clearInterval(timer);
+  stdinReader.terminate();
+  if (old !== null)
+    restoreStdin(old);
+  try {
+    emit(hl.drain(true));
+  } catch {}
+  const code = await pty.exited;
+  pty.destroy();
+  return code;
+}
+if (import.meta.main) {
+  process.exit(await main(process.argv.slice(2)));
+}
+export {
+  CONFIG,
+  ORDER,
+  buildRewrites,
+  buildRules,
+  categoryTerms,
+  drawMenu,
+  loadConfig,
+  main,
+  menuLines,
+  paintPalette,
+  paletteLines,
+  parseArgs,
+  rejectedTerms,
+  selfName,
+  selftest,
+  userFragments
+};