bunmicro 0.9.1 → 0.9.5

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # Changelog
 
+## [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.5",
   "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" };
 
@@ -134,18 +135,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) {
@@ -1043,6 +1053,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 +1349,7 @@ class TerminalPane {
     this.proc = null;
     this.vt = null;
     this.decoder = new TextDecoder();
+    this.exited = false;
   }
 
   open(cols, rows) {
@@ -1335,6 +1361,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 +1375,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 +1384,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 +1400,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 ────────────────────────────────────────────────────
@@ -2325,17 +2447,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 +2472,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 +3504,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 +3657,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 +3907,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 +4679,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; }
 });
@@ -5562,7 +5697,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 +6170,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 +6191,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;
   }