pair-mode 0.1.0

package/dist/pair-tui.js

@@ -0,0 +1,2729 @@
+#!/usr/bin/env node
+import { createRequire } from "node:module";
+const require = createRequire(import.meta.url);
+
+// src/tui/cli.ts
+import { readFileSync } from "node:fs";
+
+// src/adapters/entry-point.ts
+import { realpathSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+function isEntryPoint(moduleUrl) {
+  const entryArg = process.argv[1];
+  if (entryArg === void 0) {
+    return false;
+  }
+  try {
+    return realpathSync(entryArg) === realpathSync(fileURLToPath(moduleUrl));
+  } catch {
+    return false;
+  }
+}
+
+// src/helpers/resultFilePath.ts
+import { randomBytes } from "node:crypto";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+var NAME_BYTES = 6;
+function resultFilePath() {
+  const name = `pair-result-${randomBytes(NAME_BYTES).toString("hex")}.json`;
+  return join(tmpdir(), name);
+}
+
+// src/helpers/splitLines.ts
+function splitLines(text) {
+  const lines = text.split("\n");
+  const last = lines.at(-1);
+  if (last === "") {
+    lines.pop();
+  }
+  return lines;
+}
+
+// src/core/marks.ts
+var DEFAULT_CONTEXT = 5;
+var DEFAULT_MIN_FOLD = 4;
+
+// node_modules/.pnpm/diff@9.0.0/node_modules/diff/libesm/diff/base.js
+var Diff = class {
+  diff(oldStr, newStr, options = {}) {
+    let callback;
+    if (typeof options === "function") {
+      callback = options;
+      options = {};
+    } else if ("callback" in options) {
+      callback = options.callback;
+    }
+    const oldString = this.castInput(oldStr, options);
+    const newString = this.castInput(newStr, options);
+    const oldTokens = this.removeEmpty(this.tokenize(oldString, options));
+    const newTokens = this.removeEmpty(this.tokenize(newString, options));
+    return this.diffWithOptionsObj(oldTokens, newTokens, options, callback);
+  }
+  diffWithOptionsObj(oldTokens, newTokens, options, callback) {
+    var _a;
+    const done = (value) => {
+      value = this.postProcess(value, options);
+      if (callback) {
+        setTimeout(function() {
+          callback(value);
+        }, 0);
+        return void 0;
+      } else {
+        return value;
+      }
+    };
+    const newLen = newTokens.length, oldLen = oldTokens.length;
+    let editLength = 1;
+    let maxEditLength = newLen + oldLen;
+    if (options.maxEditLength != null) {
+      maxEditLength = Math.min(maxEditLength, options.maxEditLength);
+    }
+    const maxExecutionTime = (_a = options.timeout) !== null && _a !== void 0 ? _a : Infinity;
+    const abortAfterTimestamp = Date.now() + maxExecutionTime;
+    const bestPath = [{ oldPos: -1, lastComponent: void 0 }];
+    let newPos = this.extractCommon(bestPath[0], newTokens, oldTokens, 0, options);
+    if (bestPath[0].oldPos + 1 >= oldLen && newPos + 1 >= newLen) {
+      return done(this.buildValues(bestPath[0].lastComponent, newTokens, oldTokens));
+    }
+    let minDiagonalToConsider = -Infinity, maxDiagonalToConsider = Infinity;
+    const execEditLength = () => {
+      for (let diagonalPath = Math.max(minDiagonalToConsider, -editLength); diagonalPath <= Math.min(maxDiagonalToConsider, editLength); diagonalPath += 2) {
+        let basePath;
+        const removePath = bestPath[diagonalPath - 1], addPath = bestPath[diagonalPath + 1];
+        if (removePath) {
+          bestPath[diagonalPath - 1] = void 0;
+        }
+        let canAdd = false;
+        if (addPath) {
+          const addPathNewPos = addPath.oldPos - diagonalPath;
+          canAdd = addPath && 0 <= addPathNewPos && addPathNewPos < newLen;
+        }
+        const canRemove = removePath && removePath.oldPos + 1 < oldLen;
+        if (!canAdd && !canRemove) {
+          bestPath[diagonalPath] = void 0;
+          continue;
+        }
+        if (!canRemove || canAdd && removePath.oldPos < addPath.oldPos) {
+          basePath = this.addToPath(addPath, true, false, 0, options);
+        } else {
+          basePath = this.addToPath(removePath, false, true, 1, options);
+        }
+        newPos = this.extractCommon(basePath, newTokens, oldTokens, diagonalPath, options);
+        if (basePath.oldPos + 1 >= oldLen && newPos + 1 >= newLen) {
+          return done(this.buildValues(basePath.lastComponent, newTokens, oldTokens)) || true;
+        } else {
+          bestPath[diagonalPath] = basePath;
+          if (basePath.oldPos + 1 >= oldLen) {
+            maxDiagonalToConsider = Math.min(maxDiagonalToConsider, diagonalPath - 1);
+          }
+          if (newPos + 1 >= newLen) {
+            minDiagonalToConsider = Math.max(minDiagonalToConsider, diagonalPath + 1);
+          }
+        }
+      }
+      editLength++;
+    };
+    if (callback) {
+      (function exec() {
+        setTimeout(function() {
+          if (editLength > maxEditLength || Date.now() > abortAfterTimestamp) {
+            return callback(void 0);
+          }
+          if (!execEditLength()) {
+            exec();
+          }
+        }, 0);
+      })();
+    } else {
+      while (editLength <= maxEditLength && Date.now() <= abortAfterTimestamp) {
+        const ret = execEditLength();
+        if (ret) {
+          return ret;
+        }
+      }
+    }
+  }
+  addToPath(path, added, removed, oldPosInc, options) {
+    const last = path.lastComponent;
+    if (last && !options.oneChangePerToken && last.added === added && last.removed === removed) {
+      return {
+        oldPos: path.oldPos + oldPosInc,
+        lastComponent: { count: last.count + 1, added, removed, previousComponent: last.previousComponent }
+      };
+    } else {
+      return {
+        oldPos: path.oldPos + oldPosInc,
+        lastComponent: { count: 1, added, removed, previousComponent: last }
+      };
+    }
+  }
+  extractCommon(basePath, newTokens, oldTokens, diagonalPath, options) {
+    const newLen = newTokens.length, oldLen = oldTokens.length;
+    let oldPos = basePath.oldPos, newPos = oldPos - diagonalPath, commonCount = 0;
+    while (newPos + 1 < newLen && oldPos + 1 < oldLen && this.equals(oldTokens[oldPos + 1], newTokens[newPos + 1], options)) {
+      newPos++;
+      oldPos++;
+      commonCount++;
+      if (options.oneChangePerToken) {
+        basePath.lastComponent = { count: 1, previousComponent: basePath.lastComponent, added: false, removed: false };
+      }
+    }
+    if (commonCount && !options.oneChangePerToken) {
+      basePath.lastComponent = { count: commonCount, previousComponent: basePath.lastComponent, added: false, removed: false };
+    }
+    basePath.oldPos = oldPos;
+    return newPos;
+  }
+  equals(left, right, options) {
+    if (options.comparator) {
+      return options.comparator(left, right);
+    } else {
+      return left === right || !!options.ignoreCase && left.toLowerCase() === right.toLowerCase();
+    }
+  }
+  removeEmpty(array) {
+    const ret = [];
+    for (let i = 0; i < array.length; i++) {
+      if (array[i]) {
+        ret.push(array[i]);
+      }
+    }
+    return ret;
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  castInput(value, options) {
+    return value;
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  tokenize(value, options) {
+    return Array.from(value);
+  }
+  join(chars) {
+    return chars.join("");
+  }
+  postProcess(changeObjects, options) {
+    return changeObjects;
+  }
+  get useLongestToken() {
+    return false;
+  }
+  buildValues(lastComponent, newTokens, oldTokens) {
+    const components = [];
+    let nextComponent;
+    while (lastComponent) {
+      components.push(lastComponent);
+      nextComponent = lastComponent.previousComponent;
+      delete lastComponent.previousComponent;
+      lastComponent = nextComponent;
+    }
+    components.reverse();
+    const componentLen = components.length;
+    let componentPos = 0, newPos = 0, oldPos = 0;
+    for (; componentPos < componentLen; componentPos++) {
+      const component = components[componentPos];
+      if (!component.removed) {
+        if (!component.added && this.useLongestToken) {
+          let value = newTokens.slice(newPos, newPos + component.count);
+          value = value.map(function(value2, i) {
+            const oldValue = oldTokens[oldPos + i];
+            return oldValue.length > value2.length ? oldValue : value2;
+          });
+          component.value = this.join(value);
+        } else {
+          component.value = this.join(newTokens.slice(newPos, newPos + component.count));
+        }
+        newPos += component.count;
+        if (!component.added) {
+          oldPos += component.count;
+        }
+      } else {
+        component.value = this.join(oldTokens.slice(oldPos, oldPos + component.count));
+        oldPos += component.count;
+      }
+    }
+    return components;
+  }
+};
+
+// node_modules/.pnpm/diff@9.0.0/node_modules/diff/libesm/util/string.js
+function longestCommonPrefix(str1, str2) {
+  let i;
+  for (i = 0; i < str1.length && i < str2.length; i++) {
+    if (str1[i] != str2[i]) {
+      return str1.slice(0, i);
+    }
+  }
+  return str1.slice(0, i);
+}
+function longestCommonSuffix(str1, str2) {
+  let i;
+  if (!str1 || !str2 || str1[str1.length - 1] != str2[str2.length - 1]) {
+    return "";
+  }
+  for (i = 0; i < str1.length && i < str2.length; i++) {
+    if (str1[str1.length - (i + 1)] != str2[str2.length - (i + 1)]) {
+      return str1.slice(-i);
+    }
+  }
+  return str1.slice(-i);
+}
+function replacePrefix(string, oldPrefix, newPrefix) {
+  if (string.slice(0, oldPrefix.length) != oldPrefix) {
+    throw Error(`string ${JSON.stringify(string)} doesn't start with prefix ${JSON.stringify(oldPrefix)}; this is a bug`);
+  }
+  return newPrefix + string.slice(oldPrefix.length);
+}
+function replaceSuffix(string, oldSuffix, newSuffix) {
+  if (!oldSuffix) {
+    return string + newSuffix;
+  }
+  if (string.slice(-oldSuffix.length) != oldSuffix) {
+    throw Error(`string ${JSON.stringify(string)} doesn't end with suffix ${JSON.stringify(oldSuffix)}; this is a bug`);
+  }
+  return string.slice(0, -oldSuffix.length) + newSuffix;
+}
+function removePrefix(string, oldPrefix) {
+  return replacePrefix(string, oldPrefix, "");
+}
+function removeSuffix(string, oldSuffix) {
+  return replaceSuffix(string, oldSuffix, "");
+}
+function maximumOverlap(string1, string2) {
+  return string2.slice(0, overlapCount(string1, string2));
+}
+function overlapCount(a, b) {
+  let startA = 0;
+  if (a.length > b.length) {
+    startA = a.length - b.length;
+  }
+  let endB = b.length;
+  if (a.length < b.length) {
+    endB = a.length;
+  }
+  const map = Array(endB);
+  let k = 0;
+  map[0] = 0;
+  for (let j = 1; j < endB; j++) {
+    if (b[j] == b[k]) {
+      map[j] = map[k];
+    } else {
+      map[j] = k;
+    }
+    while (k > 0 && b[j] != b[k]) {
+      k = map[k];
+    }
+    if (b[j] == b[k]) {
+      k++;
+    }
+  }
+  k = 0;
+  for (let i = startA; i < a.length; i++) {
+    while (k > 0 && a[i] != b[k]) {
+      k = map[k];
+    }
+    if (a[i] == b[k]) {
+      k++;
+    }
+  }
+  return k;
+}
+function segment(string, segmenter) {
+  const parts = [];
+  for (const segmentObj of Array.from(segmenter.segment(string))) {
+    const segment2 = segmentObj.segment;
+    if (parts.length && /\s/.test(parts[parts.length - 1]) && /\s/.test(segment2)) {
+      parts[parts.length - 1] += segment2;
+    } else {
+      parts.push(segment2);
+    }
+  }
+  return parts;
+}
+function trailingWs(string, segmenter) {
+  if (segmenter) {
+    return leadingAndTrailingWs(string, segmenter)[1];
+  }
+  let i;
+  for (i = string.length - 1; i >= 0; i--) {
+    if (!string[i].match(/\s/)) {
+      break;
+    }
+  }
+  return string.substring(i + 1);
+}
+function leadingWs(string, segmenter) {
+  if (segmenter) {
+    return leadingAndTrailingWs(string, segmenter)[0];
+  }
+  const match = string.match(/^\s*/);
+  return match ? match[0] : "";
+}
+function leadingAndTrailingWs(string, segmenter) {
+  if (!segmenter) {
+    return [leadingWs(string), trailingWs(string)];
+  }
+  if (segmenter.resolvedOptions().granularity != "word") {
+    throw new Error('The segmenter passed must have a granularity of "word"');
+  }
+  const segments = segment(string, segmenter);
+  const firstSeg = segments[0];
+  const lastSeg = segments[segments.length - 1];
+  const head = /\s/.test(firstSeg) ? firstSeg : "";
+  const tail = /\s/.test(lastSeg) ? lastSeg : "";
+  return [head, tail];
+}
+
+// node_modules/.pnpm/diff@9.0.0/node_modules/diff/libesm/diff/word.js
+var extendedWordChars = "a-zA-Z0-9_\\u{AD}\\u{C0}-\\u{D6}\\u{D8}-\\u{F6}\\u{F8}-\\u{2C6}\\u{2C8}-\\u{2D7}\\u{2DE}-\\u{2FF}\\u{1E00}-\\u{1EFF}";
+var tokenizeIncludingWhitespace = new RegExp(`[${extendedWordChars}]+|\\s+|[^${extendedWordChars}]`, "ug");
+var WordDiff = class extends Diff {
+  equals(left, right, options) {
+    if (options.ignoreCase) {
+      left = left.toLowerCase();
+      right = right.toLowerCase();
+    }
+    return left.trim() === right.trim();
+  }
+  tokenize(value, options = {}) {
+    let parts;
+    if (options.intlSegmenter) {
+      const segmenter = options.intlSegmenter;
+      if (segmenter.resolvedOptions().granularity != "word") {
+        throw new Error('The segmenter passed must have a granularity of "word"');
+      }
+      parts = segment(value, segmenter);
+    } else {
+      parts = value.match(tokenizeIncludingWhitespace) || [];
+    }
+    const tokens = [];
+    let prevPart = null;
+    parts.forEach((part) => {
+      if (/\s/.test(part)) {
+        if (prevPart == null) {
+          tokens.push(part);
+        } else {
+          tokens.push(tokens.pop() + part);
+        }
+      } else if (prevPart != null && /\s/.test(prevPart)) {
+        if (tokens[tokens.length - 1] == prevPart) {
+          tokens.push(tokens.pop() + part);
+        } else {
+          tokens.push(prevPart + part);
+        }
+      } else {
+        tokens.push(part);
+      }
+      prevPart = part;
+    });
+    return tokens;
+  }
+  join(tokens) {
+    return tokens.map((token, i) => {
+      if (i == 0) {
+        return token;
+      } else {
+        return token.replace(/^\s+/, "");
+      }
+    }).join("");
+  }
+  postProcess(changes, options) {
+    if (!changes || options.oneChangePerToken) {
+      return changes;
+    }
+    let lastKeep = null;
+    let insertion = null;
+    let deletion = null;
+    changes.forEach((change) => {
+      if (change.added) {
+        insertion = change;
+      } else if (change.removed) {
+        deletion = change;
+      } else {
+        if (insertion || deletion) {
+          dedupeWhitespaceInChangeObjects(lastKeep, deletion, insertion, change, options.intlSegmenter);
+        }
+        lastKeep = change;
+        insertion = null;
+        deletion = null;
+      }
+    });
+    if (insertion || deletion) {
+      dedupeWhitespaceInChangeObjects(lastKeep, deletion, insertion, null, options.intlSegmenter);
+    }
+    return changes;
+  }
+};
+var wordDiff = new WordDiff();
+function dedupeWhitespaceInChangeObjects(startKeep, deletion, insertion, endKeep, segmenter) {
+  if (deletion && insertion) {
+    const [oldWsPrefix, oldWsSuffix] = leadingAndTrailingWs(deletion.value, segmenter);
+    const [newWsPrefix, newWsSuffix] = leadingAndTrailingWs(insertion.value, segmenter);
+    if (startKeep) {
+      const commonWsPrefix = longestCommonPrefix(oldWsPrefix, newWsPrefix);
+      startKeep.value = replaceSuffix(startKeep.value, newWsPrefix, commonWsPrefix);
+      deletion.value = removePrefix(deletion.value, commonWsPrefix);
+      insertion.value = removePrefix(insertion.value, commonWsPrefix);
+    }
+    if (endKeep) {
+      const commonWsSuffix = longestCommonSuffix(oldWsSuffix, newWsSuffix);
+      endKeep.value = replacePrefix(endKeep.value, newWsSuffix, commonWsSuffix);
+      deletion.value = removeSuffix(deletion.value, commonWsSuffix);
+      insertion.value = removeSuffix(insertion.value, commonWsSuffix);
+    }
+  } else if (insertion) {
+    if (startKeep) {
+      const ws = leadingWs(insertion.value, segmenter);
+      insertion.value = insertion.value.substring(ws.length);
+    }
+    if (endKeep) {
+      const ws = leadingWs(endKeep.value, segmenter);
+      endKeep.value = endKeep.value.substring(ws.length);
+    }
+  } else if (startKeep && endKeep) {
+    const newWsFull = leadingWs(endKeep.value, segmenter), [delWsStart, delWsEnd] = leadingAndTrailingWs(deletion.value, segmenter);
+    const newWsStart = longestCommonPrefix(newWsFull, delWsStart);
+    deletion.value = removePrefix(deletion.value, newWsStart);
+    const newWsEnd = longestCommonSuffix(removePrefix(newWsFull, newWsStart), delWsEnd);
+    deletion.value = removeSuffix(deletion.value, newWsEnd);
+    endKeep.value = replacePrefix(endKeep.value, newWsFull, newWsEnd);
+    startKeep.value = replaceSuffix(startKeep.value, newWsFull, newWsFull.slice(0, newWsFull.length - newWsEnd.length));
+  } else if (endKeep) {
+    const endKeepWsPrefix = leadingWs(endKeep.value, segmenter);
+    const deletionWsSuffix = trailingWs(deletion.value, segmenter);
+    const overlap = maximumOverlap(deletionWsSuffix, endKeepWsPrefix);
+    deletion.value = removeSuffix(deletion.value, overlap);
+  } else if (startKeep) {
+    const startKeepWsSuffix = trailingWs(startKeep.value, segmenter);
+    const deletionWsPrefix = leadingWs(deletion.value, segmenter);
+    const overlap = maximumOverlap(startKeepWsSuffix, deletionWsPrefix);
+    deletion.value = removePrefix(deletion.value, overlap);
+  }
+}
+var WordsWithSpaceDiff = class extends Diff {
+  tokenize(value) {
+    const regex = new RegExp(`(\\r?\\n)|[${extendedWordChars}]+|[^\\S\\n\\r]+|[^${extendedWordChars}]`, "ug");
+    return value.match(regex) || [];
+  }
+};
+var wordsWithSpaceDiff = new WordsWithSpaceDiff();
+function diffWordsWithSpace(oldStr, newStr, options) {
+  return wordsWithSpaceDiff.diff(oldStr, newStr, options);
+}
+
+// node_modules/.pnpm/diff@9.0.0/node_modules/diff/libesm/diff/array.js
+var ArrayDiff = class extends Diff {
+  tokenize(value) {
+    return value.slice();
+  }
+  join(value) {
+    return value;
+  }
+  removeEmpty(value) {
+    return value;
+  }
+};
+var arrayDiff = new ArrayDiff();
+function diffArrays(oldArr, newArr, options) {
+  return arrayDiff.diff(oldArr, newArr, options);
+}
+
+// src/tui/paint/layout.ts
+import { basename } from "node:path";
+
+// src/core/diff/diff.ts
+function mergeChangedPair(first, second, i, j) {
+  const removed = first.removed ? first : second;
+  const added = first.added ? first : second;
+  const removedCount = removed.value.length;
+  const addedCount = added.value.length;
+  return { tag: "replace", i1: i, i2: i + removedCount, j1: j, j2: j + addedCount };
+}
+function opcodes(before, after) {
+  const chunks = diffArrays(before, after);
+  const result = [];
+  let i = 0;
+  let j = 0;
+  let index = 0;
+  while (index < chunks.length) {
+    const chunk = chunks[index];
+    if (chunk === void 0) {
+      break;
+    }
+    if (!chunk.added && !chunk.removed) {
+      const count = chunk.value.length;
+      result.push({ tag: "equal", i1: i, i2: i + count, j1: j, j2: j + count });
+      i += count;
+      j += count;
+      index += 1;
+      continue;
+    }
+    const next = chunks[index + 1];
+    const nextChanged = next !== void 0 && (next.added || next.removed);
+    const isPair = nextChanged && next !== void 0 && chunk.removed !== next.removed;
+    if (isPair && next !== void 0) {
+      const opcode = mergeChangedPair(chunk, next, i, j);
+      result.push(opcode);
+      i = opcode.i2;
+      j = opcode.j2;
+      index += 2;
+      continue;
+    }
+    if (chunk.removed) {
+      const removedCount = chunk.value.length;
+      result.push({ tag: "delete", i1: i, i2: i + removedCount, j1: j, j2: j });
+      i += removedCount;
+      index += 1;
+      continue;
+    }
+    const addedCount = chunk.value.length;
+    result.push({ tag: "insert", i1: i, i2: i, j1: j, j2: j + addedCount });
+    j += addedCount;
+    index += 1;
+  }
+  return result;
+}
+
+// src/tui/model/model.ts
+var TAB_WIDTH = 8;
+var CONTROL_BYTE_CEILING = 32;
+var CONTROL_BYTE_PLACEHOLDER = "?";
+function sanitizeLine(text) {
+  const scan = text.split("").reduce(
+    (state, char) => {
+      if (char === "	") {
+        const width = TAB_WIDTH - state.column % TAB_WIDTH;
+        return { output: state.output + " ".repeat(width), column: state.column + width };
+      }
+      if (char.charCodeAt(0) < CONTROL_BYTE_CEILING) {
+        return {
+          output: state.output + CONTROL_BYTE_PLACEHOLDER,
+          column: state.column + 1
+        };
+      }
+      return { output: state.output + char, column: state.column + 1 };
+    },
+    { output: "", column: 0 }
+  );
+  return scan.output;
+}
+function buildRows(before, after) {
+  return opcodes(before, after).flatMap((opcode) => {
+    const removed = before.slice(opcode.i1, opcode.i2);
+    const added = after.slice(opcode.j1, opcode.j2);
+    const rowCount = Math.max(removed.length, added.length);
+    return Array.from({ length: rowCount }, (_, row) => {
+      const removedLine = removed[row];
+      const addedLine = added[row];
+      const left = removedLine === void 0 ? "" : sanitizeLine(removedLine);
+      const right = addedLine === void 0 ? "" : sanitizeLine(addedLine);
+      const leftNumber = removedLine === void 0 ? null : opcode.i1 + row + 1;
+      const rightNumber = addedLine === void 0 ? null : opcode.j1 + row + 1;
+      const kind = opcode.tag === "equal" ? "context" : removedLine !== void 0 && addedLine !== void 0 ? "replace" : removedLine !== void 0 ? "del" : "add";
+      return { kind, left, right, leftNumber, rightNumber };
+    });
+  });
+}
+function buildFolds(rows, context, minFold) {
+  const keep = Array.from({ length: rows.length }).fill(false);
+  rows.forEach((row, index) => {
+    if (row.kind === "context") {
+      return;
+    }
+    const start = Math.max(0, index - context);
+    const end = Math.min(rows.length, index + context + 1);
+    keep.fill(true, start, end);
+  });
+  if (!keep.some((value) => value)) {
+    return [];
+  }
+  const runStarts = keep.flatMap(
+    (kept, index) => kept || index > 0 && keep[index - 1] === false ? [] : [index]
+  );
+  return runStarts.map((start) => {
+    const nextKept = keep.indexOf(true, start);
+    const end = nextKept === -1 ? rows.length : nextKept;
+    return { start, count: end - start, expanded: false };
+  }).filter((fold2) => fold2.count >= minFold);
+}
+function buildModel(before, after, context, minFold) {
+  const rows = buildRows(before, after);
+  const folds = buildFolds(rows, context, minFold);
+  return { rows, folds, cursor: 0 };
+}
+function computeVisibleRows(model) {
+  const foldByStart = new Map(
+    model.folds.map((foldGroup, foldIndex) => [foldGroup.start, foldIndex])
+  );
+  const hidden = new Set(
+    model.folds.flatMap(
+      (foldGroup) => foldGroup.expanded ? [] : Array.from({ length: foldGroup.count }, (_, offset) => foldGroup.start + offset)
+    )
+  );
+  return model.rows.flatMap((_, index) => {
+    const foldIndex = foldByStart.get(index);
+    const foldGroup = foldIndex === void 0 ? void 0 : model.folds[foldIndex];
+    if (foldGroup !== void 0 && foldIndex !== void 0 && !foldGroup.expanded) {
+      return [{ kind: "fold", foldIndex }];
+    }
+    return hidden.has(index) ? [] : [{ kind: "row", index }];
+  });
+}
+var visibleRowsCache = /* @__PURE__ */ new WeakMap();
+function visibleRows(model) {
+  const byFolds = visibleRowsCache.get(model.rows) ?? /* @__PURE__ */ new WeakMap();
+  const cached = byFolds.get(model.folds);
+  if (cached !== void 0) {
+    return cached;
+  }
+  const computed = computeVisibleRows(model);
+  byFolds.set(model.folds, computed);
+  visibleRowsCache.set(model.rows, byFolds);
+  return computed;
+}
+function toggleFold(model, foldIndex) {
+  if (foldIndex < 0 || foldIndex >= model.folds.length) {
+    return model;
+  }
+  const folds = model.folds.map(
+    (foldGroup, index) => index === foldIndex ? { ...foldGroup, expanded: !foldGroup.expanded } : foldGroup
+  );
+  return { ...model, folds };
+}
+function moveCursor(model, delta) {
+  const visible = visibleRows(model);
+  if (visible.length === 0) {
+    return { ...model, cursor: 0 };
+  }
+  const clamped = Math.min(Math.max(model.cursor + delta, 0), visible.length - 1);
+  return { ...model, cursor: clamped };
+}
+function resolveClick(map, terminalRow, terminalColumn) {
+  const row = terminalRow - 1;
+  const column = terminalColumn - 1;
+  const screenRow = row >= 0 && row < map.rows.length ? map.rows[row] : void 0;
+  if (screenRow === void 0 || screenRow.kind === "chrome") {
+    return null;
+  }
+  if (screenRow.kind === "fold") {
+    return screenRow.index === null ? null : { kind: "fold", foldIndex: screenRow.index };
+  }
+  if (screenRow.index === null) {
+    return null;
+  }
+  const bounds = map.panes.find((pane) => column >= pane.textStart && column < pane.textEnd);
+  if (bounds === void 0) {
+    return null;
+  }
+  return {
+    kind: "row",
+    index: screenRow.index,
+    pane: bounds.pane,
+    column: column - bounds.textStart
+  };
+}
+
+// src/tui/selection/selection.ts
+function visibleIndexForRow(model, rowIndex) {
+  const visible = visibleRows(model);
+  const found = visible.findIndex((entry) => entry.kind === "row" && entry.index === rowIndex);
+  return found === -1 ? model.cursor : found;
+}
+function currentRowIndex(model) {
+  const visible = visibleRows(model);
+  const entry = visible[model.cursor];
+  return entry !== void 0 && entry.kind === "row" ? entry.index : null;
+}
+function cursorRowIndex(model) {
+  return currentRowIndex(model);
+}
+function lastColumn(model, rowIndex, pane) {
+  return Math.max(paneLineLength(model, rowIndex, pane) - 1, 0);
+}
+function wholeRowSelection(model, rowIndex, pane) {
+  return {
+    pane,
+    anchorRow: rowIndex,
+    anchorColumn: 0,
+    headRow: rowIndex,
+    headColumn: lastColumn(model, rowIndex, pane)
+  };
+}
+function moveSelectionHead(state, delta) {
+  const selection = state.selection;
+  if (selection === null) {
+    return state;
+  }
+  const visible = visibleRows(state.model);
+  const currentIndex = visible.findIndex(
+    (entry2) => entry2.kind === "row" && entry2.index === selection.headRow
+  );
+  if (currentIndex === -1) {
+    return state;
+  }
+  const nextIndex = Math.min(Math.max(currentIndex + delta, 0), Math.max(visible.length - 1, 0));
+  const entry = visible[nextIndex];
+  const headRow = entry !== void 0 && entry.kind === "row" ? entry.index : selection.headRow;
+  const headColumn = lastColumn(state.model, headRow, selection.pane);
+  return { ...state, selection: { ...selection, headRow, headColumn } };
+}
+function startSelection(state) {
+  const rowIndex = currentRowIndex(state.model);
+  if (rowIndex === null) {
+    return state;
+  }
+  const selection = wholeRowSelection(state.model, rowIndex, "right");
+  return { ...state, selection, mode: "select" };
+}
+function normalizeSelection(selection) {
+  const reversed = selection.anchorRow > selection.headRow || selection.anchorRow === selection.headRow && selection.anchorColumn > selection.headColumn;
+  if (!reversed) {
+    return selection;
+  }
+  return {
+    pane: selection.pane,
+    anchorRow: selection.headRow,
+    anchorColumn: selection.headColumn,
+    headRow: selection.anchorRow,
+    headColumn: selection.anchorColumn
+  };
+}
+function clampSpan(span, lineLength) {
+  return {
+    start: Math.min(Math.max(span.start, 0), lineLength),
+    end: Math.min(Math.max(span.end, 0), lineLength)
+  };
+}
+function selectionSpanFor(selection, rowIndex, lineLength) {
+  if (selection === null) {
+    return null;
+  }
+  const normalized = normalizeSelection(selection);
+  if (rowIndex < normalized.anchorRow || rowIndex > normalized.headRow) {
+    return null;
+  }
+  if (normalized.anchorRow === normalized.headRow) {
+    return clampSpan(
+      { start: normalized.anchorColumn, end: normalized.headColumn + 1 },
+      lineLength
+    );
+  }
+  if (rowIndex === normalized.anchorRow) {
+    return clampSpan({ start: normalized.anchorColumn, end: lineLength }, lineLength);
+  }
+  if (rowIndex === normalized.headRow) {
+    return clampSpan({ start: 0, end: normalized.headColumn + 1 }, lineLength);
+  }
+  return clampSpan({ start: 0, end: lineLength }, lineLength);
+}
+function paneLineLength(model, rowIndex, pane) {
+  const row = model.rows[rowIndex];
+  if (row === void 0) {
+    return 0;
+  }
+  return pane === "left" ? row.left.length : row.right.length;
+}
+function applyMouseDown(state, target) {
+  if (target.kind === "fold") {
+    return { ...state, model: toggleFold(state.model, target.foldIndex) };
+  }
+  const selection = {
+    pane: target.pane,
+    anchorRow: target.index,
+    anchorColumn: target.column,
+    headRow: target.index,
+    headColumn: target.column
+  };
+  const model = { ...state.model, cursor: visibleIndexForRow(state.model, target.index) };
+  return { ...state, selection, mode: "select", model };
+}
+function applyMouseDrag(state, target) {
+  const selection = state.selection;
+  if (selection === null || target === null || target.kind !== "row") {
+    return state;
+  }
+  const samePane = target.pane === selection.pane;
+  const lineLength = paneLineLength(state.model, target.index, selection.pane);
+  const headColumn = samePane ? target.column : Math.min(Math.max(target.column, 0), lineLength);
+  const nextSelection = { ...selection, headRow: target.index, headColumn };
+  return { ...state, selection: nextSelection };
+}
+function applyMouseUp(state) {
+  const selection = state.selection;
+  if (selection === null) {
+    return { ...state, mode: "browse" };
+  }
+  const normalized = normalizeSelection(selection);
+  const isPlainClick = normalized.anchorRow === normalized.headRow && normalized.anchorColumn === normalized.headColumn;
+  return { ...state, selection: isPlainClick ? null : normalized, mode: "browse" };
+}
+function applyMouse(state, event) {
+  if (event.shift) {
+    return state;
+  }
+  if (event.kind === "scroll") {
+    return state;
+  }
+  if (event.kind === "down") {
+    const target = resolveClick(state.map, event.row, event.column);
+    if (target === null) {
+      return state;
+    }
+    return applyMouseDown(state, target);
+  }
+  if (event.kind === "drag") {
+    const target = resolveClick(state.map, event.row, event.column);
+    return applyMouseDrag(state, target);
+  }
+  return applyMouseUp(state);
+}
+
+// src/helpers/hexColor.ts
+var HEX_COLOR = /^#[0-9a-fA-F]{6}$/;
+function isHexColor(value) {
+  return HEX_COLOR.test(value);
+}
+
+// src/tui/paint/theme.ts
+var RED_CHANNEL_START = 1;
+var GREEN_CHANNEL_START = 3;
+var BLUE_CHANNEL_START = 5;
+var CHANNEL_END = 7;
+var HEX_RADIX = 16;
+var theme = Object.freeze({
+  addBar: "#3FB950",
+  addSpan: "#1F5B2E",
+  delBar: "#F85149",
+  delSpan: "#6B2126",
+  selection: "#16324F",
+  note: "#D2A8FF",
+  fold: "#6E7681",
+  chrome: "#E8A33D",
+  statusText: "#1F1A12"
+});
+var RESET = "\x1B[0m";
+var DEFAULT_FG = "\x1B[39m";
+var DEFAULT_BG = "\x1B[49m";
+var ANSI_16 = {
+  [theme.addBar]: { fg: "\x1B[32m", bg: "\x1B[42m" },
+  [theme.addSpan]: { fg: "\x1B[32m", bg: "\x1B[42m" },
+  [theme.delBar]: { fg: "\x1B[31m", bg: "\x1B[41m" },
+  [theme.delSpan]: { fg: "\x1B[31m", bg: "\x1B[41m" },
+  [theme.selection]: { fg: "\x1B[34m", bg: "\x1B[44m" },
+  [theme.note]: { fg: "\x1B[35m", bg: "\x1B[45m" },
+  [theme.fold]: { fg: "\x1B[90m", bg: "\x1B[100m" },
+  [theme.chrome]: { fg: "\x1B[33m", bg: "\x1B[43m" },
+  [theme.statusText]: { fg: "\x1B[30m", bg: "\x1B[40m" }
+};
+function supportsTruecolor(env) {
+  return env.COLORTERM === "truecolor" || env.COLORTERM === "24bit";
+}
+function hexToRgb(hex) {
+  if (!isHexColor(hex)) {
+    return null;
+  }
+  return {
+    r: parseInt(hex.slice(RED_CHANNEL_START, GREEN_CHANNEL_START), HEX_RADIX),
+    g: parseInt(hex.slice(GREEN_CHANNEL_START, BLUE_CHANNEL_START), HEX_RADIX),
+    b: parseInt(hex.slice(BLUE_CHANNEL_START, CHANNEL_END), HEX_RADIX)
+  };
+}
+function fg(hex, truecolor) {
+  const rgb = hexToRgb(hex);
+  if (rgb === null) {
+    return DEFAULT_FG;
+  }
+  if (truecolor) {
+    return `\x1B[38;2;${rgb.r};${rgb.g};${rgb.b}m`;
+  }
+  const mapped = ANSI_16[hex];
+  return mapped === void 0 ? DEFAULT_FG : mapped.fg;
+}
+function bg(hex, truecolor) {
+  const rgb = hexToRgb(hex);
+  if (rgb === null) {
+    return DEFAULT_BG;
+  }
+  if (truecolor) {
+    return `\x1B[48;2;${rgb.r};${rgb.g};${rgb.b}m`;
+  }
+  const mapped = ANSI_16[hex];
+  return mapped === void 0 ? DEFAULT_BG : mapped.bg;
+}
+
+// src/tui/paint/layout.ts
+var NUMBER_WIDTH_FLOOR = 2;
+var GUTTER_SPACE_WIDTH = 1;
+var SIGN_BAR_WIDTH = 1;
+var DIVIDER_WIDTH = 1;
+var PANE_COUNT = 2;
+var HEADER_ROWS = 2;
+var STATUS_ROWS = 1;
+var HEADER_COUNT_GAP_WIDTH = 1;
+var UNIFIED_PANE_COUNT = 1;
+var TEXT_GAP_WIDTH = 1;
+var MIN_BODY_HEIGHT = 1;
+var MARKER_WIDTH = 1;
+var NOTE_MARKER = "\u25CF";
+var FOCUSED_NOTE_MARKER = "\u25B8";
+var PANEL_TITLE_ROWS = 1;
+var PANEL_DRAFT_ROWS = 1;
+var PANEL_MAX_HEIGHT = 6;
+var CONFIRM_PANEL_HEIGHT = 2;
+var CURSOR_WIDTH = 1;
+var NO_PANEL_HEIGHT = 0;
+var ANCHORED_CONNECTOR = "\u2570\u2500";
+var ANCHORED_FOCUSED_CONNECTOR = "\u2570\u25B8";
+var ANCHORED_CONNECTOR_GAP = " ";
+var UNIFIED_REPLACE_LINES = 2;
+var SINGLE_LINE = 1;
+var MIN_PAGE_ROWS = 1;
+var NO_SPANS = { left: [], right: [] };
+var SIGN_BAR = {
+  context: { leftChar: " ", leftColor: null, rightChar: " ", rightColor: null },
+  add: { leftChar: " ", leftColor: null, rightChar: "\u258C", rightColor: theme.addBar },
+  del: { leftChar: "\u258C", leftColor: theme.delBar, rightChar: " ", rightColor: null },
+  replace: { leftChar: "\u258C", leftColor: theme.delBar, rightChar: "\u258C", rightColor: theme.addBar }
+};
+function panelHeight(noteCount, mode, notePosition) {
+  if (mode === "confirm") {
+    return CONFIRM_PANEL_HEIGHT;
+  }
+  if (notePosition === "anchored") {
+    return NO_PANEL_HEIGHT;
+  }
+  const draftRows = mode === "note" ? PANEL_DRAFT_ROWS : 0;
+  const rowCount = noteCount + draftRows;
+  return rowCount === 0 ? 0 : Math.min(rowCount + PANEL_TITLE_ROWS, PANEL_MAX_HEIGHT);
+}
+function bodyHeight(height, noteCount, mode, notePosition) {
+  return Math.max(
+    height - HEADER_ROWS - STATUS_ROWS - panelHeight(noteCount, mode, notePosition),
+    MIN_BODY_HEIGHT
+  );
+}
+function isUnified(geometry) {
+  return geometry.layout === "unified" || geometry.width < MIN_SPLIT_WIDTH || !hasRemovals(geometry.model);
+}
+function anchoredExtraLines(geometry, rowIndex) {
+  if (geometry.notePosition !== "anchored") {
+    return 0;
+  }
+  const noteLines = geometry.notes.filter((note) => note.endRowIndex === rowIndex).length;
+  const draftLines = geometry.mode === "note" && draftAnchorRowFor(geometry.selection) === rowIndex ? 1 : 0;
+  return noteLines + draftLines;
+}
+function entryLineCount(geometry, entry) {
+  if (entry.kind === "fold") {
+    return SINGLE_LINE;
+  }
+  const row = lookupRow(geometry.model, entry.index);
+  const base = isUnified(geometry) && row.kind === "replace" ? UNIFIED_REPLACE_LINES : SINGLE_LINE;
+  return base + anchoredExtraLines(geometry, entry.index);
+}
+function geometryBodyRows(geometry) {
+  return bodyHeight(geometry.height, geometry.notes.length, geometry.mode, geometry.notePosition);
+}
+function rowsThatFit(geometry, scrollTop) {
+  const visible = visibleRows(geometry.model);
+  const bodyRows = geometryBodyRows(geometry);
+  let used = 0;
+  let count = 0;
+  for (let index = scrollTop; index < visible.length; index += 1) {
+    const cost = entryLineCount(geometry, visible[index]);
+    if (count > 0 && used + cost > bodyRows) {
+      break;
+    }
+    used += cost;
+    count += 1;
+    if (used >= bodyRows) {
+      break;
+    }
+  }
+  return count;
+}
+function lastFittingRow(geometry, scrollTop) {
+  return scrollTop + Math.max(rowsThatFit(geometry, scrollTop), SINGLE_LINE) - 1;
+}
+function scrollTopForRow(geometry, row) {
+  const visible = visibleRows(geometry.model);
+  const entry = visible[row];
+  if (entry === void 0) {
+    return 0;
+  }
+  const bodyRows = geometryBodyRows(geometry);
+  let used = entryLineCount(geometry, entry);
+  let top = row;
+  for (let index = row - 1; index >= 0; index -= 1) {
+    const cost = entryLineCount(geometry, visible[index]);
+    if (used + cost > bodyRows) {
+      break;
+    }
+    used += cost;
+    top = index;
+  }
+  return top;
+}
+function followScrollTop(geometry, scrollTop) {
+  const cursor = geometry.model.cursor;
+  if (cursor < scrollTop) {
+    return cursor;
+  }
+  return cursor <= lastFittingRow(geometry, scrollTop) ? scrollTop : scrollTopForRow(geometry, cursor);
+}
+function maxScrollTop(geometry) {
+  const visible = visibleRows(geometry.model);
+  return visible.length === 0 ? 0 : scrollTopForRow(geometry, visible.length - 1);
+}
+function pageRowStep(geometry, scrollTop) {
+  return Math.max(lastFittingRow(geometry, scrollTop) - scrollTop, MIN_PAGE_ROWS);
+}
+function hasPaneNotes(notes, pane) {
+  return notes.some((note) => note.pane === pane);
+}
+function coversRow(note, rowIndex, pane) {
+  return note.pane === pane && rowIndex >= note.rowIndex && rowIndex <= note.endRowIndex;
+}
+function noteSpanFor(note, rowIndex, lineLength) {
+  const start = rowIndex === note.rowIndex ? note.startColumn : 0;
+  const end = rowIndex === note.endRowIndex ? note.endColumn : lineLength;
+  return {
+    start: Math.min(Math.max(start, 0), lineLength),
+    end: Math.min(Math.max(end, 0), lineLength)
+  };
+}
+function noteSpansFor(notes, rowIndex, pane, lineLength) {
+  return notes.filter((note) => coversRow(note, rowIndex, pane)).map((note) => noteSpanFor(note, rowIndex, lineLength));
+}
+function isAnnotatedRow(notes, rowIndex, pane) {
+  return notes.some((note) => coversRow(note, rowIndex, pane));
+}
+function paintMarkerColumn(hasColumn, annotated, truecolor) {
+  if (!hasColumn) {
+    return "";
+  }
+  return annotated ? fg(theme.note, truecolor) + NOTE_MARKER + DEFAULT_FG : " ";
+}
+function widestNumber(rows) {
+  return rows.reduce(
+    (widest, row) => Math.max(widest, row.leftNumber ?? 0, row.rightNumber ?? 0),
+    0
+  );
+}
+var numberWidthCache = /* @__PURE__ */ new WeakMap();
+function computeNumberWidth(model) {
+  const cached = numberWidthCache.get(model.rows);
+  if (cached !== void 0) {
+    return cached;
+  }
+  const width = Math.max(NUMBER_WIDTH_FLOOR, String(widestNumber(model.rows)).length);
+  numberWidthCache.set(model.rows, width);
+  return width;
+}
+var changeCountCache = /* @__PURE__ */ new WeakMap();
+function changeCounts(model) {
+  const cached = changeCountCache.get(model.rows);
+  if (cached !== void 0) {
+    return cached;
+  }
+  const counts = model.rows.reduce(
+    (running, row) => ({
+      add: running.add + (row.kind === "add" || row.kind === "replace" ? 1 : 0),
+      del: running.del + (row.kind === "del" || row.kind === "replace" ? 1 : 0)
+    }),
+    { add: 0, del: 0 }
+  );
+  changeCountCache.set(model.rows, counts);
+  return counts;
+}
+function lookupRow(model, index) {
+  const row = model.rows[index];
+  if (row === void 0) {
+    throw new Error(`paintSplit: row index out of bounds: ${index}`);
+  }
+  return row;
+}
+function lookupFold(model, foldIndex) {
+  const fold2 = model.folds[foldIndex];
+  if (fold2 === void 0) {
+    throw new Error(`paintSplit: fold index out of bounds: ${foldIndex}`);
+  }
+  return fold2;
+}
+function paintGutter(lineNumber, numberWidth, truecolor, cursorRow) {
+  const text = lineNumber === null ? "" : String(lineNumber);
+  const color = cursorRow ? theme.chrome : theme.fold;
+  return fg(color, truecolor) + text.padStart(numberWidth, " ") + " " + DEFAULT_FG;
+}
+function paintSignBar(char, color, truecolor) {
+  return color === null ? DEFAULT_FG + char : fg(color, truecolor) + char;
+}
+function mergeSpans(spans) {
+  if (spans.length < 2) {
+    return spans;
+  }
+  return [...spans].sort((left, right) => left.start - right.start).reduce((merged, span) => {
+    const last = merged[merged.length - 1];
+    if (last === void 0 || span.start > last.end) {
+      return [...merged, span];
+    }
+    return [...merged.slice(0, -1), { start: last.start, end: Math.max(last.end, span.end) }];
+  }, []);
+}
+function renderPaneText(text, tokens, changeSpansForSide, changeColor, paneWidth, rowBand, truecolor, highlightSpans) {
+  const textLength = Math.min(text.length, paneWidth);
+  const highlights = mergeSpans(highlightSpans);
+  const parts = [];
+  let currentFg = void 0;
+  let currentBg = void 0;
+  let tokenCursor = 0;
+  let spanCursor = 0;
+  let highlightCursor = 0;
+  for (let column = 0; column < paneWidth; column += 1) {
+    while (tokenCursor < tokens.length && tokens[tokenCursor].end <= column) {
+      tokenCursor += 1;
+    }
+    while (spanCursor < changeSpansForSide.length && changeSpansForSide[spanCursor].end <= column) {
+      spanCursor += 1;
+    }
+    while (highlightCursor < highlights.length && highlights[highlightCursor].end <= column) {
+      highlightCursor += 1;
+    }
+    const token = tokens[tokenCursor];
+    const span = changeSpansForSide[spanCursor];
+    const highlight = highlights[highlightCursor];
+    const char = column < textLength ? text.charAt(column) : " ";
+    const desiredFg = column < textLength && token !== void 0 && column >= token.start ? token.color : null;
+    const withinSpan = span !== void 0 && column >= span.start;
+    const withinHighlight = highlight !== void 0 && column >= highlight.start;
+    const desiredBg = withinHighlight ? theme.selection : changeColor !== null && (rowBand || withinSpan) ? changeColor : null;
+    if (desiredFg !== currentFg) {
+      parts.push(desiredFg === null ? DEFAULT_FG : fg(desiredFg, truecolor));
+      currentFg = desiredFg;
+    }
+    if (desiredBg !== currentBg) {
+      parts.push(desiredBg === null ? DEFAULT_BG : bg(desiredBg, truecolor));
+      currentBg = desiredBg;
+    }
+    parts.push(char);
+  }
+  return parts.join("");
+}
+function paintModelRow(row, rowIndex, leftBounds, rightBounds, numberWidth, tokens, rowBand, changeBackground, truecolor, selection, notes, hasLeftMarkerColumn, hasRightMarkerColumn, cursorRow) {
+  const bar = SIGN_BAR[row.kind];
+  const spans = row.kind === "context" ? NO_SPANS : changedSpans(row.left, row.right);
+  const leftColor = changeBackground && (row.kind === "del" || row.kind === "replace") ? theme.delSpan : null;
+  const rightColor = changeBackground && (row.kind === "add" || row.kind === "replace") ? theme.addSpan : null;
+  const leftPaneWidth = leftBounds.textEnd - leftBounds.textStart;
+  const rightPaneWidth = rightBounds.textEnd - rightBounds.textStart;
+  const leftSelectionSpan = selection !== null && selection.pane === "left" ? selectionSpanFor(selection, rowIndex, row.left.length) : null;
+  const rightSelectionSpan = selection !== null && selection.pane === "right" ? selectionSpanFor(selection, rowIndex, row.right.length) : null;
+  const leftHighlights = [
+    ...leftSelectionSpan === null ? [] : [leftSelectionSpan],
+    ...noteSpansFor(notes, rowIndex, "left", row.left.length)
+  ];
+  const rightHighlights = [
+    ...rightSelectionSpan === null ? [] : [rightSelectionSpan],
+    ...noteSpansFor(notes, rowIndex, "right", row.right.length)
+  ];
+  const leftText = renderPaneText(
+    row.left,
+    tokens(row.left, row.leftNumber),
+    spans.left,
+    leftColor,
+    leftPaneWidth,
+    rowBand,
+    truecolor,
+    leftHighlights
+  );
+  const rightText = renderPaneText(
+    row.right,
+    tokens(row.right, row.rightNumber),
+    spans.right,
+    rightColor,
+    rightPaneWidth,
+    rowBand,
+    truecolor,
+    rightHighlights
+  );
+  const divider = fg(theme.fold, truecolor) + "\u2502" + DEFAULT_FG;
+  return paintGutter(row.leftNumber, numberWidth, truecolor, cursorRow) + paintSignBar(bar.leftChar, bar.leftColor, truecolor) + paintMarkerColumn(hasLeftMarkerColumn, isAnnotatedRow(notes, rowIndex, "left"), truecolor) + leftText + divider + paintGutter(row.rightNumber, numberWidth, truecolor, cursorRow) + paintSignBar(bar.rightChar, bar.rightColor, truecolor) + paintMarkerColumn(hasRightMarkerColumn, isAnnotatedRow(notes, rowIndex, "right"), truecolor) + rightText + RESET;
+}
+function paintFoldRow(fold2, width, truecolor, cursorRow) {
+  const label = `\u22EF ${fold2.count} unchanged lines`;
+  const totalPadding = Math.max(0, width - label.length);
+  const leftPadding = Math.floor(totalPadding / 2);
+  const rightPadding = totalPadding - leftPadding;
+  const color = cursorRow ? theme.chrome : theme.fold;
+  return fg(color, truecolor) + " ".repeat(leftPadding) + label + " ".repeat(rightPadding) + RESET;
+}
+function paintHeader(path, addCount, delCount, width, truecolor) {
+  const prefix = `pair mode\u2502${basename(path)}\u2502`;
+  const addText = `+${addCount}`;
+  const delText = `-${delCount}`;
+  const used = prefix.length + addText.length + HEADER_COUNT_GAP_WIDTH + delText.length;
+  const padding = " ".repeat(Math.max(0, width - used));
+  return fg(theme.chrome, truecolor) + prefix + fg(theme.addBar, truecolor) + addText + fg(theme.chrome, truecolor) + " ".repeat(HEADER_COUNT_GAP_WIDTH) + fg(theme.delBar, truecolor) + delText + fg(theme.chrome, truecolor) + padding + RESET;
+}
+function paintRule(width, truecolor) {
+  return fg(theme.fold, truecolor) + "\u2500".repeat(width) + RESET;
+}
+var KEY_HINTS = [
+  "j/k move",
+  "^d/^u page",
+  "n/N hunk",
+  "v select",
+  "a note",
+  "tab cycle",
+  "d delete",
+  "space fold",
+  "u layout",
+  "s send",
+  "q quit",
+  "? keys"
+];
+var HINT_SEPARATOR = " \xB7 ";
+function fitHints(width) {
+  return KEY_HINTS.reduce((kept, hint) => {
+    const candidate = kept === "" ? hint : kept + HINT_SEPARATOR + hint;
+    return candidate.length <= width ? candidate : kept;
+  }, "");
+}
+function paintStatus(width, truecolor, message) {
+  const text = message === null ? fitHints(width) : message.slice(0, width);
+  const padding = " ".repeat(Math.max(0, width - text.length));
+  return bg(theme.chrome, truecolor) + fg(theme.statusText, truecolor) + text + padding + RESET;
+}
+function paintBlankLine(width) {
+  return " ".repeat(width) + RESET;
+}
+function padPanelLine(content, contentLength, width) {
+  return content + " ".repeat(Math.max(0, width - contentLength)) + RESET;
+}
+function paintPanelTitle(noteCount, width, truecolor) {
+  const text = `NOTES (${noteCount})`.slice(0, width);
+  return padPanelLine(fg(theme.note, truecolor) + text + DEFAULT_FG, text.length, width);
+}
+function lineLabel(line) {
+  return line === null ? "?" : String(line);
+}
+function noteAnchorLabel(note) {
+  return note.endRowIndex === note.rowIndex ? `L${lineLabel(note.line)}` : `L${lineLabel(note.line)}-${lineLabel(note.endLine)}`;
+}
+function paintNoteRow(note, focused, width, truecolor) {
+  const marker = focused ? FOCUSED_NOTE_MARKER : NOTE_MARKER;
+  const rest = ` ${noteAnchorLabel(note)} ${note.text}`.slice(0, Math.max(0, width - MARKER_WIDTH));
+  return padPanelLine(
+    fg(theme.note, truecolor) + marker + DEFAULT_FG + rest,
+    marker.length + rest.length,
+    width
+  );
+}
+function paintDraftRow(draft, width, truecolor) {
+  const text = draft.slice(0, Math.max(0, width - CURSOR_WIDTH));
+  const cursor = bg(theme.chrome, truecolor) + " " + DEFAULT_BG;
+  return padPanelLine(text + cursor, text.length + CURSOR_WIDTH, width);
+}
+function paintAnchoredNoteRow(note, focused, width, truecolor) {
+  const connector = focused ? ANCHORED_FOCUSED_CONNECTOR : ANCHORED_CONNECTOR;
+  const maxTextWidth = Math.max(0, width - connector.length - ANCHORED_CONNECTOR_GAP.length);
+  const text = note.text.slice(0, maxTextWidth);
+  const content = fg(theme.fold, truecolor) + connector + DEFAULT_FG + ANCHORED_CONNECTOR_GAP + fg(theme.note, truecolor) + text + DEFAULT_FG;
+  const plainLength = connector.length + ANCHORED_CONNECTOR_GAP.length + text.length;
+  return padPanelLine(content, plainLength, width);
+}
+function paintAnchoredDraftRow(draft, width, truecolor) {
+  const connector = ANCHORED_CONNECTOR;
+  const maxTextWidth = Math.max(
+    0,
+    width - connector.length - ANCHORED_CONNECTOR_GAP.length - CURSOR_WIDTH
+  );
+  const text = draft.slice(0, maxTextWidth);
+  const cursor = bg(theme.chrome, truecolor) + " " + DEFAULT_BG;
+  const content = fg(theme.fold, truecolor) + connector + DEFAULT_FG + ANCHORED_CONNECTOR_GAP + text + cursor;
+  const plainLength = connector.length + ANCHORED_CONNECTOR_GAP.length + text.length + CURSOR_WIDTH;
+  return padPanelLine(content, plainLength, width);
+}
+function draftAnchorRowFor(selection) {
+  return selection === null ? null : Math.min(selection.anchorRow, selection.headRow);
+}
+function anchoredNoteRowsFor(rowIndex, notes, focusedNote, width, truecolor) {
+  const rowNotes = notes.filter((note) => note.endRowIndex === rowIndex).sort((left, right) => left.id - right.id);
+  const chromeRow = { kind: "chrome", index: null };
+  return {
+    lines: rowNotes.map(
+      (note) => paintAnchoredNoteRow(note, note.id === focusedNote, width, truecolor)
+    ),
+    screenRows: rowNotes.map(() => chromeRow)
+  };
+}
+function anchoredExtrasFor(rowIndex, options, width, truecolor) {
+  const { notes, focusedNote, mode, draft, selection } = options;
+  const noteEntries = anchoredNoteRowsFor(rowIndex, notes, focusedNote, width, truecolor);
+  const showDraft = mode === "note" && draftAnchorRowFor(selection) === rowIndex;
+  if (!showDraft) {
+    return noteEntries;
+  }
+  const chromeRow = { kind: "chrome", index: null };
+  return {
+    lines: [...noteEntries.lines, paintAnchoredDraftRow(draft, width, truecolor)],
+    screenRows: [...noteEntries.screenRows, chromeRow]
+  };
+}
+function paintConfirmSummary(noteCount, width, truecolor) {
+  const text = `${noteCount} notes are not sent.`.slice(0, width);
+  return padPanelLine(fg(theme.chrome, truecolor) + text + DEFAULT_FG, text.length, width);
+}
+function paintConfirmChoices(width, truecolor) {
+  const choices = [
+    ["s", " send   "],
+    ["d", " discard and apply the edit   "],
+    ["esc", " back"]
+  ];
+  const content = choices.map(([key, label]) => bg(theme.chrome, truecolor) + key + DEFAULT_BG + label).join("");
+  const plainLength = choices.reduce((sum, [key, label]) => sum + key.length + label.length, 0);
+  return padPanelLine(content, plainLength, width);
+}
+function buildPanel(options, width, truecolor) {
+  const { notes, focusedNote, mode, draft, notePosition } = options;
+  const height = panelHeight(notes.length, mode, notePosition);
+  if (height === 0) {
+    return { lines: [], screenRows: [] };
+  }
+  const chromeRow = { kind: "chrome", index: null };
+  if (mode === "confirm") {
+    return {
+      lines: [
+        paintConfirmSummary(notes.length, width, truecolor),
+        paintConfirmChoices(width, truecolor)
+      ],
+      screenRows: [chromeRow, chromeRow]
+    };
+  }
+  const draftRows = mode === "note" ? PANEL_DRAFT_ROWS : 0;
+  const availableForNotes = Math.max(0, height - PANEL_TITLE_ROWS - draftRows);
+  const visibleNotes = notes.slice(0, availableForNotes);
+  const lines = [
+    paintPanelTitle(notes.length, width, truecolor),
+    ...visibleNotes.map((note) => paintNoteRow(note, note.id === focusedNote, width, truecolor)),
+    ...mode === "note" ? [paintDraftRow(draft, width, truecolor)] : []
+  ];
+  return { lines, screenRows: lines.map(() => chromeRow) };
+}
+function takeBodyEntries(entries, bodyRows) {
+  const lines = [];
+  const screenRows = [];
+  let count = 0;
+  for (const entry of entries) {
+    if (count > 0 && lines.length + entry.lines.length > bodyRows) {
+      break;
+    }
+    lines.push(...entry.lines);
+    screenRows.push(...entry.screenRows);
+    count += 1;
+    if (lines.length >= bodyRows) {
+      break;
+    }
+  }
+  return { lines: lines.slice(0, bodyRows), screenRows: screenRows.slice(0, bodyRows), count };
+}
+function assembleScreen(header, rule, bodyLines, bodyScreenRows, bodyRows, panelLines, panelScreenRows, statusMessage, width, height, truecolor, panes, lastRow) {
+  const padCount = Math.max(0, bodyRows - bodyLines.length);
+  const padLines = Array.from({ length: padCount }, () => paintBlankLine(width));
+  const padScreenRows = Array.from({ length: padCount }, () => ({
+    kind: "chrome",
+    index: null
+  }));
+  const lines = [
+    header,
+    rule,
+    ...bodyLines,
+    ...padLines,
+    ...panelLines,
+    paintStatus(width, truecolor, statusMessage)
+  ].slice(0, height);
+  const allRows = [
+    { kind: "chrome", index: null },
+    { kind: "chrome", index: null },
+    ...bodyScreenRows,
+    ...padScreenRows,
+    ...panelScreenRows,
+    { kind: "chrome", index: null }
+  ];
+  const rows = allRows.slice(0, height);
+  const map = { rows, panes };
+  return { lines, map, lastRow };
+}
+function paintSplit(options) {
+  const {
+    model,
+    width,
+    height,
+    path,
+    tokens,
+    truecolor,
+    rowBand,
+    scrollTop,
+    selection,
+    notes,
+    mode,
+    notePosition
+  } = options;
+  const numberWidth = computeNumberWidth(model);
+  const changeBackground = hasRemovals(model);
+  const hasLeftMarkerColumn = hasPaneNotes(notes, "left");
+  const hasRightMarkerColumn = hasPaneNotes(notes, "right");
+  const leftMarkerWidth = hasLeftMarkerColumn ? MARKER_WIDTH : 0;
+  const rightMarkerWidth = hasRightMarkerColumn ? MARKER_WIDTH : 0;
+  const fixedWidth = PANE_COUNT * (numberWidth + GUTTER_SPACE_WIDTH + SIGN_BAR_WIDTH) + DIVIDER_WIDTH + leftMarkerWidth + rightMarkerWidth;
+  const remaining = Math.max(0, width - fixedWidth);
+  const leftPaneWidth = Math.floor(remaining / PANE_COUNT);
+  const rightPaneWidth = remaining - leftPaneWidth;
+  const leftTextStart = numberWidth + GUTTER_SPACE_WIDTH + SIGN_BAR_WIDTH + leftMarkerWidth;
+  const leftTextEnd = leftTextStart + leftPaneWidth;
+  const rightGutterStart = leftTextEnd + DIVIDER_WIDTH;
+  const rightTextStart = rightGutterStart + numberWidth + GUTTER_SPACE_WIDTH + SIGN_BAR_WIDTH + rightMarkerWidth;
+  const rightTextEnd = rightTextStart + rightPaneWidth;
+  const leftBounds = {
+    pane: "left",
+    gutterStart: 0,
+    textStart: leftTextStart,
+    textEnd: leftTextEnd
+  };
+  const rightBounds = {
+    pane: "right",
+    gutterStart: rightGutterStart,
+    textStart: rightTextStart,
+    textEnd: rightTextEnd
+  };
+  const counts = changeCounts(model);
+  const bodyRows = bodyHeight(height, notes.length, mode, notePosition);
+  const visible = visibleRows(model).slice(scrollTop, scrollTop + bodyRows);
+  const bodyEntries = visible.map((entry, offset) => {
+    const cursorRow = scrollTop + offset === model.cursor;
+    if (entry.kind === "fold") {
+      return {
+        lines: [paintFoldRow(lookupFold(model, entry.foldIndex), width, truecolor, cursorRow)],
+        screenRows: [{ kind: "fold", index: entry.foldIndex }]
+      };
+    }
+    const line = paintModelRow(
+      lookupRow(model, entry.index),
+      entry.index,
+      leftBounds,
+      rightBounds,
+      numberWidth,
+      tokens,
+      rowBand,
+      changeBackground,
+      truecolor,
+      selection,
+      notes,
+      hasLeftMarkerColumn,
+      hasRightMarkerColumn,
+      cursorRow
+    );
+    const screenRow = { kind: "row", index: entry.index };
+    const extras = notePosition === "anchored" ? anchoredExtrasFor(entry.index, options, width, truecolor) : { lines: [], screenRows: [] };
+    return { lines: [line, ...extras.lines], screenRows: [screenRow, ...extras.screenRows] };
+  });
+  const fill = takeBodyEntries(bodyEntries, bodyRows);
+  const panel = buildPanel(options, width, truecolor);
+  return assembleScreen(
+    paintHeader(path, counts.add, counts.del, width, truecolor),
+    paintRule(width, truecolor),
+    fill.lines,
+    fill.screenRows,
+    bodyRows,
+    panel.lines,
+    panel.screenRows,
+    null,
+    width,
+    height,
+    truecolor,
+    [leftBounds, rightBounds],
+    scrollTop + Math.max(fill.count, 1) - 1
+  );
+}
+var UNIFIED_SIGN_BAR = {
+  context: { char: " ", color: null },
+  add: { char: "\u258C", color: theme.addBar },
+  del: { char: "\u258C", color: theme.delBar }
+};
+function paintUnifiedHalf(halfKind, lineNumber, text, tokens, spans, changeColor, numberWidth, textWidth, rowBand, truecolor, highlightSpans, hasMarkerColumn, annotated, cursorRow) {
+  const bar = UNIFIED_SIGN_BAR[halfKind];
+  const rendered = renderPaneText(
+    text,
+    tokens,
+    spans,
+    changeColor,
+    textWidth,
+    rowBand,
+    truecolor,
+    highlightSpans
+  );
+  return paintGutter(lineNumber, numberWidth, truecolor, cursorRow) + paintSignBar(bar.char, bar.color, truecolor) + paintMarkerColumn(hasMarkerColumn, annotated, truecolor) + " ".repeat(TEXT_GAP_WIDTH) + rendered + RESET;
+}
+function paintUnifiedBodyEntry(entry, model, numberWidth, textWidth, width, tokens, rowBand, changeBackground, truecolor, selection, notes, hasMarkerColumn, cursorRow) {
+  if (entry.kind === "fold") {
+    return {
+      lines: [paintFoldRow(lookupFold(model, entry.foldIndex), width, truecolor, cursorRow)],
+      screenRows: [{ kind: "fold", index: entry.foldIndex }]
+    };
+  }
+  const row = lookupRow(model, entry.index);
+  const spans = row.kind === "context" ? NO_SPANS : changedSpans(row.left, row.right);
+  const screenRow = { kind: "row", index: entry.index };
+  const hasSelection = selection !== null && selection.pane === "right";
+  const addColor = changeBackground ? theme.addSpan : null;
+  const delColor = changeBackground ? theme.delSpan : null;
+  if (row.kind === "context") {
+    const selectionSpan = hasSelection ? selectionSpanFor(selection, entry.index, row.right.length) : null;
+    const highlights = [
+      ...selectionSpan === null ? [] : [selectionSpan],
+      ...noteSpansFor(notes, entry.index, "right", row.right.length)
+    ];
+    const line = paintUnifiedHalf(
+      "context",
+      row.rightNumber,
+      row.right,
+      tokens(row.right, row.rightNumber),
+      [],
+      null,
+      numberWidth,
+      textWidth,
+      rowBand,
+      truecolor,
+      highlights,
+      hasMarkerColumn,
+      isAnnotatedRow(notes, entry.index, "right"),
+      cursorRow
+    );
+    return { lines: [line], screenRows: [screenRow] };
+  }
+  if (row.kind === "add") {
+    const selectionSpan = hasSelection ? selectionSpanFor(selection, entry.index, row.right.length) : null;
+    const highlights = [
+      ...selectionSpan === null ? [] : [selectionSpan],
+      ...noteSpansFor(notes, entry.index, "right", row.right.length)
+    ];
+    const line = paintUnifiedHalf(
+      "add",
+      row.rightNumber,
+      row.right,
+      tokens(row.right, row.rightNumber),
+      spans.right,
+      addColor,
+      numberWidth,
+      textWidth,
+      rowBand,
+      truecolor,
+      highlights,
+      hasMarkerColumn,
+      isAnnotatedRow(notes, entry.index, "right"),
+      cursorRow
+    );
+    return { lines: [line], screenRows: [screenRow] };
+  }
+  if (row.kind === "del") {
+    const selectionSpan = hasSelection ? selectionSpanFor(selection, entry.index, row.left.length) : null;
+    const highlights = [
+      ...selectionSpan === null ? [] : [selectionSpan],
+      ...noteSpansFor(notes, entry.index, "left", row.left.length)
+    ];
+    const line = paintUnifiedHalf(
+      "del",
+      row.leftNumber,
+      row.left,
+      tokens(row.left, row.leftNumber),
+      spans.left,
+      delColor,
+      numberWidth,
+      textWidth,
+      rowBand,
+      truecolor,
+      highlights,
+      hasMarkerColumn,
+      isAnnotatedRow(notes, entry.index, "left"),
+      cursorRow
+    );
+    return { lines: [line], screenRows: [screenRow] };
+  }
+  const delSelectionSpan = hasSelection ? selectionSpanFor(selection, entry.index, row.left.length) : null;
+  const addSelectionSpan = hasSelection ? selectionSpanFor(selection, entry.index, row.right.length) : null;
+  const delHighlights = [
+    ...delSelectionSpan === null ? [] : [delSelectionSpan],
+    ...noteSpansFor(notes, entry.index, "left", row.left.length)
+  ];
+  const addHighlights = [
+    ...addSelectionSpan === null ? [] : [addSelectionSpan],
+    ...noteSpansFor(notes, entry.index, "right", row.right.length)
+  ];
+  const delLine = paintUnifiedHalf(
+    "del",
+    row.leftNumber,
+    row.left,
+    tokens(row.left, row.leftNumber),
+    spans.left,
+    delColor,
+    numberWidth,
+    textWidth,
+    rowBand,
+    truecolor,
+    delHighlights,
+    hasMarkerColumn,
+    isAnnotatedRow(notes, entry.index, "left"),
+    cursorRow
+  );
+  const addLine = paintUnifiedHalf(
+    "add",
+    row.rightNumber,
+    row.right,
+    tokens(row.right, row.rightNumber),
+    spans.right,
+    addColor,
+    numberWidth,
+    textWidth,
+    rowBand,
+    truecolor,
+    addHighlights,
+    hasMarkerColumn,
+    isAnnotatedRow(notes, entry.index, "right"),
+    cursorRow
+  );
+  return { lines: [delLine, addLine], screenRows: [screenRow, screenRow] };
+}
+function paintUnified(options) {
+  const {
+    model,
+    width,
+    height,
+    path,
+    tokens,
+    truecolor,
+    rowBand,
+    scrollTop,
+    selection,
+    notes,
+    mode,
+    notePosition
+  } = options;
+  const numberWidth = computeNumberWidth(model);
+  const changeBackground = hasRemovals(model);
+  const hasMarkerColumn = notes.length > 0;
+  const markerWidth = hasMarkerColumn ? MARKER_WIDTH : 0;
+  const fixedWidth = UNIFIED_PANE_COUNT * (numberWidth + GUTTER_SPACE_WIDTH + SIGN_BAR_WIDTH) + markerWidth + TEXT_GAP_WIDTH;
+  const textStart = fixedWidth;
+  const textWidth = Math.max(0, width - fixedWidth);
+  const textEnd = textStart + textWidth;
+  const rightBounds = { pane: "right", gutterStart: 0, textStart, textEnd };
+  const counts = changeCounts(model);
+  const bodyRows = bodyHeight(height, notes.length, mode, notePosition);
+  const visible = visibleRows(model).slice(scrollTop, scrollTop + bodyRows);
+  const entries = visible.map((entry, offset) => {
+    const cursorRow = scrollTop + offset === model.cursor;
+    const base = paintUnifiedBodyEntry(
+      entry,
+      model,
+      numberWidth,
+      textWidth,
+      width,
+      tokens,
+      rowBand,
+      changeBackground,
+      truecolor,
+      selection,
+      notes,
+      hasMarkerColumn,
+      cursorRow
+    );
+    if (notePosition !== "anchored" || entry.kind === "fold") {
+      return base;
+    }
+    const extras = anchoredExtrasFor(entry.index, options, width, truecolor);
+    return {
+      lines: [...base.lines, ...extras.lines],
+      screenRows: [...base.screenRows, ...extras.screenRows]
+    };
+  });
+  const fill = takeBodyEntries(entries, bodyRows);
+  const statusMessage = layoutStatusMessage(options);
+  const panel = buildPanel(options, width, truecolor);
+  return assembleScreen(
+    paintHeader(path, counts.add, counts.del, width, truecolor),
+    paintRule(width, truecolor),
+    fill.lines,
+    fill.screenRows,
+    bodyRows,
+    panel.lines,
+    panel.screenRows,
+    statusMessage,
+    width,
+    height,
+    truecolor,
+    [rightBounds],
+    scrollTop + Math.max(fill.count, 1) - 1
+  );
+}
+
+// src/tui/paint/paint.ts
+var SPAN_SIMILARITY_FLOOR = 0.3;
+var MIN_SPLIT_WIDTH = 90;
+var NEW_FILE_REASON = "whole file is new \xB7 unified";
+var NARROW_REASON = "narrow \xB7 unified";
+var noTokens = () => [];
+function hasRemovals(model) {
+  return model.rows.some((row) => row.kind === "del" || row.kind === "replace");
+}
+function indentWidth(line) {
+  return line.length - line.trimStart().length;
+}
+function changedSpans(before, after) {
+  const chunks = diffWordsWithSpace(before, after);
+  const scan = chunks.reduce(
+    (state, chunk) => {
+      const length = chunk.value.length;
+      if (chunk.removed === true) {
+        return {
+          ...state,
+          left: [...state.left, { start: state.leftCursor, end: state.leftCursor + length }],
+          leftCursor: state.leftCursor + length
+        };
+      }
+      if (chunk.added === true) {
+        return {
+          ...state,
+          right: [...state.right, { start: state.rightCursor, end: state.rightCursor + length }],
+          rightCursor: state.rightCursor + length
+        };
+      }
+      return {
+        ...state,
+        sharedLength: state.sharedLength + length,
+        leftCursor: state.leftCursor + length,
+        rightCursor: state.rightCursor + length
+      };
+    },
+    { left: [], right: [], sharedLength: 0, leftCursor: 0, rightCursor: 0 }
+  );
+  const { left, right, sharedLength } = scan;
+  const indent = Math.min(indentWidth(before), indentWidth(after));
+  const longer = Math.max(before.length, after.length) - indent;
+  const sharedFraction = longer <= 0 ? 1 : (sharedLength - indent) / longer;
+  if (sharedFraction < SPAN_SIMILARITY_FLOOR) {
+    return {
+      left: before === "" ? [] : [{ start: 0, end: before.length }],
+      right: after === "" ? [] : [{ start: 0, end: after.length }]
+    };
+  }
+  return { left, right };
+}
+function decideLayout(options) {
+  const preferred = options.layout;
+  const forcedReason = !hasRemovals(options.model) ? NEW_FILE_REASON : options.width < MIN_SPLIT_WIDTH ? NARROW_REASON : null;
+  if (forcedReason === null) {
+    return { layout: preferred, overrideReason: null };
+  }
+  return { layout: "unified", overrideReason: preferred === "split" ? forcedReason : null };
+}
+function layoutStatusMessage(options) {
+  return decideLayout(options).overrideReason;
+}
+function paint(options) {
+  const { layout } = decideLayout(options);
+  return layout === "unified" ? paintUnified(options) : paintSplit(options);
+}
+
+// src/editors/languages.ts
+import { extname } from "node:path";
+var LANGS = {
+  ".go": "go",
+  ".rb": "ruby",
+  ".rake": "ruby",
+  ".ts": "typescript",
+  ".tsx": "typescript",
+  ".js": "javascript",
+  ".jsx": "javascript",
+  ".mjs": "javascript",
+  ".py": "python3",
+  ".ex": "elixir",
+  ".exs": "elixir",
+  ".rs": "rust",
+  ".sh": "sh",
+  ".bash": "sh",
+  ".fish": "fish",
+  ".zsh": "zsh",
+  ".sql": "sql",
+  ".json": "json",
+  ".tf": "terraform",
+  ".proto": "proto",
+  ".dockerfile": "dockerfile",
+  ".toml": "toml",
+  ".yaml": "yaml",
+  ".yml": "yaml",
+  ".md": "markdown",
+  ".css": "css",
+  ".html": "html",
+  ".erb": "html",
+  ".lua": "lua",
+  ".c": "c",
+  ".h": "c"
+};
+function syntaxName(sourcePath) {
+  const ext = extname(sourcePath).toLowerCase();
+  return LANGS[ext] ?? null;
+}
+var SHIKI_TRANSLATIONS = {
+  python3: "python",
+  sh: "shellscript",
+  zsh: "shellscript",
+  fish: "fish",
+  proto: "proto",
+  dockerfile: "docker",
+  terraform: "terraform"
+};
+function shikiLanguage(sourcePath) {
+  const name = syntaxName(sourcePath);
+  if (name === null) {
+    return null;
+  }
+  return SHIKI_TRANSLATIONS[name] ?? name;
+}
+
+// src/tui/syntax/syntax.ts
+var THEME_ID = "github-dark";
+var MAX_CACHED_LINES = 4096;
+var providers = /* @__PURE__ */ new Map();
+function isBundledLanguage(lang, bundled) {
+  return lang in bundled;
+}
+function isBundledTheme(id, bundled) {
+  return id in bundled;
+}
+var loadShikiHighlighter = async (lang, theme2) => {
+  const shiki = await import("shiki");
+  if (!isBundledLanguage(lang, shiki.bundledLanguages) || !isBundledTheme(theme2, shiki.bundledThemes)) {
+    throw new Error(`shiki does not bundle language "${lang}" or theme "${theme2}"`);
+  }
+  const highlighter = await shiki.createHighlighter({ langs: [lang], themes: [theme2] });
+  return {
+    codeToTokensBase(code, options) {
+      if (!isBundledLanguage(options.lang, shiki.bundledLanguages) || !isBundledTheme(options.theme, shiki.bundledThemes)) {
+        return [[]];
+      }
+      return highlighter.codeToTokensBase(code, { lang: options.lang, theme: options.theme });
+    }
+  };
+};
+function hasColor(token) {
+  return typeof token.color === "string";
+}
+function tokenizeLine(highlighter, lang, line) {
+  const tokenizedLines = highlighter.codeToTokensBase(line, { lang, theme: THEME_ID });
+  const lineTokens = tokenizedLines[0] ?? [];
+  return lineTokens.filter(hasColor).map((token) => ({
+    start: token.offset,
+    end: token.offset + token.content.length,
+    color: token.color
+  }));
+}
+async function tryLoadHighlighter(load, lang, theme2) {
+  try {
+    return await load(lang, theme2);
+  } catch {
+    return null;
+  }
+}
+function remember(cache, line, tokens) {
+  if (cache.size >= MAX_CACHED_LINES) {
+    const oldest = cache.keys().next();
+    if (oldest.done !== true) {
+      cache.delete(oldest.value);
+    }
+  }
+  cache.set(line, tokens);
+}
+async function buildTokenProvider(load, lang) {
+  const highlighter = await tryLoadHighlighter(load, lang, THEME_ID);
+  if (highlighter === null) {
+    return noTokens;
+  }
+  const cache = /* @__PURE__ */ new Map();
+  return (line) => {
+    const cached = cache.get(line);
+    if (cached !== void 0) {
+      return cached;
+    }
+    const tokens = tokenizeLine(highlighter, lang, line);
+    remember(cache, line, tokens);
+    return tokens;
+  };
+}
+async function createTokenProvider(options, loadHighlighter = loadShikiHighlighter) {
+  if (!options.enabled) {
+    return noTokens;
+  }
+  const lang = shikiLanguage(options.path);
+  if (lang === null) {
+    return noTokens;
+  }
+  if (loadHighlighter !== loadShikiHighlighter) {
+    return buildTokenProvider(loadHighlighter, lang);
+  }
+  const shared = providers.get(lang);
+  if (shared !== void 0) {
+    return shared;
+  }
+  const created = buildTokenProvider(loadHighlighter, lang);
+  providers.set(lang, created);
+  return created;
+}
+
+// src/tui/input/keys.ts
+var ESC = "\x1B";
+var CSI_FINAL_START = 64;
+var CSI_FINAL_END = 126;
+var CSI_PARAM_RUN = /^[\x20-\x3f]*/;
+var ARROW_NAMES = {
+  A: "up",
+  B: "down",
+  C: "right",
+  D: "left"
+};
+var CTRL_NAMES = {
+  "": "d",
+  "": "u",
+  "": "s",
+  "": "q",
+  "": "c"
+};
+function consumeMouseSequence(chunk, start) {
+  const closeIndex = chunk.slice(start).search(/[Mm]/);
+  if (closeIndex === -1) {
+    return chunk.length;
+  }
+  return start + closeIndex + 1;
+}
+function consumeUnknownCsi(chunk, start) {
+  const params = CSI_PARAM_RUN.exec(chunk.slice(start))?.[0] ?? "";
+  const afterParams = start + params.length;
+  const code = chunk.charCodeAt(afterParams);
+  return code >= CSI_FINAL_START && code <= CSI_FINAL_END ? afterParams + 1 : afterParams;
+}
+function parseEscape(chunk, index) {
+  const afterEsc = index + 1;
+  if (afterEsc >= chunk.length || chunk[afterEsc] !== "[") {
+    return { event: { name: "escape", ctrl: false, text: "" }, next: afterEsc };
+  }
+  const afterBracket = afterEsc + 1;
+  const marker = afterBracket < chunk.length ? chunk[afterBracket] : void 0;
+  if (marker === "<") {
+    return { event: null, next: consumeMouseSequence(chunk, afterBracket + 1) };
+  }
+  if (marker !== void 0 && marker in ARROW_NAMES) {
+    return { event: { name: ARROW_NAMES[marker], ctrl: false, text: "" }, next: afterBracket + 1 };
+  }
+  return { event: null, next: consumeUnknownCsi(chunk, afterBracket) };
+}
+function parseSingle(chunk, index) {
+  const char = chunk[index];
+  const next = index + 1;
+  if (char === "\r" || char === "\n") {
+    return { event: { name: "enter", ctrl: false, text: "" }, next };
+  }
+  if (char === "\x7F" || char === "\b") {
+    return { event: { name: "backspace", ctrl: false, text: "" }, next };
+  }
+  if (char === "	") {
+    return { event: { name: "tab", ctrl: false, text: "" }, next };
+  }
+  const ctrlName = CTRL_NAMES[char];
+  if (ctrlName !== void 0) {
+    return { event: { name: ctrlName, ctrl: true, text: "" }, next };
+  }
+  return { event: { name: char, ctrl: false, text: char }, next };
+}
+function parseKeys(chunk) {
+  const events = [];
+  let index = 0;
+  while (index < chunk.length) {
+    if (chunk[index] === ESC) {
+      const result2 = parseEscape(chunk, index);
+      if (result2.event !== null) {
+        events.push(result2.event);
+      }
+      index = result2.next;
+      continue;
+    }
+    const result = parseSingle(chunk, index);
+    events.push(result.event);
+    index = result.next;
+  }
+  return events;
+}
+
+// src/tui/input/mouse.ts
+var MOUSE_ON = "\x1B[?1000h\x1B[?1002h\x1B[?1006h";
+var MOUSE_OFF = "\x1B[?1006l\x1B[?1002l\x1B[?1000l";
+var MOUSE_REPORT_SOURCE = "\\x1b\\[<(\\d+);(\\d+);(\\d+)([Mm])";
+var BUTTON_MASK = 3;
+var DRAG_BIT = 32;
+var SCROLL_BIT = 64;
+var SHIFT_BIT = 4;
+function mouseReportPattern() {
+  return new RegExp(MOUSE_REPORT_SOURCE, "g");
+}
+function toMouseEvent(match) {
+  const word = Number(match[1]);
+  const column = Number(match[2]);
+  const row = Number(match[3]);
+  const isRelease = match[4] === "m";
+  const kind = isRelease ? "up" : (word & SCROLL_BIT) !== 0 ? "scroll" : (word & DRAG_BIT) !== 0 ? "drag" : "down";
+  return {
+    kind,
+    button: word & BUTTON_MASK,
+    row,
+    column,
+    shift: (word & SHIFT_BIT) !== 0
+  };
+}
+function splitInput(chunk) {
+  const matches = [...chunk.matchAll(mouseReportPattern())];
+  const segmentStarts = [0, ...matches.map((match) => match.index + match[0].length)];
+  const keys = segmentStarts.map((start, position) => chunk.slice(start, matches[position]?.index)).join("");
+  return { keys, mouse: matches.map(toMouseEvent) };
+}
+
+// src/tui/notes/notes.ts
+import { writeFileSync } from "node:fs";
+function rangeOf(selection) {
+  const reversed = selection.anchorRow > selection.headRow || selection.anchorRow === selection.headRow && selection.anchorColumn > selection.headColumn;
+  if (!reversed) {
+    return {
+      startRow: selection.anchorRow,
+      endRow: selection.headRow,
+      pane: selection.pane,
+      startColumn: selection.anchorColumn,
+      endColumn: selection.headColumn + 1
+    };
+  }
+  return {
+    startRow: selection.headRow,
+    endRow: selection.anchorRow,
+    pane: selection.pane,
+    startColumn: selection.headColumn,
+    endColumn: selection.anchorColumn + 1
+  };
+}
+function noteFromSelection(model, selection, id, text) {
+  const trimmed = text.trim();
+  if (trimmed === "") {
+    return null;
+  }
+  const range = rangeOf(selection);
+  const startRow = model.rows[range.startRow];
+  const endRow = model.rows[range.endRow];
+  if (startRow === void 0 || endRow === void 0) {
+    return null;
+  }
+  const line = range.pane === "right" ? startRow.rightNumber : startRow.leftNumber;
+  const endLine = range.pane === "right" ? endRow.rightNumber : endRow.leftNumber;
+  const code = range.pane === "right" ? startRow.right : startRow.left;
+  return {
+    id,
+    rowIndex: range.startRow,
+    endRowIndex: range.endRow,
+    pane: range.pane,
+    startColumn: range.startColumn,
+    endColumn: range.endColumn,
+    line,
+    endLine,
+    code,
+    text: trimmed
+  };
+}
+function firstRowEndColumn(note) {
+  return note.endRowIndex > note.rowIndex ? note.code.length : note.endColumn;
+}
+function isWholeLine(note) {
+  return note.startColumn === 0 && firstRowEndColumn(note) >= note.code.length;
+}
+function withSpanSuffix(note) {
+  const selected = note.code.slice(note.startColumn, firstRowEndColumn(note));
+  return `${note.text} [re: "${selected}"]`;
+}
+function sortNotes(notes) {
+  return [...notes].sort(
+    (first, second) => first.rowIndex === second.rowIndex ? first.startColumn - second.startColumn : first.rowIndex - second.rowIndex
+  );
+}
+function toQuestions(notes) {
+  return sortNotes(notes).map((note) => ({
+    line: note.line,
+    code: note.code,
+    text: isWholeLine(note) ? note.text : withSpanSuffix(note)
+  }));
+}
+function writeResult(path, notes) {
+  try {
+    writeFileSync(path, JSON.stringify({ questions: toQuestions(notes) }, null, 2), "utf-8");
+  } catch {
+    return;
+  }
+}
+
+// src/tui/tui.ts
+var NOTE_PANE = "right";
+function geometryFor(state, model, height, width) {
+  return {
+    model,
+    layout: state.layout,
+    width,
+    height,
+    notes: state.notes,
+    mode: state.mode,
+    notePosition: state.notePosition,
+    selection: state.selection
+  };
+}
+function pageSize(state, height, width) {
+  return pageRowStep(geometryFor(state, state.model, height, width), state.scrollTop);
+}
+function visibleIndexForRow2(model, rowIndex) {
+  const visible = visibleRows(model);
+  const found = visible.findIndex((entry) => entry.kind === "row" && entry.index === rowIndex);
+  return found === -1 ? model.cursor : found;
+}
+function isChangedEntry(model, entry) {
+  return entry.kind === "row" && model.rows[entry.index].kind !== "context";
+}
+function walkFrom(from, length, direction) {
+  const count = direction === 1 ? length - from : from + 1;
+  return Array.from({ length: Math.max(0, count) }, (_, step) => from + step * direction);
+}
+function jumpToRun(model, direction) {
+  const visible = visibleRows(model);
+  if (visible.length === 0) {
+    return model;
+  }
+  const walk = walkFrom(model.cursor, visible.length, direction);
+  const current = visible[model.cursor];
+  const onRun = current !== void 0 && isChangedEntry(model, current);
+  const runEnd = walk.findIndex((index) => !isChangedEntry(model, visible[index]));
+  const rest = onRun ? runEnd === -1 ? [] : walk.slice(runEnd) : walk.slice(1);
+  const target = rest.find((index) => isChangedEntry(model, visible[index]));
+  return target === void 0 ? model : { ...model, cursor: target };
+}
+function toggleFoldAtCursor(model) {
+  const visible = visibleRows(model);
+  const entry = visible[model.cursor];
+  if (entry === void 0 || entry.kind !== "fold") {
+    return model;
+  }
+  return toggleFold(model, entry.foldIndex);
+}
+var WHEEL_UP_BUTTON = 0;
+var WHEEL_DOWN_BUTTON = 1;
+var WHEEL_ROWS = 3;
+function wheelStep(button) {
+  if (button === WHEEL_UP_BUTTON) {
+    return -WHEEL_ROWS;
+  }
+  return button === WHEEL_DOWN_BUTTON ? WHEEL_ROWS : 0;
+}
+function applyScroll(state, event, height, width) {
+  const step = wheelStep(event.button);
+  if (step === 0) {
+    return state;
+  }
+  const maxScroll = maxScrollTop(geometryFor(state, state.model, height, width));
+  const scrollTop = Math.min(maxScroll, Math.max(0, state.scrollTop + step));
+  return scrollTop === state.scrollTop ? state : { ...state, scrollTop };
+}
+function withScroll(state, model, height, width) {
+  const scrollTop = followScrollTop(geometryFor(state, model, height, width), state.scrollTop);
+  return { ...state, model, scrollTop };
+}
+function commitDraft(state) {
+  const cleared = { ...state, draft: "", selection: null, mode: "browse" };
+  if (state.selection === null) {
+    return cleared;
+  }
+  const note = noteFromSelection(state.model, state.selection, state.nextNoteId, state.draft);
+  if (note === null) {
+    return cleared;
+  }
+  return {
+    ...cleared,
+    notes: sortNotes([...state.notes, note]),
+    nextNoteId: state.nextNoteId + 1
+  };
+}
+function enterNoteMode(state) {
+  if (state.selection !== null) {
+    return { ...state, mode: "note", draft: "" };
+  }
+  const rowIndex = cursorRowIndex(state.model);
+  if (rowIndex === null) {
+    return state;
+  }
+  return {
+    ...state,
+    selection: wholeRowSelection(state.model, rowIndex, NOTE_PANE),
+    mode: "note",
+    draft: ""
+  };
+}
+function focusNextNote(state) {
+  if (state.notes.length === 0) {
+    return state;
+  }
+  const ids = state.notes.map((note2) => note2.id);
+  const currentIndex = state.focusedNote === null ? -1 : ids.indexOf(state.focusedNote);
+  const nextId = ids[(currentIndex + 1) % ids.length];
+  const note = state.notes.find((candidate) => candidate.id === nextId);
+  const model = { ...state.model, cursor: visibleIndexForRow2(state.model, note.rowIndex) };
+  return { ...state, focusedNote: nextId, model };
+}
+function deleteNote(state, id) {
+  const notes = state.notes.filter((note) => note.id !== id);
+  if (state.focusedNote !== id) {
+    return { ...state, notes };
+  }
+  if (notes.length === 0) {
+    return { ...state, notes, focusedNote: null };
+  }
+  const deletedIndex = state.notes.findIndex((note) => note.id === id);
+  const nextIndex = Math.min(deletedIndex, notes.length - 1);
+  return { ...state, notes, focusedNote: notes[nextIndex].id };
+}
+function deleteFocusedNote(state) {
+  return state.focusedNote === null ? state : deleteNote(state, state.focusedNote);
+}
+function applyConfirmKey(state, key) {
+  if (key.ctrl) {
+    return state;
+  }
+  if (key.name === "s") {
+    return { ...state, quit: "send" };
+  }
+  if (key.name === "d") {
+    return { ...state, quit: "clean" };
+  }
+  if (key.name === "escape") {
+    return { ...state, mode: "browse" };
+  }
+  return state;
+}
+function applyNoteKey(state, key) {
+  if (key.ctrl) {
+    if (key.name === "s") {
+      return { ...state, quit: "send" };
+    }
+    if (key.name === "q" || key.name === "c") {
+      return state.notes.length === 0 ? { ...state, quit: "clean" } : { ...state, mode: "confirm" };
+    }
+    return state;
+  }
+  if (key.name === "enter") {
+    return commitDraft(state);
+  }
+  if (key.name === "escape") {
+    return { ...state, draft: "", mode: "browse" };
+  }
+  if (key.name === "backspace") {
+    return { ...state, draft: state.draft.slice(0, -1) };
+  }
+  if (key.text !== "") {
+    return { ...state, draft: state.draft + key.text };
+  }
+  return state;
+}
+function applyKey(state, key, height, width) {
+  if (state.mode === "confirm") {
+    return applyConfirmKey(state, key);
+  }
+  if (state.mode === "help") {
+    if (!key.ctrl && key.name === "?") {
+      return { ...state, mode: "browse" };
+    }
+    if (key.ctrl && key.name === "s") {
+      return { ...state, quit: "send" };
+    }
+    if (key.ctrl && (key.name === "q" || key.name === "c")) {
+      return state.notes.length === 0 ? { ...state, quit: "clean" } : { ...state, mode: "confirm" };
+    }
+    return state;
+  }
+  if (state.mode === "note") {
+    return applyNoteKey(state, key);
+  }
+  if (key.ctrl) {
+    if (key.name === "d") {
+      return withScroll(
+        state,
+        moveCursor(state.model, pageSize(state, height, width)),
+        height,
+        width
+      );
+    }
+    if (key.name === "u") {
+      return withScroll(
+        state,
+        moveCursor(state.model, -pageSize(state, height, width)),
+        height,
+        width
+      );
+    }
+    if (key.name === "s") {
+      return { ...state, quit: "send" };
+    }
+    if (key.name === "q" || key.name === "c") {
+      return state.notes.length === 0 ? { ...state, quit: "clean" } : { ...state, mode: "confirm" };
+    }
+    return state;
+  }
+  if (key.name === "s") {
+    return { ...state, quit: "send" };
+  }
+  if (key.name === "q") {
+    return state.notes.length === 0 ? { ...state, quit: "clean" } : { ...state, mode: "confirm" };
+  }
+  if (key.name === "v") {
+    return startSelection(state);
+  }
+  if (key.name === "escape") {
+    return { ...state, selection: null, mode: "browse" };
+  }
+  if (state.mode === "select") {
+    if (key.name === "j" || key.name === "down") {
+      return moveSelectionHead(state, 1);
+    }
+    if (key.name === "k" || key.name === "up") {
+      return moveSelectionHead(state, -1);
+    }
+  }
+  if (key.name === "a") {
+    return enterNoteMode(state);
+  }
+  if (key.name === "tab") {
+    return focusNextNote(state);
+  }
+  if (key.name === "d") {
+    return deleteFocusedNote(state);
+  }
+  if (key.name === "j" || key.name === "down") {
+    return withScroll(state, moveCursor(state.model, 1), height, width);
+  }
+  if (key.name === "k" || key.name === "up") {
+    return withScroll(state, moveCursor(state.model, -1), height, width);
+  }
+  if (key.name === "n") {
+    return withScroll(state, jumpToRun(state.model, 1), height, width);
+  }
+  if (key.name === "N") {
+    return withScroll(state, jumpToRun(state.model, -1), height, width);
+  }
+  if (key.name === " ") {
+    return withScroll(state, toggleFoldAtCursor(state.model), height, width);
+  }
+  if (key.name === "u") {
+    return { ...state, layout: state.layout === "split" ? "unified" : "split" };
+  }
+  if (key.name === "?") {
+    return { ...state, mode: "help" };
+  }
+  return state;
+}
+function frameDiff(previous, next) {
+  return next.map((line, index) => line === previous[index] ? "" : `\x1B[${index + 1};1H${line}`).join("");
+}
+var ENTER_ALT_SCREEN = "\x1B[?1049h";
+var LEAVE_ALT_SCREEN = "\x1B[?1049l";
+var HIDE_CURSOR = "\x1B[?25l";
+var SHOW_CURSOR = "\x1B[?25h";
+function runTui(options, io, abort) {
+  return new Promise((resolve, reject) => {
+    const model = buildModel(options.before, options.after, options.context, options.minFold);
+    let state = {
+      model,
+      mode: "browse",
+      scrollTop: 0,
+      map: { rows: [], panes: [] },
+      layout: options.layout,
+      quit: "none",
+      selection: null,
+      notes: [],
+      focusedNote: null,
+      draft: "",
+      nextNoteId: 1,
+      notePosition: options.notePosition
+    };
+    let previousLines = [];
+    let finished = false;
+    const repaint = () => {
+      const { width, height } = io.size();
+      const result = paint({
+        model: state.model,
+        width,
+        height,
+        path: options.path,
+        tokens: options.tokens,
+        truecolor: options.truecolor,
+        rowBand: options.rowBand,
+        scrollTop: state.scrollTop,
+        layout: state.layout,
+        selection: state.selection,
+        mode: state.mode,
+        draft: state.draft,
+        notes: state.notes,
+        focusedNote: state.focusedNote,
+        notePosition: state.notePosition
+      });
+      state = { ...state, map: result.map };
+      io.write(frameDiff(previousLines, result.lines));
+      previousLines = result.lines;
+    };
+    const attemptTeardown = () => {
+      let teardownError = null;
+      try {
+        io.write(SHOW_CURSOR);
+        io.write(MOUSE_OFF);
+        io.write(LEAVE_ALT_SCREEN);
+      } catch (writeError) {
+        teardownError = writeError instanceof Error ? writeError : new Error(String(writeError));
+      }
+      try {
+        io.cleanup();
+      } catch (cleanupError) {
+        teardownError = teardownError ?? (cleanupError instanceof Error ? cleanupError : new Error(String(cleanupError)));
+      }
+      return teardownError;
+    };
+    const finishQuit = (quit) => {
+      finished = true;
+      if (quit === "send") {
+        writeResult(options.resultFile, state.notes);
+      }
+      const teardownError = attemptTeardown();
+      if (teardownError !== null) {
+        reject(teardownError);
+        return;
+      }
+      const questions = quit === "send" ? toQuestions(state.notes) : [];
+      resolve({ quit, questions });
+    };
+    const finishError = (error) => {
+      if (finished) {
+        return;
+      }
+      finished = true;
+      attemptTeardown();
+      reject(error instanceof Error ? error : new Error(String(error)));
+    };
+    abort?.addEventListener(
+      "abort",
+      () => {
+        if (!finished) {
+          finishQuit("clean");
+        }
+      },
+      { once: true }
+    );
+    try {
+      io.write(ENTER_ALT_SCREEN);
+      io.write(MOUSE_ON);
+      io.write(HIDE_CURSOR);
+      repaint();
+    } catch (error) {
+      finishError(error);
+      return;
+    }
+    io.onResize?.(() => {
+      if (finished) {
+        return;
+      }
+      try {
+        previousLines = [];
+        repaint();
+      } catch (error) {
+        finishError(error);
+      }
+    });
+    io.onKey((chunk) => {
+      if (finished) {
+        return;
+      }
+      try {
+        const { keys, mouse } = splitInput(chunk);
+        state = mouse.reduce(
+          (current, event) => event.kind === "scroll" && !event.shift ? applyScroll(current, event, io.size().height, io.size().width) : applyMouse(current, event),
+          state
+        );
+        const events = parseKeys(keys);
+        state = events.reduce(
+          (current, event) => applyKey(current, event, io.size().height, io.size().width),
+          state
+        );
+        repaint();
+        if (state.quit !== "none") {
+          finishQuit(state.quit);
+        }
+      } catch (error) {
+        finishError(error);
+      }
+    });
+  });
+}
+
+// src/tui/index.ts
+var DEFAULT_WIDTH = 80;
+var DEFAULT_HEIGHT = 24;
+function createStdioIo() {
+  const wasRaw = process.stdin.isRaw === true;
+  process.stdin.setEncoding("utf8");
+  if (process.stdin.isTTY) {
+    process.stdin.setRawMode(true);
+  }
+  process.stdin.resume();
+  return {
+    onKey(handler) {
+      process.stdin.on("data", (chunk) => {
+        handler(typeof chunk === "string" ? chunk : chunk.toString("utf8"));
+      });
+    },
+    onResize(handler) {
+      process.stdout.on("resize", handler);
+    },
+    write(text) {
+      process.stdout.write(text);
+    },
+    size() {
+      return {
+        width: process.stdout.columns ?? DEFAULT_WIDTH,
+        height: process.stdout.rows ?? DEFAULT_HEIGHT
+      };
+    },
+    cleanup() {
+      if (process.stdin.isTTY) {
+        process.stdin.setRawMode(wasRaw);
+      }
+      process.stdin.pause();
+    }
+  };
+}
+
+// src/tui/cli.ts
+var DEFAULT_TERMINAL_WIDTH = 80;
+var DEFAULT_TERMINAL_HEIGHT = 24;
+var DEFAULT_LAYOUT = "split";
+var DEFAULT_NOTE_POSITION = "panel";
+var UNIFIED_LAYOUT_FLAG = "unified";
+var ANCHORED_NOTES_FLAG = "anchored";
+var TRUE_FLAG_VALUE = "true";
+var FALSE_FLAG_VALUE = "false";
+function readLinesOf(path) {
+  if (path === void 0) {
+    return [];
+  }
+  try {
+    return splitLines(readFileSync(path, "utf-8"));
+  } catch {
+    return [];
+  }
+}
+function parseArgs(argv) {
+  const args = {};
+  argv.forEach((entry, index) => {
+    if (!entry.startsWith("--")) {
+      return;
+    }
+    const value = argv[index + 1];
+    if (value === void 0 || value.startsWith("--")) {
+      return;
+    }
+    args[entry.slice(2)] = value;
+  });
+  return args;
+}
+function toLayout(value) {
+  return value === UNIFIED_LAYOUT_FLAG ? "unified" : DEFAULT_LAYOUT;
+}
+function toNotePosition(value) {
+  return value === ANCHORED_NOTES_FLAG ? "anchored" : DEFAULT_NOTE_POSITION;
+}
+function toBoolean(value, fallback) {
+  if (value === TRUE_FLAG_VALUE) {
+    return true;
+  }
+  if (value === FALSE_FLAG_VALUE) {
+    return false;
+  }
+  return fallback;
+}
+function toPositiveInteger(value, fallback) {
+  if (value === void 0) {
+    return fallback;
+  }
+  const parsed = Number(value);
+  if (!Number.isInteger(parsed) || parsed <= 0) {
+    return fallback;
+  }
+  return parsed;
+}
+function readTerminalSize(stdout) {
+  return {
+    width: stdout.columns ?? DEFAULT_TERMINAL_WIDTH,
+    height: stdout.rows ?? DEFAULT_TERMINAL_HEIGHT
+  };
+}
+async function run() {
+  const args = parseArgs(process.argv.slice(2));
+  const before = readLinesOf(args["left"]);
+  const after = readLinesOf(args["right"]);
+  const path = args["path"] ?? "";
+  const layout = toLayout(args["layout"]);
+  const notePosition = toNotePosition(args["notes"]);
+  const rowBand = toBoolean(args["row-band"], true);
+  const syntaxEnabled = toBoolean(args["syntax"], true);
+  const context = toPositiveInteger(args["context"], DEFAULT_CONTEXT);
+  const minFold = toPositiveInteger(args["min-fold"], DEFAULT_MIN_FOLD);
+  const resultFile = args["result"] ?? resultFilePath();
+  const truecolor = supportsTruecolor(process.env);
+  const { width, height } = readTerminalSize(process.stdout);
+  const tokens = await createTokenProvider({ path, enabled: syntaxEnabled, truecolor });
+  const options = {
+    before,
+    after,
+    path,
+    context,
+    minFold,
+    layout,
+    notePosition,
+    rowBand,
+    width,
+    height,
+    truecolor,
+    resultFile,
+    tokens
+  };
+  await runTui(options, createStdioIo());
+  return 0;
+}
+async function main() {
+  try {
+    return await run();
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    process.stderr.write(`pair-mode tui: ${message}
+`);
+    return 1;
+  }
+}
+if (isEntryPoint(import.meta.url)) {
+  const code = await main();
+  process.exit(code);
+}
+export {
+  toPositiveInteger
+};