bunmicro 0.9.1 → 0.9.9

package/CHANGELOG.md

@@ -1,5 +1,18 @@
 # Changelog
 
+## [0.9.9] - 2026-06-04
+- Added long line protection for softwrap
+  * That means binary edits available
+  * you can now open libc.so.6
+  * Ctrl+E reopen hex3 to edit & save
+- Fixed softwrap search match cross line
+
+## [0.9.5] - 2026-06-03
+- Added encoding hex3 for binary edit
+- term better supports fish
+- enter to close term
+- bat-like highlighting supports URL
+
 ## [0.9.1] - 2026-06-03
 - Upgrade method explanation
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bunmicro",
-  "version": "0.9.1",
+  "version": "0.9.9",
   "description": "Bun JavaScript rewrite of the micro editor originally in Golang",
   "type": "module",
   "main": "./src/index.js",

package/src/buffer/fixed3-codec.js

@@ -0,0 +1,140 @@
+const HEX = Array.from({ length: 256 }, (_, i) =>
+  i.toString(16).padStart(2, "0"),
+);
+const ENCODE_TABLE = new Uint8Array(256 * 3);
+const DECODE_HEX = new Int16Array(128);
+
+DECODE_HEX.fill(-1);
+
+for (let i = 0; i < 10; i++) {
+  DECODE_HEX[0x30 + i] = i;
+}
+for (let i = 0; i < 6; i++) {
+  DECODE_HEX[0x41 + i] = 10 + i;
+  DECODE_HEX[0x61 + i] = 10 + i;
+}
+
+for (let byte = 0; byte < 256; byte++) {
+  const offset = byte * 3;
+
+  if (byte >= 0x20 && byte <= 0x7e) {
+    ENCODE_TABLE[offset] = byte;
+    ENCODE_TABLE[offset + 1] = 0x2e;
+    ENCODE_TABLE[offset + 2] = 0x2e;
+  } else {
+    ENCODE_TABLE[offset] = 0x5c;
+    ENCODE_TABLE[offset + 1] = HEX[byte].charCodeAt(0);
+    ENCODE_TABLE[offset + 2] = HEX[byte].charCodeAt(1);
+  }
+}
+
+export class Fixed3DecodeError extends SyntaxError {
+  constructor(message, position) {
+    super(`${message} at text offset ${position}`);
+    this.name = "Fixed3DecodeError";
+    this.position = position;
+    this.byteOffset = Math.floor(position / 3);
+  }
+}
+
+export function encodeBinary(input) {
+  return encodeBinaryToBuffer(input).toString("latin1");
+}
+
+export function encodeBinaryToBuffer(input) {
+  const bytes = input instanceof Uint8Array ? input : Buffer.from(input);
+  const out = Buffer.allocUnsafe(bytes.byteLength * 3);
+  let j = 0;
+
+  for (let i = 0; i < bytes.byteLength; i++) {
+    const offset = bytes[i] * 3;
+    out[j++] = ENCODE_TABLE[offset];
+    out[j++] = ENCODE_TABLE[offset + 1];
+    out[j++] = ENCODE_TABLE[offset + 2];
+  }
+
+  return out;
+}
+
+export function decodeBinary(text) {
+  if (typeof text !== "string") {
+    throw new TypeError("decodeBinary() expects a string");
+  }
+
+  return decodeBinaryBytes(Buffer.from(text, "latin1"));
+}
+
+export function decodeBinaryBytes(input) {
+  const bytes = input instanceof Uint8Array ? input : Buffer.from(input);
+  const out = Buffer.allocUnsafe(Math.floor(bytes.byteLength / 3));
+  let j = 0;
+
+  for (let i = 0; i < bytes.byteLength; i += 3) {
+    const a = bytes[i];
+    const b = bytes[i + 1];
+    const c = bytes[i + 2];
+
+    if (b === 0x2e && c === 0x2e) {
+      out[j++] = a;
+    } else {
+      out[j++] = (DECODE_HEX[b] << 4) | DECODE_HEX[c];
+    }
+  }
+
+  return out;
+}
+
+export function decodeBinaryStrict(text) {
+  if (typeof text !== "string") {
+    throw new TypeError("decodeBinary() expects a string");
+  }
+
+  if (text.length % 3 !== 0) {
+    throw new Fixed3DecodeError("input length is not a multiple of 3", text.length);
+  }
+
+  const out = Buffer.allocUnsafe(text.length / 3);
+  let j = 0;
+
+  for (let i = 0; i < text.length; i += 3) {
+    const a = text.charCodeAt(i);
+    const b = text.charCodeAt(i + 1);
+    const c = text.charCodeAt(i + 2);
+
+    if (b === 0x2e && c === 0x2e) {
+      if (a < 0x20 || a > 0x7e) {
+        throw new Fixed3DecodeError("printable cell has non-printable byte", i);
+      }
+      out[j++] = a;
+      continue;
+    }
+
+    if (a !== 0x5c) {
+      throw new Fixed3DecodeError("escaped cell must start with backslash", i);
+    }
+
+    const hi = b < 128 ? DECODE_HEX[b] : -1;
+    const lo = c < 128 ? DECODE_HEX[c] : -1;
+    if (hi < 0 || lo < 0) {
+      throw new Fixed3DecodeError("escaped cell must contain two hex digits", i);
+    }
+
+    const byte = (hi << 4) | lo;
+    if (byte >= 0x20 && byte <= 0x7e) {
+      throw new Fixed3DecodeError("printable byte must use c.. form", i);
+    }
+
+    out[j++] = byte;
+  }
+
+  return out;
+}
+
+export default {
+  encodeBinary,
+  encodeBinaryToBuffer,
+  decodeBinary,
+  decodeBinaryBytes,
+  decodeBinaryStrict,
+  Fixed3DecodeError,
+};

package/src/index.js

@@ -21,6 +21,7 @@ import { ClipboardManager } from "./platform/clipboard.js";
 import { platformId, run as runCommand, runSync, fetchHttp, fetchHttpBytes, detectHttpBackend } from "./platform/commands.js";
 import { shellSplit } from "./shell/shell.js";
 import { styleToAnsi } from "./display/ansi-style.js";
+import { encodeBinaryToBuffer, decodeBinaryBytes } from "./buffer/fixed3-codec.js";
 
 import pkg from "../package.json" with { type: "json" };
 
@@ -100,6 +101,8 @@ const DEFAULT_SETTINGS = {
 };
 
 const LONG_LINE_REHIGHLIGHT_LIMIT = 300;
+// Lines exceeding this are never highlighted interactively; stored as default and deferred to Esc.
+const LONG_LINE_INITIAL_HIGHLIGHT_LIMIT = 10_000;
 
 const promptHistory = new Map();
 let startupHighlightProgress = null;
@@ -134,18 +137,27 @@ function isHttpUrl(value) {
 }
 
 async function readTextFileWithEncoding(path, encoding = "utf-8") {
-  const decoder = new TextDecoder(normalizeEncodingLabel(encoding));
   const bytes = new Uint8Array(await Bun.file(path).arrayBuffer());
+  if (normalizeEncodingLabel(encoding) === "hex3") {
+    return { text: encodeBinaryToBuffer(bytes).toString("latin1"), encoding: "hex3" };
+  }
+  const decoder = new TextDecoder(normalizeEncodingLabel(encoding));
   return { text: decoder.decode(bytes), encoding: decoder.encoding };
 }
 
 async function fetchTextWithEncoding(url, encoding = "utf-8") {
+  const bytes = await fetchHttpBytes(url);
+  if (normalizeEncodingLabel(encoding) === "hex3") {
+    return { text: encodeBinaryToBuffer(new Uint8Array(bytes)).toString("latin1"), encoding: "hex3" };
+  }
   const decoder = new TextDecoder(normalizeEncodingLabel(encoding));
-  return { text: decoder.decode(await fetchHttpBytes(url)), encoding: decoder.encoding };
+  return { text: decoder.decode(bytes), encoding: decoder.encoding };
 }
 
 function normalizeEncodingLabel(encoding = "utf-8") {
-  return new TextDecoder(String(encoding || "utf-8")).encoding;
+  const s = String(encoding || "utf-8");
+  if (s === "hex3") return "hex3";
+  return new TextDecoder(s).encoding;
 }
 
 function isReadonlyBuffer(buf) {
@@ -330,8 +342,11 @@ function normalizeCharBoundary(line, idx) {
 // breaks[0] === 0 always. breaks[k] is the start of visual row k within `line`.
 // Tabs are treated as `tabsize` columns wide (consistent with the renderer).
 // With wordwrap=true, breaks at word boundaries; with wordwrap=false, hard-wraps at bufWidth.
+let _swCacheLine = null, _swCacheBufWidth = 0, _swCacheWordwrap = false, _swCacheTabsize = 4, _swCacheBreaks = null;
 function softwrapBreaks(line, bufWidth, wordwrap, tabsize) {
   if (bufWidth <= 0) return [0];
+  if (line === _swCacheLine && bufWidth === _swCacheBufWidth && wordwrap === _swCacheWordwrap && tabsize === _swCacheTabsize)
+    return _swCacheBreaks;
   const breaks = [0];
   let visualX = 0;    // display col within current visual row
   let wordStart = 0;  // code-unit index of current word start
@@ -371,6 +386,7 @@ function softwrapBreaks(line, bufWidth, wordwrap, tabsize) {
     }
   }
 
+  _swCacheLine = line; _swCacheBufWidth = bufWidth; _swCacheWordwrap = wordwrap; _swCacheTabsize = tabsize; _swCacheBreaks = breaks;
   return breaks;
 }
 
@@ -559,6 +575,9 @@ function parseInput(args) {
 }
 
 class BufferModel {
+  get searchPattern() { return this._searchPattern ?? ""; }
+  set searchPattern(v) { this._searchPattern = v ?? ""; this.searchMatches?.clear(); }
+
   constructor({ path = "", text = "", command = {}, type = "default", readonly = false, modTimeMs = null, encoding = DEFAULT_SETTINGS.encoding } = {}) {
     this.path = path;
     this.type = type;
@@ -579,6 +598,7 @@ class BufferModel {
     this.acSuggestions = [];
     this.acCompletions = [];
     this.acCurIdx = -1;
+    this.searchMatches = new Map();
     this.searchPattern = "";
     this.command = command;
     this.filetype = "unknown";
@@ -650,6 +670,8 @@ class BufferModel {
 
   invalidateHighlightFrom(lineNo = 0, options = {}) {
     this._editRev = (this._editRev ?? 0) + 1;
+    if (options.force) this.searchMatches?.clear();
+    else this.searchMatches?.delete(lineNo);
     invalidateHighlightFrom(this, lineNo, options);
   }
 
@@ -1043,6 +1065,21 @@ class BufferModel {
   async save(path = this.path) {
     if (!path) throw new Error("No filename");
     let text = this.lines.join("\n");
+    if (this.encoding === "hex3") {
+      await Bun.write(path, decodeBinaryBytes(Buffer.from(text, "latin1")));
+      this.path = path;
+      this.Path = path;
+      this.AbsPath = path;
+      this.name = basename(path);
+      this.updateModTime();
+      this.readonly = !canWritePath(path);
+      this.Settings.readonly = this.readonly;
+      this.Type.Readonly = this.readonly;
+      this._savedSerial = this._undoSerial ?? 0;
+      this.modified = false;
+      this.message = `Saved ${path}`;
+      return;
+    }
     if (DEFAULT_SETTINGS.eofnewline && !text.endsWith("\n")) text += "\n";
     await Bun.write(path, text);
     this.encoding = "utf-8";
@@ -1324,6 +1361,7 @@ class TerminalPane {
     this.proc = null;
     this.vt = null;
     this.decoder = new TextDecoder();
+    this.exited = false;
   }
 
   open(cols, rows) {
@@ -1335,6 +1373,7 @@ class TerminalPane {
     cols = Math.max(10, cols ?? this.app.cols);
     rows = Math.max(4, rows ?? Math.floor(this.app.rows / 2));
     this.vt = new VT100(cols, rows);
+    this.exited = false;
     this.proc = Bun.spawn([shell], {
       env: { ...process.env, TERM: "xterm-256color", COLUMNS: String(cols), LINES: String(rows) },
       terminal: {
@@ -1348,7 +1387,8 @@ class TerminalPane {
           this.app.render();
         },
         exit: () => {
-          this.vt.feed("\r\n[process exited]\r\n");
+          this.exited = true;
+          this.vt.feed("\r\n[process exited]\r\nPress enter to close\r\n");
           this.app.render();
         },
       },
@@ -1356,9 +1396,14 @@ class TerminalPane {
   }
 
   write(data) {
+    if (this.exited) return;
     this.proc?.terminal?.write(data);
   }
 
+  writeInput(data) {
+    this.write(encodeTerminalInput(data, this.vt));
+  }
+
   resize(cols, rows) {
     rows = Math.max(4, rows);
     this.vt?.resize(cols, rows);
@@ -1367,13 +1412,102 @@ class TerminalPane {
 
   close() {
     try {
-      this.proc?.kill();
+      if (!this.exited) this.proc?.kill();
       this.proc?.terminal?.close();
     } catch {
       // PTY may already be closed.
     }
     this.proc = null;
+    this.exited = true;
+  }
+}
+
+function encodeTerminalInput(data, vt) {
+  if (!vt) return data;
+  const flags = vt.keyboardProtocolFlags ?? 0;
+  const wantsKitty = flags !== 0;
+  const wantsXterm = (vt.modifyOtherKeys ?? 0) > 0 || (vt.formatOtherKeys ?? 0) > 0;
+  if (!wantsKitty && !wantsXterm) return data;
+
+  const text = data instanceof Uint8Array ? decoder.decode(data) : String(data);
+  const events = parseInputEvents(text);
+  if (events.length === 0 || events.some(e => e.type !== "key")) return data;
+
+  const encoded = [];
+  for (const event of events) {
+    const seq = encodeKeyEventForTerminal(event, flags, wantsXterm);
+    if (!seq) return data;
+    encoded.push(seq);
+  }
+  return encoded.join("");
+}
+
+function encodeKeyEventForTerminal(event, flags, wantsXterm) {
+  const key = event.key;
+  const raw = event.raw ?? "";
+  const reportAll = (flags & 8) !== 0;
+  const disambiguate = (flags & 1) !== 0 || reportAll || wantsXterm;
+
+  if (!reportAll && isPlainTextKey(raw, key)) return raw;
+  const parsed = keyToKittyCode(key, raw);
+  if (!parsed) return raw;
+  const { code, modifiers } = parsed;
+  if (!reportAll && !disambiguate && modifiers <= 1) return raw;
+  if (!reportAll && modifiers <= 1 && !needsDisambiguation(key)) return raw;
+  return `\x1b[${code};${modifiers}u`;
+}
+
+function isPlainTextKey(raw, key) {
+  return raw && raw === key && !raw.includes("\x1b") && !/^(?:ctrl|alt|shift)-/.test(key) && !KEY_CODEPOINTS[key];
+}
+
+function needsDisambiguation(key) {
+  return key === "escape" || key.startsWith("ctrl-") || key.startsWith("alt-") || key.includes("shift-");
+}
+
+const NAMED_KEY_CODEPOINTS = {
+  escape: 27,
+  enter: 13,
+  tab: 9,
+  backspace: 127,
+  delete: 57362,
+  insert: 57363,
+  left: 57364,
+  right: 57365,
+  up: 57366,
+  down: 57367,
+  pageup: 57368,
+  pagedown: 57369,
+  home: 57370,
+  end: 57371,
+};
+
+const KEY_CODEPOINTS = NAMED_KEY_CODEPOINTS;
+
+function keyToKittyCode(key, raw) {
+  let rest = key;
+  let mods = 1;
+  let changed = true;
+  while (changed) {
+    changed = false;
+    for (const [prefix, bit] of [["shift-", 1], ["alt-", 2], ["ctrl-", 4]]) {
+      if (rest.startsWith(prefix)) {
+        mods += bit;
+        rest = rest.slice(prefix.length);
+        changed = true;
+      }
+    }
+  }
+
+  if (rest === "space") return { code: 32, modifiers: mods };
+  if (KEY_CODEPOINTS[rest]) return { code: KEY_CODEPOINTS[rest], modifiers: mods };
+  if (rest.length === 1) return { code: rest.toLowerCase().codePointAt(0), modifiers: mods };
+
+  if (raw.length === 1 && raw >= " " && raw !== "\x7f") return { code: raw.toLowerCase().codePointAt(0), modifiers: mods };
+  if (raw.length === 1 && raw.charCodeAt(0) >= 1 && raw.charCodeAt(0) <= 26) {
+    return { code: raw.charCodeAt(0) + 96, modifiers: mods | 4 };
   }
+  return null;
 }
 
 // ─── Pane / split layout ────────────────────────────────────────────────────
@@ -1944,12 +2078,14 @@ class App {
         const isCL = clBg && lineNo === buf.cursor.y && !pane.selection;
         if (gutterW > 0) renderGutter(lineNo, row, screenRow);
         if (lineNo < buf.lines.length) {
-          const cells = renderHighlightedCells(buf, lineNo, buf.scroll.x, maxW, this.context.colorscheme, pane.selection, buf.searchPattern, braceMatches, isCL ? clBg : null);
+          const cells = renderHighlightedCells(buf, lineNo, buf.scroll.x, maxW, this.context.colorscheme, pane.selection, getLineSearchRanges(buf, lineNo), braceMatches, isCL ? clBg : null);
           putCells(this.screen, pane.x + gutterW, screenRow, cells, maxW);
         }
       }
     } else {
       let sloc = { line: buf.scroll.y, row: buf.scroll.row ?? 0 };
+      let _swBreaksLineNo = -1, _swBreaks = null;
+      let _swSearchLineNo = -1, _swSearchRanges = [];
       for (let screenY = 0; screenY < pane.h; screenY++) {
         const screenRow = pane.y + screenY;
         const { line: lineNo, row: subRow } = sloc;
@@ -1957,13 +2093,15 @@ class App {
         if (lineNo >= buf.lines.length) break;
 
         const lineStr = buf.lines[lineNo] ?? "";
-        const breaks = softwrapBreaks(lineStr, maxW, wordwrap, tabsize);
+        if (lineNo !== _swBreaksLineNo) { _swBreaks = softwrapBreaks(lineStr, maxW, wordwrap, tabsize); _swBreaksLineNo = lineNo; }
+        if (lineNo !== _swSearchLineNo) { _swSearchRanges = getLineSearchRanges(buf, lineNo); _swSearchLineNo = lineNo; }
+        const breaks = _swBreaks;
         const segStart = breaks[subRow] ?? 0;
         const isCL = clBg && lineNo === buf.cursor.y && !pane.selection;
 
         if (gutterW > 0) renderGutter(lineNo, screenY, screenRow, subRow);
 
-        const cells = renderHighlightedCells(buf, lineNo, segStart, maxW, this.context.colorscheme, pane.selection, buf.searchPattern, braceMatches, isCL ? clBg : null);
+        const cells = renderHighlightedCells(buf, lineNo, segStart, maxW, this.context.colorscheme, pane.selection, _swSearchRanges, braceMatches, isCL ? clBg : null);
         putCells(this.screen, pane.x + gutterW, screenRow, cells, maxW);
 
         if (subRow + 1 < breaks.length) {
@@ -2325,17 +2463,15 @@ class App {
         return;
       }
 
-      // Escape alone: restore previous buffer if available, otherwise close pane
-      if (text === "\x1b") {
-        activePaneObj.terminal?.close();
-        activePaneObj.terminal = null;
-        if (activePaneObj.prevBuffer) {
-          activePaneObj.type = "editor";
-          activePaneObj.buffer = activePaneObj.prevBuffer;
-          activePaneObj.prevBuffer = null;
-        } else {
-          this.closePane(activePaneObj);
-        }
+      if (activePaneObj.terminal.exited && events.some((event) => event.type === "key" && event.key === "enter")) {
+        this.closeTermPane(activePaneObj);
+        this.render();
+        return;
+      }
+
+      // Escape alone: close pane in legacy mode; protocol-aware shells need it as input.
+      if (text === "\x1b" && !(activePaneObj.terminal?.vt?.keyboardProtocolFlags || activePaneObj.terminal?.vt?.modifyOtherKeys)) {
+        this.closeTermPane(activePaneObj);
         this.render();
         return;
       }
@@ -2352,7 +2488,7 @@ class App {
 
       // Any other key input: reset scroll to live view, then forward
       if (activePaneObj.terminal?.vt) activePaneObj.terminal.vt.scrollOffset = 0;
-      activePaneObj.terminal.write(data);
+      activePaneObj.terminal.writeInput(data);
       return;
     }
 
@@ -3384,7 +3520,8 @@ class App {
   async save({ force = false } = {}) {
     if (!force && this.buffer?.readonly) { this.message = "Can't save under readonly mode"; return; }
     try {
-      if (normalizeEncodingLabel(this.buffer?.encoding) !== "utf-8") {
+      const enc = normalizeEncodingLabel(this.buffer?.encoding);
+      if (enc !== "utf-8" && enc !== "hex3") {
         this.openYNPrompt("Save in UTF-8?(y,n)", async (answer) => {
           if (answer === "y") await this.saveUtf8();
         });
@@ -3536,6 +3673,18 @@ class App {
     this.message = "No previous diff";
   }
 
+  closeTermPane(pane) {
+    pane.terminal?.close();
+    pane.terminal = null;
+    if (pane.prevBuffer) {
+      pane.type = "editor";
+      pane.buffer = pane.prevBuffer;
+      pane.prevBuffer = null;
+    } else {
+      this.closePane(pane);
+    }
+  }
+
   closePane(pane) {
     pane.terminal?.close();
     const tab = this.tab;
@@ -3774,7 +3923,7 @@ class App {
         const saveArgs = [...cmdArgs];
         const saveForce = saveArgs[0] === "-f" && (saveArgs.shift(), true);
         if (!saveForce && buf?.readonly) { this.message = "Can't save under readonly mode"; break; }
-        if (saveArgs.length > 0 && normalizeEncodingLabel(buf?.encoding) !== "utf-8") {
+        if (saveArgs.length > 0 && normalizeEncodingLabel(buf?.encoding) !== "utf-8" && normalizeEncodingLabel(buf?.encoding) !== "hex3") {
           const target = resolve(expandHome(saveArgs[0]));
           this.openYNPrompt("Save in UTF-8?(y,n)", async (answer) => {
             if (answer === "y") {
@@ -4546,12 +4695,14 @@ const COMMAND_NAMES = [
 ];
 
 const SUPPORTED_ENCODING_LABELS = [
+  "hex3",
   "utf-8", "utf-16le", "utf-16be",
   "windows-1252", "iso-8859-1", "latin1",
   "big5", "gbk", "gb18030",
   "shift_jis", "sjis", "euc-jp", "iso-2022-jp",
   "euc-kr", "ks_c_5601-1987",
 ].filter((encoding) => {
+  if (encoding === "hex3") return true;
   try { new TextDecoder(encoding); return true; }
   catch { return false; }
 });
@@ -4860,6 +5011,15 @@ function highlightBufferLine(buf, lineNo) {
     if (!cache.forceLongLineRehighlight && cache.dirtyLongLines.has(y) && cache.results[y]) {
       result = cache.results[y];
       state = cache.states[y] ?? null;
+    } else if (!cache.forceLongLineRehighlight && line.length > LONG_LINE_INITIAL_HIGHLIGHT_LIMIT) {
+      // Too long to highlight interactively — store a default result and mark dirty for Esc rehighlight.
+      if (!cache.results[y]) {
+        cache.results[y] = { changes: new Map([[0, "default"], [line.length, "default"]]), state: null };
+        cache.states[y] = null;
+      }
+      result = cache.results[y];
+      state = null;
+      cache.dirtyLongLines.add(y);
     } else {
       const progress = startupHighlightProgress
         ? (pos) => startupHighlightProgress.linePosition(pos, y, target)
@@ -4896,6 +5056,11 @@ function invalidateHighlightFrom(buf, lineNo = 0, { force = false } = {}) {
   if (!cache) return;
   const from = Math.max(0, Math.trunc(Number(lineNo) || 0));
   const line = buf.lines[from] ?? "";
+  // Hard limit: never clear cache for very long lines even on force — mark dirty instead.
+  if (line.length > LONG_LINE_INITIAL_HIGHLIGHT_LIMIT && cache.results[from]) {
+    cache.dirtyLongLines.add(from);
+    return;
+  }
   if (!force && line.length > LONG_LINE_REHIGHLIGHT_LIMIT && cache.results[from]) {
     cache.dirtyLongLines.add(from);
     return;
@@ -5317,6 +5482,7 @@ function findMatchingBracePositions(buf) {
 
 function findMatchingBracePair(buf) {
   if (!(buf?.Settings?.matchbrace ?? DEFAULT_SETTINGS.matchbrace)) return null;
+  if ((buf.lines[buf.cursor.y] ?? "").length > LONG_LINE_INITIAL_HIGHLIGHT_LIMIT) return null;
   const left = braceAt(buf, buf.cursor.x - 1, buf.cursor.y);
   const right = braceAt(buf, buf.cursor.x, buf.cursor.y);
   let origin = null;
@@ -5374,7 +5540,7 @@ function braceKey(loc) {
   return String(loc.y) + ":" + String(loc.x);
 }
 
-function renderHighlightedCells(buf, lineNo, scrollX, maxWidth, colorscheme, selection = null, searchPattern = "", braceMatches = null, cursorLineBg = null) {
+function renderHighlightedCells(buf, lineNo, scrollX, maxWidth, colorscheme, selection = null, searchRanges = [], braceMatches = null, cursorLineBg = null) {
   const raw = buf.lines[lineNo] ?? "";
   const cells = [];
   let width = 0;
@@ -5385,8 +5551,6 @@ function renderHighlightedCells(buf, lineNo, scrollX, maxWidth, colorscheme, sel
     if (changes.length === 0 || changes[0][0] !== 0) changes.unshift([0, "default"]);
     changes.push([raw.length, changes.at(-1)?.[1] ?? "default"]);
   }
-
-  const searchRanges = searchPattern ? getSearchRanges(raw, searchPattern, buf.Settings?.ignorecase ?? true) : [];
   // Go: cursor-line bg is skipped when a syntax style already has a non-default background (preservebg)
   const defBg = colorscheme?.defaultStyle?.bg ?? "default";
 
@@ -5402,6 +5566,7 @@ function renderHighlightedCells(buf, lineNo, scrollX, maxWidth, colorscheme, sel
     : null;
 
   let changeIndex = 0;
+  let searchIdx = 0;
   let i = scrollX;
   while (i < raw.length && width < maxWidth) {
     const cp = raw.codePointAt(i);
@@ -5415,7 +5580,8 @@ function renderHighlightedCells(buf, lineNo, scrollX, maxWidth, colorscheme, sel
     const syntaxStyle = colorscheme?.get(group) ?? colorscheme?.defaultStyle ?? {};
     const preservebg = cursorLineBg != null && syntaxStyle.bg !== undefined && syntaxStyle.bg !== defBg;
     const baseStyle = (cursorLineBg && !preservebg) ? { ...syntaxStyle, bg: cursorLineBg } : syntaxStyle;
-    const inSearch = searchRanges.some(([from, to]) => i >= from && i < to);
+    while (searchIdx < searchRanges.length && searchRanges[searchIdx][1] <= i) searchIdx++;
+    const inSearch = searchIdx < searchRanges.length && i >= searchRanges[searchIdx][0] && i < searchRanges[searchIdx][1];
     const selected = isSelected(selection, lineNo, i, i + charLen);
     const braceMatched = braceMatches?.has(String(lineNo) + ":" + String(i));
     let style = (showTrailingWs && i >= trailingWsIdx) ? trailingWsStyle : baseStyle;
@@ -5522,7 +5688,17 @@ function allMatchPositions(text, re, literal) {
   return positions;
 }
 
-function getSearchRanges(line, pattern, ignoreCase = false) {
+function getLineSearchRanges(buf, lineNo) {
+  if (!buf.searchPattern) return [];
+  if (!buf.searchMatches.has(lineNo)) {
+    const raw = buf.lines[lineNo] ?? "";
+    const ignoreCase = buf.Settings?.ignorecase ?? true;
+    buf.searchMatches.set(lineNo, getSearchRanges(raw, buf.searchPattern, ignoreCase));
+  }
+  return buf.searchMatches.get(lineNo);
+}
+
+function getSearchRanges(line, pattern, ignoreCase = false, rangeStart = 0, rangeEnd = line.length) {
   if (!pattern) return [];
   let re;
   try {
@@ -5532,16 +5708,18 @@ function getSearchRanges(line, pattern, ignoreCase = false) {
   }
   const ranges = [];
   if (re) {
+    re.lastIndex = rangeStart;
     let m;
     while ((m = re.exec(line)) !== null) {
+      if (m.index >= rangeEnd) break;
       if (m[0].length === 0) { re.lastIndex++; continue; }
       ranges.push([m.index, m.index + m[0].length]);
     }
   } else {
-    let idx = 0;
-    while (idx < line.length) {
+    let idx = rangeStart;
+    while (idx < rangeEnd) {
       const pos = line.indexOf(pattern, idx);
-      if (pos < 0) break;
+      if (pos < 0 || pos >= rangeEnd) break;
       ranges.push([pos, pos + pattern.length]);
       idx = pos + pattern.length;
     }
@@ -5562,7 +5740,10 @@ async function loadBuffers(files, command) {
   } else if (!process.stdin.isTTY) {
     const chunks = [];
     for await (const chunk of process.stdin) chunks.push(chunk);
-    buffers.push(new BufferModel({ text: Buffer.concat(chunks).toString("utf8"), type: process.stdout.isTTY ? "default" : "stdout", command }));
+    const stdinText = Buffer.concat(chunks).toString("utf8");
+    const stdinBuf = new BufferModel({ text: stdinText, type: process.stdout.isTTY ? "default" : "stdout", command });
+    if (loadBuffers.context) attachSyntax(stdinBuf, loadBuffers.context, "", stdinText);
+    buffers.push(stdinBuf);
   } else {
     buffers.push(new BufferModel({ command }));
   }
@@ -6032,8 +6213,18 @@ function syncEditorSettings(config) {
 async function catFiles(files, colorscheme, syntaxDefinitions) {
   const targets = files.length > 0 ? files.map((f) => ({ path: f, stdin: false })) : [{ path: null, stdin: true }];
   for (const { path: filePath, stdin } of targets) {
-    const content = stdin ? await Bun.stdin.text() : await Bun.file(filePath).text();
-    if (filePath && /\.md$/i.test(filePath)) {
+    let content;
+    let effectivePath = filePath;
+    if (stdin) {
+      content = await Bun.stdin.text();
+    } else if (isHttpUrl(filePath)) {
+      content = await fetchHttp(filePath);
+      // Use the URL pathname for syntax/md detection (strip query/hash)
+      try { effectivePath = new URL(filePath).pathname; } catch { effectivePath = filePath; }
+    } else {
+      content = await Bun.file(filePath).text();
+    }
+    if (effectivePath && /\.md$/i.test(effectivePath)) {
       process.stdout.write(
         Bun.markdown.ansi(content,{
           hyperlinks:true
@@ -6043,7 +6234,7 @@ async function catFiles(files, colorscheme, syntaxDefinitions) {
     }
     const lines = content.split("\n");
     const def = detectSyntax(syntaxDefinitions, {
-      path: filePath ?? "",
+      path: effectivePath ?? "",
       firstLine: lines[0] ?? "",
       lines: lines.slice(0, 50),
     });

package/src/screen/vt100.js

@@ -77,6 +77,7 @@ export class VT100 {
     this.cells = [];
     this.cx = 0;
     this.cy = 0;
+    this.wrapPending = false;
     this.savedCursor = { x: 0, y: 0 };
     this.scrollTop = 0;
     this.scrollBottom = this.rows - 1;
@@ -88,6 +89,10 @@ export class VT100 {
     this.scrollOffset = 0;      // 0 = live view; n = n rows scrolled back into history
     // mouse reporting: set by the application via ?1000h / ?1002h / ?1003h
     this.mouseMode = false;
+    this.keyboardProtocolFlags = 0;
+    this.keyboardProtocolStack = [];
+    this.modifyOtherKeys = 0;
+    this.formatOtherKeys = 0;
     this._initCells();
   }
 
@@ -205,6 +210,7 @@ export class VT100 {
   }
 
   _lineFeed() {
+    this.wrapPending = false;
     if (this.cy < this.scrollBottom) {
       this.cy++;
     } else {
@@ -212,6 +218,12 @@ export class VT100 {
     }
   }
 
+  _moveCursor(x, y) {
+    this.cx = Math.min(this.cols - 1, Math.max(0, x));
+    this.cy = Math.min(this.rows - 1, Math.max(0, y));
+    this.wrapPending = false;
+  }
+
   // Feed a chunk of terminal output. Returns array of response strings to send back.
   feed(text) {
     const data = this.pending + text;
@@ -248,17 +260,18 @@ export class VT100 {
         } else if (next === "7") {
           this.savedCursor = { x: this.cx, y: this.cy }; i += 2;
         } else if (next === "8") {
-          this.cx = this.savedCursor.x; this.cy = this.savedCursor.y; i += 2;
+          this._moveCursor(this.savedCursor.x, this.savedCursor.y); i += 2;
         } else if (next === "M") {
           // Reverse index
           if (this.cy === this.scrollTop) this._scrollDown(1);
-          else this.cy = Math.max(0, this.cy - 1);
+          else this._moveCursor(this.cx, this.cy - 1);
           i += 2;
         } else if (next === "(" || next === ")" || next === "*" || next === "+") {
           i += 3; // charset designation, skip designator
         } else if (next === "c") {
           // Full reset
           this._initCells(); this.cx = this.cy = 0;
+          this.wrapPending = false;
           this.sgr = { fg: "default", bg: "default", bold: false, italic: false, underline: false, reverse: false };
           this.scrollTop = 0; this.scrollBottom = this.rows - 1;
           i += 2;
@@ -271,13 +284,15 @@ export class VT100 {
         }
 
       } else if (ch === "\r") {
-        this.cx = 0; i++;
+        this.cx = 0; this.wrapPending = false; i++;
       } else if (ch === "\n" || ch === "\x0b" || ch === "\x0c") {
         this._lineFeed(); i++;
       } else if (ch === "\b") {
-        if (this.cx > 0) this.cx--; i++;
+        if (this.wrapPending) this.wrapPending = false;
+        else if (this.cx > 0) this.cx--;
+        i++;
       } else if (ch === "\t") {
-        this.cx = Math.min(this.cols - 1, (Math.floor(this.cx / 8) + 1) * 8); i++;
+        this.cx = Math.min(this.cols - 1, (Math.floor(this.cx / 8) + 1) * 8); this.wrapPending = false; i++;
       } else if (ch === "\x07") {
         i++; // Bell: ignore
       } else if (ch === "\x0e" || ch === "\x0f") {
@@ -287,10 +302,20 @@ export class VT100 {
         const cp = data.codePointAt(i);
         const rune = String.fromCodePoint(cp);
         const width = charWidth(rune);
+        if (width > 0 && this.wrapPending) {
+          this.cx = 0;
+          this._lineFeed();
+        }
         this._setCell(this.cx, this.cy, rune, width);
-        this.cx += width;
-        if (this.cx >= this.cols) {
-          this.cx = 0; this._lineFeed();
+        if (width > 0) {
+          const nextX = this.cx + width;
+          if (nextX >= this.cols) {
+            this.cx = this.cols - 1;
+            this.wrapPending = true;
+          } else {
+            this.cx = nextX;
+            this.wrapPending = false;
+          }
         }
         i += cp > 0xFFFF ? 2 : 1;
       } else {
@@ -302,6 +327,10 @@ export class VT100 {
   }
 
   _handleCSI(params, final) {
+    if (final === "u" && /^(?:[?<>]=?|=)/.test(params)) {
+      return this._handleKeyboardProtocol(params);
+    }
+
     // Check for private mode prefix
     const isPrivate = params.startsWith("?");
     const raw = isPrivate ? params.slice(1) : params;
@@ -310,17 +339,15 @@ export class VT100 {
     const p2 = parts[1] ?? 0;
 
     switch (final) {
-      case "A": this.cy = Math.max(this.scrollTop, this.cy - Math.max(1, p1)); break;
-      case "B": this.cy = Math.min(this.scrollBottom, this.cy + Math.max(1, p1)); break;
-      case "C": this.cx = Math.min(this.cols - 1, this.cx + Math.max(1, p1)); break;
-      case "D": this.cx = Math.max(0, this.cx - Math.max(1, p1)); break;
-      case "E": this.cy = Math.min(this.rows - 1, this.cy + Math.max(1, p1)); this.cx = 0; break;
-      case "F": this.cy = Math.max(0, this.cy - Math.max(1, p1)); this.cx = 0; break;
-      case "G": this.cx = Math.min(this.cols - 1, Math.max(0, Math.max(1, p1) - 1)); break;
+      case "A": this._moveCursor(this.cx, Math.max(this.scrollTop, this.cy - Math.max(1, p1))); break;
+      case "B": this._moveCursor(this.cx, Math.min(this.scrollBottom, this.cy + Math.max(1, p1))); break;
+      case "C": this._moveCursor(Math.min(this.cols - 1, this.cx + Math.max(1, p1)), this.cy); break;
+      case "D": this._moveCursor(Math.max(0, this.cx - Math.max(1, p1)), this.cy); break;
+      case "E": this._moveCursor(0, Math.min(this.rows - 1, this.cy + Math.max(1, p1))); break;
+      case "F": this._moveCursor(0, Math.max(0, this.cy - Math.max(1, p1))); break;
+      case "G": this._moveCursor(Math.min(this.cols - 1, Math.max(0, Math.max(1, p1) - 1)), this.cy); break;
       case "H":
-      case "f":
-        this.cy = Math.min(this.rows - 1, Math.max(0, Math.max(1, p1) - 1));
-        this.cx = Math.min(this.cols - 1, Math.max(0, Math.max(1, p2) - 1));
+        this._moveCursor(Math.max(0, Math.max(1, p2) - 1), Math.max(0, Math.max(1, p1) - 1));
         break;
       case "J":
         if (p1 === 0) {
@@ -365,8 +392,17 @@ export class VT100 {
         for (let x = this.cx; x < Math.min(this.cols, this.cx + n); x++) this._clearCell(x, this.cy);
         break;
       }
-      case "d": this.cy = Math.min(this.rows - 1, Math.max(0, Math.max(1, p1) - 1)); break;
-      case "m": this._handleSGR(parts); break;
+      case "d": this._moveCursor(this.cx, Math.min(this.rows - 1, Math.max(0, Math.max(1, p1) - 1))); break;
+      case "f":
+        if (params.startsWith(">")) this._handleXtermKeyFormat(raw);
+        else {
+          this._moveCursor(Math.max(0, Math.max(1, p2) - 1), Math.max(0, Math.max(1, p1) - 1));
+        }
+        break;
+      case "m":
+        if (params.startsWith(">")) this._handleXtermKeyModifier(raw);
+        else this._handleSGR(parts);
+        break;
       case "n":
         if (p1 === 6) return `\x1b[${this.cy + 1};${this.cx + 1}R`; // CPR
         if (p1 === 5) return "\x1b[0n"; // device status OK
@@ -377,7 +413,14 @@ export class VT100 {
         if (this.scrollTop >= this.scrollBottom) { this.scrollTop = 0; this.scrollBottom = this.rows - 1; }
         break;
       case "s": this.savedCursor = { x: this.cx, y: this.cy }; break;
-      case "u": this.cx = this.savedCursor.x; this.cy = this.savedCursor.y; break;
+      case "u":
+        if (params === "") {
+          this._moveCursor(this.savedCursor.x, this.savedCursor.y);
+        }
+        break;
+      case "c":
+        if (params === "" || p1 === 0) return "\x1b[?1;2c"; // primary device attributes
+        break;
       case "h":
         if (isPrivate) {
           for (const n of parts) {
@@ -396,6 +439,53 @@ export class VT100 {
     return null;
   }
 
+  _handleKeyboardProtocol(params) {
+    const parseNum = (value, fallback = 0) => {
+      const n = Number(String(value ?? "").split(":")[0]);
+      return Number.isFinite(n) ? n : fallback;
+    };
+
+    if (params === "?") return `\x1b[?${this.keyboardProtocolFlags}u`;
+    if (params.startsWith("=")) {
+      const parts = params.slice(1).split(";");
+      const flags = parseNum(parts[0], 0);
+      const mode = parseNum(parts[1], 1);
+      if (mode === 2) this.keyboardProtocolFlags |= flags;
+      else if (mode === 3) this.keyboardProtocolFlags &= ~flags;
+      else this.keyboardProtocolFlags = flags;
+      return null;
+    }
+    if (params.startsWith(">")) {
+      const flags = parseNum(params.slice(1), 0);
+      this.keyboardProtocolStack.push(this.keyboardProtocolFlags);
+      if (this.keyboardProtocolStack.length > 32) this.keyboardProtocolStack.shift();
+      this.keyboardProtocolFlags = flags;
+      return null;
+    }
+    if (params.startsWith("<")) {
+      const count = Math.max(1, parseNum(params.slice(1), 1));
+      for (let i = 0; i < count; i++) {
+        this.keyboardProtocolFlags = this.keyboardProtocolStack.length > 0 ? this.keyboardProtocolStack.pop() : 0;
+      }
+      return null;
+    }
+    return null;
+  }
+
+  _handleXtermKeyFormat(raw) {
+    const parts = raw.slice(1).split(";").map(p => Number(p));
+    const id = parts[0];
+    const value = parts[1];
+    if (id === 4) this.formatOtherKeys = Number.isFinite(value) ? value : 0;
+  }
+
+  _handleXtermKeyModifier(raw) {
+    const parts = raw.slice(1).split(";").map(p => Number(p));
+    const id = parts[0];
+    const value = parts[1];
+    if (id === 4) this.modifyOtherKeys = Number.isFinite(value) ? value : 0;
+  }
+
   _handleSGR(parts) {
     if (parts.length === 0 || (parts.length === 1 && parts[0] === 0)) {
       this.sgr = { fg: "default", bg: "default", bold: false, italic: false, underline: false, reverse: false };
@@ -459,6 +549,7 @@ export class VT100 {
     this.cells = newCells;
     this.cx = Math.min(this.cx, cols - 1);
     this.cy = Math.min(this.cy, rows - 1);
+    this.wrapPending = false;
     this.scrollTop = 0;
     this.scrollBottom = rows - 1;
   }

package/todo.txt

@@ -68,6 +68,12 @@ Current handoff notes
     - Lines over 300 chars keep their old cached highlight/state when dirtied, mark the row dirty, and defer full rehighlight until Esc.
     - Dirty long lines render red in the gutter and in the statusline row field.
     - Startup and Esc rehighlight show colorful bottom progress by highlighted character count, wrapped with Bun.wrapAnsi.
+[x] Recent 0.9.x updates:
+    - Added hex3 encoding for binary edit/open/save paths and encoding completion.
+    - --cat/--bat-style highlighting supports HTTP/HTTPS URLs.
+    - Terminal pane close behavior improved: exited terminals show "Press enter to close" and Enter closes/restores the pane.
+    - Added Alt-s selection mode plus more Alt key help/defaultkey documentation.
+    - Added Dedent/Unindent action aliases for outdent actions.
 [!] Known follow-up: syntax detection still needs Go parity. todo.txt can be misdetected as filetype B because signatures are considered globally instead of only disambiguating filename/header matches.
 [!] Known tool note: apply_patch is currently unreliable in this environment; use Bun scripts for small file edits.
 
@@ -76,7 +82,9 @@ Screen / tcell parity
 [x] Replace current whole-string renderer with CellBuffer-backed rendering and diff flush.
 [x] Implement Screen.SetContent/GetContent/Fill/Show equivalents over CellBuffer.
 [x] Preserve per-cell style and wide-char handling: Cell.filler for double-width right-half, Screen.Show skips filler cells, putText/putCells advance col by visual width, setFillerContent added to Screen/CellBuffer.
-[ ] Preserve combining chars (zero-width combining marks stored alongside base char).
+[~] Preserve combining chars (zero-width combining marks stored alongside base char).
+    Done: CellBuffer/Screen/VT100 store combining marks alongside the base cell and terminal pane rendering emits them through Screen.SetContent.
+    Remaining: editor text rendering still needs grapheme-cluster-level behavior for combining marks and ZWJ sequences.
 [ ] Implement fake cursor and multi-cursor reverse styling behavior.
 [ ] Add raw escape registration/unregistration equivalent to tcell RegisterRawSeq.
 [~] Add complete bracketed paste event handling across split input chunks.
@@ -105,6 +113,7 @@ Buffer / editing model
 [~] Implement save options: fileformat, encoding, eofnewline, rmtrailingws, mkparents, autosu/sucmd behavior.
     Done: eofnewline save behavior exists; fileformat status/toggle exists; encoding decode/reopen supports Bun TextDecoder labels including common CJK encodings, and statusline encoding click pre-fills reopen with encoding completion.
     Done: saving a non-UTF-8-decoded buffer prompts "Save in UTF-8?(y,n)" before converting the buffer to UTF-8 on disk.
+    Done: hex3 encoding supports binary edit/open/save paths without UTF-8 conversion prompt.
     Remaining: non-UTF-8 save/encode, rmtrailingws, mkparents, autosu/sucmd, full fileformat behavior parity.
 [ ] Implement backup recovery and permbackup behavior.
 [~] Implement savecursor and saveundo serialization.
@@ -194,8 +203,8 @@ Lua plugin parity
     Done: minimal Buf/BufPane/Cursor adapters support autoclose-style Line/Insert/Replace/cursor movement and option access.
     Remaining: real BufPane/Cursor/Buffer object parity, selections, multi-cursor, Tab/TabList APIs, InfoPane/Log/Raw buffers.
 [~] Implement all plugin lifecycle hooks: preinit, init, postinit, onRune, preInsertNewline, preBackspace, onSave, onBufferOpen, onBufferOptionChanged, onAnyEvent, etc.
-    Done: preinit/init/postinit, onRune, preInsertNewline, preBackspace, onSave, onBufferOpen, onSetActive/onBufferClose are dispatched in current editor paths.
-    Remaining: onBufferOptionChanged, onAnyEvent, deinit/reload hooks, full action hook coverage, exact args/return behavior.
+    Done: preinit/init/postinit, onRune, preInsertNewline, preBackspace, onSave, onBufferOpen, onSetActive/onBufferClose, onBufferOptionChanged are dispatched in current editor paths.
+    Remaining: onAnyEvent, deinit/reload hooks, full action hook coverage, exact args/return behavior.
 [~] Ensure Lua return values can cancel operations where Go micro expects bool false.
     Done: PluginManager.runBool treats false as cancellation and is wired for preBackspace/preInsertNewline.
     Remaining: all cancellable actions/hooks need to use the same path and match Go micro semantics.
@@ -291,7 +300,9 @@ Shell / jobs / terminal pane
 [x] Implement Ctrl-B ShellMode prompt and shell command execution with temporary screen fini/start behavior.
 [x] Improve Bun PTY terminal pane rendering using terminal state/cell emulation instead of raw line log.
     VT100 class in src/screen/vt100.js: CSI cursor/erase/SGR/scroll, CPR response, OSC strip.
-[ ] Implement terminal selection/copy and close behavior parity.
+[~] Implement terminal selection/copy and close behavior parity.
+    Done: exited terminal panes can be closed with Enter and restore the previous editor buffer when available.
+    Remaining: terminal selection/copy and full close behavior parity.
 [ ] Verify Bun.spawn stdio usage everywhere; PTY terminal option remains separate.
 [x] Shared HTTP backend in platform/commands.js: fetchHttp(url) and downloadFile(url, outPath).
     Priority: Bun.which detects curl (curl -kL --silent --fail) or wget (wget --no-check-certificate -q -O -),