bunmicro 0.9.25 → 0.9.30

package/CHANGELOG.md

@@ -1,5 +1,10 @@
 # Changelog
 
+## [0.9.30] - 2026-06-13
+- Fixed binary edit hex3 regression
+  * see readme
+- Added crash backup recovery
+
 ## [0.9.25] - 2026-06-10
 - Fixed colorscheme: aligned with go
 - Added colorcolumn taberror showchars

package/README.md

@@ -35,6 +35,16 @@
 - Works like bat ccat glow
 - bunmicro -bat file
 - aliases: --cat --bat --ccat --glow
+## Binary edit by hex3
+- Edit binary files like text files
+- bunmicro libc.so.6
+- Ctrl+E reopen hex3
+- Printable chars stay readable
+  * a => a..
+- Non-printable chars become escapes
+  * \xff => \ff
+- Search & Edit by plain text
+- And simply save by Ctrl+S
 ## Preview color schemes(theme)
 - Ctrl-E theme, then press Tab and use arrow keys to preview
 ## Mouse clicks more useful

package/package.json

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

package/src/buffer/backup.js

@@ -0,0 +1,160 @@
+// Crash recovery backup system compatible with Go micro's internal/buffer/backup.go.
+
+import { join } from "node:path";
+import { existsSync, statSync, unlinkSync } from "node:fs";
+import { mkdir, writeFile, readFile, rename } from "node:fs/promises";
+import { homedir } from "node:os";
+import { createHash } from "node:crypto";
+
+export const BACKUP_SUFFIX = ".micro-backup";
+
+export function getBackupDir(buf, configDir) {
+  const raw = String(buf?.Settings?.backupdir ?? "");
+  if (!raw) return join(configDir, "backups");
+  if (raw === "~" || raw.startsWith("~/") || raw.startsWith("~\\")) {
+    return raw.replace(/^~/, homedir());
+  }
+  // Node has no portable equivalent of Go's user.Lookup for ~otheruser.
+  if (raw.startsWith("~")) return join(configDir, "backups");
+  return raw;
+}
+
+function queryEscapePath(path) {
+  return encodeURIComponent(String(path).replaceAll("\\", "/"))
+    .replace(/[!'()*]/g, (ch) => `%${ch.charCodeAt(0).toString(16).toUpperCase()}`)
+    .replace(/%20/g, "+"); 
+} // '
+
+function legacyEscapePath(path) {
+  let escaped = String(path).replaceAll("\\", "/");
+  if (process.platform === "win32") escaped = escaped.replaceAll(":", "%");
+  return escaped.replaceAll("/", "%");
+}
+
+export function determineBackupPath(backupDirPath, absPath) {
+  const urlName = join(backupDirPath, queryEscapePath(absPath));
+  if (existsSync(urlName)) return { name: urlName, resolveName: null };
+
+  const legacyName = join(backupDirPath, legacyEscapePath(absPath));
+  if (existsSync(legacyName)) return { name: legacyName, resolveName: null };
+
+  if (Buffer.byteLength(urlName + BACKUP_SUFFIX) > 255) {
+    const hash = createHash("md5").update(absPath).digest("hex");
+    return {
+      name: join(backupDirPath, hash),
+      resolveName: join(backupDirPath, hash + ".path"),
+    };
+  }
+  return { name: urlName, resolveName: null };
+}
+
+export async function writeBackup(buf, configDir, path = buf?.AbsPath ?? buf?.path, { force = false } = {}) {
+  if ((!force && !buf?.Settings?.backup) || !path || buf.type !== "default") return false;
+  const dir = getBackupDir(buf, configDir);
+  await mkdir(dir, { recursive: true });
+  const { name, resolveName } = determineBackupPath(dir, path);
+  const tmp = name + BACKUP_SUFFIX;
+  try {
+    await writeFile(tmp, buf.lines.join("\n"), "utf8");
+    await rename(tmp, name);
+    if (resolveName) await writeFile(resolveName, path, "utf8");
+    return true;
+  } catch (error) {
+    try { unlinkSync(tmp); } catch {}
+    throw error;
+  }
+}
+
+export function removeBackup(buf, configDir, path = buf?.AbsPath ?? buf?.path) {
+  if (buf?.Settings?.permbackup || buf?._forceKeepBackup) return;
+  if (!path || buf.type !== "default") return;
+  const dir = getBackupDir(buf, configDir);
+  const { name, resolveName } = determineBackupPath(dir, path);
+  try { unlinkSync(name); } catch {}
+  if (resolveName) try { unlinkSync(resolveName); } catch {}
+}
+
+// promptFn(msg) -> Promise<string>
+// Returns { recovered: bool, abort: bool }
+export async function applyBackup(buf, configDir, promptFn) {
+  if (!buf?.Settings?.backup || buf?.Settings?.permbackup) return { recovered: false, abort: false };
+  if (!buf.path || buf.type !== "default") return { recovered: false, abort: false };
+
+  const dir = getBackupDir(buf, configDir);
+  const { name: backupFile, resolveName } = determineBackupPath(dir, buf.AbsPath ?? buf.path);
+  if (!existsSync(backupFile)) return { recovered: false, abort: false };
+
+  let info;
+  try { info = statSync(backupFile); } catch { return { recovered: false, abort: false }; }
+
+  const t = info.mtime;
+  const dateStr =
+    t.toLocaleDateString("en-US", { weekday: "short", month: "short", day: "numeric" }) +
+    " at " +
+    t.toLocaleTimeString("en-US", { hour: "2-digit", minute: "2-digit", hour12: false }) +
+    ", " + t.getFullYear();
+
+  const ticcc='```';
+
+  const msg = `
+# Backup detected! ⚠️
+- File path/url:
+${ticcc}
+${buf.path}
+${ticcc}
+- either micro crashed
+- or another micro is running
+- or an error occurred while saving
+- The file may be corrupted
+# Date of backup 🕰
+- ${dateStr}
+# Path of backup 
+${ticcc}
+${backupFile}
+${ticcc}
+# Recovery options
+## r = 'recover'
+- Apply the backup 
+- as unsaved changes to the current buffer
+- When the buffer is closed, the backup will be removed.
+## i = 'ignore'
+- Ignore & remove the backup
+## a = 'abort' 
+- Abort the open operation
+- Open an empty buffer
+- Keep the backup
+### Your choice
+- [r]ecover, [i]gnore, [a]bort
+`;
+
+  const options = ["r", "i", "a", "recover", "ignore", "abort"];
+  let choice = -1;
+  let prompt = msg;
+  while (choice === -1) {
+    const resp = await promptFn(prompt);
+    const idx = options.indexOf(resp.trim().toLowerCase());
+    if (idx !== -1) choice = idx % 3;
+    else prompt = "\n#### Invalid choice!";
+  }
+
+  if (choice === 0) {
+    try {
+      const text = await readFile(backupFile, "utf8");
+      buf.lines = text.replace(/\r\n/g, "\n").replace(/\r/g, "\n").split("\n");
+      if (!buf.lines.length) buf.lines = [""];
+      buf._recovered = true;
+      buf._savedSerial = -1;
+      buf.setModified?.(true);
+      if (!buf.setModified) buf.modified = true;
+      return { recovered: true, abort: false };
+    } catch {
+      return { recovered: false, abort: false };
+    }
+  }
+  if (choice === 1) {
+    try { unlinkSync(backupFile); } catch {}
+    if (resolveName) try { unlinkSync(resolveName); } catch {}
+    return { recovered: false, abort: false };
+  }
+  return { recovered: false, abort: true };
+}

package/src/index.js

@@ -23,6 +23,8 @@ import { platformId, run as runCommand, runSync, fetchHttpBytes, detectHttpBacke
 import { shellSplit } from "./shell/shell.js";
 import { styleToAnsi } from "./display/ansi-style.js";
 import { encodeBinaryToBuffer, decodeBinaryBytes } from "./buffer/fixed3-codec.js";
+import { writeBackup, removeBackup, applyBackup } from "./buffer/backup.js";
+import { createInterface } from "node:readline/promises";
 
 import pkg from "../package.json" with { type: "json" };
 
@@ -92,6 +94,9 @@ const DEFAULT_SETTINGS = {
   matchbraceleft: true,
   matchbracestyle: "underline",
   savecursor: false,
+  backup: true,
+  backupdir: "",
+  permbackup: false,
   softwrap: false,
   wordwrap: false,
   pageoverlap: 2,
@@ -119,6 +124,20 @@ function write(data) {
   process.stdout.write(data);
 }
 
+// Pre-TUI terminal prompt — stdin must still be in line (cooked) mode.
+// Accepts an optional input stream so the TUI path can pass its own tty fd.
+async function termPromptLine(msg, input = process.stdin) {
+  const rl = createInterface({ input, output: process.stdout });
+  try {
+    console.log(Bun.markdown.ansi(msg))
+    return await rl.question("> ");
+  } catch {
+    return "";
+  } finally {
+    rl.close();
+  }
+}
+
 function sgr(...codes) {
   return `\x1b[${codes.join(";")}m`;
 }
@@ -611,7 +630,15 @@ class BufferModel {
     if (this.lines.length === 0) this.lines = [""];
     this.cursor = { x: 0, y: 0 };
     this.scroll = { x: 0, y: 0, row: 0 };
-    this.modified = false;
+    this._modified = false;
+    this._backupRequested = false;
+    this._backupRevision = 0;
+    Object.defineProperty(this, "modified", {
+      configurable: true,
+      enumerable: true,
+      get: () => this._modified,
+      set: (value) => this.setModified(value),
+    });
     this.readonly = readonly;
     this.modTimeMs = modTimeMs;
     this.reloadDisabled = false;
@@ -644,6 +671,9 @@ class BufferModel {
       matchbraceleft: DEFAULT_SETTINGS.matchbraceleft,
       matchbracestyle: DEFAULT_SETTINGS.matchbracestyle,
       savecursor: DEFAULT_SETTINGS.savecursor,
+      backup: DEFAULT_SETTINGS.backup,
+      backupdir: DEFAULT_SETTINGS.backupdir,
+      permbackup: DEFAULT_SETTINGS.permbackup,
       softwrap: DEFAULT_SETTINGS.softwrap,
       wordwrap: DEFAULT_SETTINGS.wordwrap,
       pageoverlap: DEFAULT_SETTINGS.pageoverlap,
@@ -674,6 +704,19 @@ class BufferModel {
     if (command.searchRegex) this.search(command.searchRegex, command.searchAfterStart);
   }
 
+  setModified(value = true) {
+    const next = Boolean(value);
+    const prev = this._modified;
+    this._modified = next;
+    if (next) {
+      this._backupRequested = true;
+      this._backupRevision++;
+    } else {
+      this._backupRequested = false;
+      if (prev && this._configDir) removeBackup(this, this._configDir);
+    }
+  }
+
   static async fromFile(path, command, context = {}) {
     let text = "";
     let readonly = false;
@@ -689,6 +732,7 @@ class BufferModel {
       encoding = decoded.encoding;
     }
     const buffer = new BufferModel({ path, text, command, readonly, modTimeMs, encoding });
+    buffer._configDir = context?.config?.configDir ?? null;
     attachSyntax(buffer, context, path, text);
     return buffer;
   }
@@ -1101,39 +1145,74 @@ class BufferModel {
   async save(path = this.path) {
     if (!path) throw new Error("No filename");
     const detectSyntaxAfterSave = this.filetype === "unknown";
+    const oldPath = this.AbsPath || this.path;
+    const targetPath = resolve(path);
     let text = this.lines.join("\n");
+    if (this._configDir) {
+      if (this._backupWritePromise) {
+        try { await this._backupWritePromise; } catch {}
+      }
+      const backupRevision = this._backupRevision;
+      const job = writeBackup(this, this._configDir, targetPath, { force: true });
+      this._backupWritePromise = job;
+      try {
+        await job;
+      } finally {
+        if (this._backupWritePromise === job) this._backupWritePromise = null;
+      }
+      if (this._backupRevision === backupRevision) this._backupRequested = false;
+      this._forceKeepBackup = true;
+    }
     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);
+      try {
+        await Bun.write(targetPath, decodeBinaryBytes(Buffer.from(text, "latin1")));
+      } finally {
+        this._forceKeepBackup = false;
+      }
+      this.path = targetPath;
+      this.Path = targetPath;
+      this.AbsPath = targetPath;
+      this.name = basename(targetPath);
       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}`;
-      if (detectSyntaxAfterSave && this._syntaxContext) attachSyntax(this, this._syntaxContext, path, text);
+      this.message = `Saved ${targetPath}`;
+      if (this._configDir && oldPath !== targetPath) removeBackup(this, this._configDir, oldPath);
+      this._updateOpenBufferPath(oldPath, targetPath);
+      if (detectSyntaxAfterSave && this._syntaxContext) attachSyntax(this, this._syntaxContext, targetPath, text);
       return;
     }
     if ((this.Settings.eofnewline ?? DEFAULT_SETTINGS.eofnewline) && !text.endsWith("\n")) text += "\n";
-    await Bun.write(path, encodeBufferTextForFile(text, this.Settings.fileformat ?? this.fileformat));
+    try {
+      await Bun.write(targetPath, encodeBufferTextForFile(text, this.Settings.fileformat ?? this.fileformat));
+    } finally {
+      this._forceKeepBackup = false;
+    }
     this.encoding = "utf-8";
     this.Settings.encoding = "utf-8";
-    this.path = path;
-    this.Path = path;
-    this.AbsPath = path;
-    this.name = basename(path);
+    this.path = targetPath;
+    this.Path = targetPath;
+    this.AbsPath = targetPath;
+    this.name = basename(targetPath);
     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}`;
-    if (detectSyntaxAfterSave && this._syntaxContext) attachSyntax(this, this._syntaxContext, path, text);
+    this.message = `Saved ${targetPath}`;
+    if (this._configDir && oldPath !== targetPath) removeBackup(this, this._configDir, oldPath);
+    this._updateOpenBufferPath(oldPath, targetPath);
+    if (detectSyntaxAfterSave && this._syntaxContext) attachSyntax(this, this._syntaxContext, targetPath, text);
+  }
+
+  _updateOpenBufferPath(oldPath, newPath) {
+    if (!this._openBufferMap) return;
+    if (oldPath && this._openBufferMap.get(oldPath) === this) this._openBufferMap.delete(oldPath);
+    this._openBufferMap.set(newPath, this);
   }
 
   // --- Autocomplete (BufferComplete) ---
@@ -1700,11 +1779,15 @@ class App {
   get buffer() { return this.pane?.buffer ?? null; }
   // backward-compat for the few spots that still use this.active / this.buffers
   get active() { return this.activeTabIdx; }
-  get buffers() { return this.tabs.map(t => t.buffer).filter(Boolean); }
+  get buffers() {
+    return [...new Set(this.tabs.flatMap((tab) =>
+      tab.panes().flatMap((pane) => [pane.buffer, pane.prevBuffer]).filter(Boolean)
+    ))];
+  }
 
   paneForBuffer(buffer) {
     for (const tab of this.tabs) {
-      const pane = tab.panes().find((p) => p.buffer === buffer);
+      const pane = tab.panes().find((p) => p.buffer === buffer || p.prevBuffer === buffer);
       if (pane) return pane;
     }
     return null;
@@ -1755,6 +1838,45 @@ class App {
     });
     process.on("SIGINT", () => {}); // Ctrl+C is handled as copy in handleEvent
     this.screen.init();
+    // Update backup prompt to screen-aware version now that TUI is running.
+    if (this.context._termPrompt) {
+      this.context._termPrompt = async (msg) => {
+        const tty = this._ttyStream ?? process.stdin;
+        if (this._inputHandler) tty.removeListener("data", this._inputHandler);
+        tty.setRawMode?.(false);
+        this.screen.fini();
+        process.stdout.write("\n");
+        const answer = await termPromptLine(msg, tty);
+        this.screen.previous = null;
+        this.screen.init();
+        tty.setRawMode?.(true);
+        tty.resume(); // rl.close() pauses the stream; resume so data events fire again
+        if (this._inputHandler) tty.on("data", this._inputHandler);
+        return answer;
+      };
+    }
+    // Process buffers requested by edits. A successful backup is not repeated
+    // until the buffer is modified again.
+    const configDir = this.context?.config?.configDir;
+    if (configDir) {
+      this._backupTimer = setInterval(async () => {
+        for (const buf of this.buffers) {
+          if (buf._backupRequested && buf.modified && buf.path && buf.type === "default" &&
+              (buf.Settings?.backup ?? DEFAULT_SETTINGS.backup) && !buf._backupWritePromise) {
+            const revision = buf._backupRevision;
+            const job = writeBackup(buf, configDir);
+            buf._backupWritePromise = job;
+            try {
+              if (await job) {
+                if (buf._backupRevision === revision) buf._backupRequested = false;
+              }
+            } catch {} finally {
+              if (buf._backupWritePromise === job) buf._backupWritePromise = null;
+            }
+          }
+        }
+      }, 10_000);
+    }
     startupHighlightProgress = new StartupHighlightProgress(this);
     try {
       this.render();
@@ -1774,6 +1896,8 @@ class App {
 
   async stop(code = 0) {
     this.running = false;
+    if (this._backupTimer) { clearInterval(this._backupTimer); this._backupTimer = null; }
+    await Promise.allSettled(this.buffers.map((buf) => buf._backupWritePromise).filter(Boolean));
     for (const tab of this.tabs)
       for (const p of tab.panes())
         if (p.type === "term") p.terminal?.close();
@@ -1790,6 +1914,10 @@ class App {
       }
       try { await saveCursorStates(this.context.config.configDir, this.context.cursorStates); } catch {}
     }
+    const configDir = this.context?.config?.configDir;
+    if (configDir) {
+      for (const buf of this.buffers) removeBackup(buf, configDir);
+    }
     process.exit(code);
   }
 
@@ -3859,9 +3987,11 @@ class App {
   }
   async openInPane(path) {
     try {
+      const previous = this.pane.buffer;
       const buffer = await loadBufferForPath(path, this.context);
       this.pane.buffer = buffer;
       this.pane.selection = null;
+      if (previous !== buffer) this._closeBufferIfUnused(previous);
       await this.context.plugins?.run("onBufferOpen", buffer);
       await this.context.jsPlugins?.run("onBufferOpen", buffer);
     } catch (error) {
@@ -3873,8 +4003,10 @@ class App {
     try {
       const buffer = await loadBufferForPath(path, this.context);
       if (isEmptyUntitledBuffer(this.buffer)) {
+        const previous = this.pane.buffer;
         this.pane.buffer = buffer;
         this.pane.selection = null;
+        if (previous !== buffer) this._closeBufferIfUnused(previous);
       } else {
         const tab = new Tab(new Pane(buffer));
         this.tabs.push(tab);
@@ -4057,8 +4189,10 @@ class App {
 
   closePane(pane) {
     pane.terminal?.close();
+    const closingBuffers = [...new Set([pane.buffer, pane.prevBuffer].filter(Boolean))];
     const tab = this.tab;
     tab.removePane(pane);
+    for (const buffer of closingBuffers) this._closeBufferIfUnused(buffer);
     if (!tab.root) {
       // Tab is empty — close it
       if (this.tabs.length <= 1) { this.stop(0); return; }
@@ -4073,10 +4207,12 @@ class App {
       await this.stop(0);
       return;
     }
+    const closingBuffers = [...new Set(this.tab.panes().flatMap((pane) => [pane.buffer, pane.prevBuffer]).filter(Boolean))];
     const closing = this.buffer;
     this.tabs.splice(this.activeTabIdx, 1);
     this.activeTabIdx = Math.min(this.activeTabIdx, this.tabs.length - 1);
     this.message = "";
+    for (const buffer of closingBuffers) this._closeBufferIfUnused(buffer);
     if (this.context.plugins && this.buffer) this.context.plugins.curPaneAdapter = makePaneAdapter(this.buffer, this);
     await this.context.plugins?.run("onSetActive", makePaneAdapter(this.buffer, this));
     await this.context.plugins?.run("onBufferClose", closing);
@@ -4085,6 +4221,14 @@ class App {
     this.render();
   }
 
+  _closeBufferIfUnused(buffer) {
+    if (!buffer || this.paneForBuffer(buffer)) return;
+    const configDir = this.context?.config?.configDir;
+    if (configDir) removeBackup(buffer, configDir);
+    const map = this.context?._openBuffers;
+    if (map && map.get(buffer.AbsPath) === buffer) map.delete(buffer.AbsPath);
+  }
+
   openCommandMode(initial = "") {
     const originalColorscheme = this.context.colorscheme;
     const previewTheme = async (value) => {
@@ -4442,25 +4586,27 @@ class App {
       case "vsplit": {
         let newBuf;
         if (cmdArgs.length > 0) {
-          try { newBuf = await BufferModel.fromFile(resolve(expandHome(cmdArgs[0])), {}, this.context); }
+          try { newBuf = await loadBufferForPath(resolve(expandHome(cmdArgs[0])), this.context); }
           catch (err) { this.message = err.message; break; }
         } else {
           newBuf = new BufferModel({ command: {} });
           attachSyntax(newBuf, this.context, "", "");
         }
         this.tab.split(this.pane, new Pane(newBuf), "h");
+        this.render();
         break;
       }
       case "hsplit": {
         let newBuf;
         if (cmdArgs.length > 0) {
-          try { newBuf = await BufferModel.fromFile(resolve(expandHome(cmdArgs[0])), {}, this.context); }
+          try { newBuf = await loadBufferForPath(resolve(expandHome(cmdArgs[0])), this.context); }
           catch (err) { this.message = err.message; break; }
         } else {
           newBuf = new BufferModel({ command: {} });
           attachSyntax(newBuf, this.context, "", "");
         }
         this.tab.split(this.pane, new Pane(newBuf), "v");
+        this.render();
         break;
       }
       case "term": {
@@ -5731,9 +5877,26 @@ async function loadBufferForPath(pathOrUrl, context, command = {}) {
     encoding = decoded.encoding;
     const urlPath = pathOrUrl.replace(/[?#].*$/, "");
     buffer = new BufferModel({ path: pathOrUrl, text, command, encoding });
+    buffer._configDir = context?.config?.configDir ?? null;
     attachSyntax(buffer, context, urlPath, text);
   } else {
-    buffer = await BufferModel.fromFile(pathOrUrl, command, context);
+    if (!context._openBuffers) context._openBuffers = new Map();
+    const absPath = resolve(pathOrUrl);
+    const existing = context._openBuffers.get(absPath);
+    if (existing) return existing;
+    buffer = await BufferModel.fromFile(absPath, command, context);
+    // Check for crash-recovery backup before returning the buffer.
+    const promptFn = context._termPrompt;
+    if (promptFn && buffer._configDir) {
+      const { recovered, abort } = await applyBackup(buffer, buffer._configDir, promptFn);
+      if (abort) return new BufferModel({ command });
+      if (recovered) {
+        buffer.ensureCursor();
+        attachSyntax(buffer, context, absPath, buffer.lines.join("\n"));
+      }
+    }
+    buffer._openBufferMap = context._openBuffers;
+    context._openBuffers.set(absPath, buffer);
   }
   if (DEFAULT_SETTINGS.savecursor && !commandHasStartupJump(command) && context?.cursorStates?.[pathOrUrl]) {
     const saved = context.cursorStates[pathOrUrl];
@@ -6115,9 +6278,13 @@ function renderHighlightedCells(buf, lineNo, scrollX, maxWidth, colorscheme, sel
     else if (key === "ispace") indentspacechars = val;
     else if (key === "itab") indenttabchars = val;
   }
-  // leadingwsEnd: index of first non-whitespace char (raw code-unit index)
+  // Only inspect visible leading whitespace. Once horizontally scrolled, the
+  // line start is off-screen and should not make redraw cost depend on it.
   let leadingwsEnd = 0;
-  while (leadingwsEnd < raw.length && (raw[leadingwsEnd] === " " || raw[leadingwsEnd] === "\t")) leadingwsEnd++;
+  if (scrollX === 0) {
+    const visibleEnd = Math.min(raw.length, maxWidth);
+    while (leadingwsEnd < visibleEnd && (raw[leadingwsEnd] === " " || raw[leadingwsEnd] === "\t")) leadingwsEnd++;
+  }
 
   const hltaberrors = buf.Settings?.hltaberrors ?? false;
   const tabstospaces = buf.Settings?.tabstospaces ?? false;
@@ -6133,9 +6300,9 @@ function renderHighlightedCells(buf, lineNo, scrollX, maxWidth, colorscheme, sel
     : null;
   const tabsize = buf.Settings?.tabsize ?? DEFAULT_SETTINGS.tabsize;
 
-  // scrollVisualCol: visual column of raw[0..scrollX). Uses displayWidth (tab = full
-  // tabsize, not aligned-to-boundary) to stay consistent with cursor/scroll math.
-  const scrollVisualCol = displayWidth(raw.slice(0, scrollX));
+  // Keep horizontal rendering bounded to the visible range. Reconstructing
+  // the exact display width before scrollX makes long-line redraws O(scrollX).
+  const scrollVisualCol = scrollX;
 
   // Linter messages overlapping this line (Go bufwindow.go:662-668)
   const lineMessages = (buf.Messages ?? []).filter((m) => {
@@ -6532,6 +6699,8 @@ async function main() {
   if (DEFAULT_SETTINGS.savecursor) {
     context.cursorStates = await loadCursorStates(config.configDir);
   }
+  // Backup prompt available before App starts (stdin still in cooked mode).
+  context._termPrompt = process.stdout.isTTY ? termPromptLine : null;
   loadBuffers.context = context;
   const buffers = await loadBuffers(files.map((file) =>
     isHttpUrl(file) ? file : resolve(file)

package/tests/backup.test.js

@@ -0,0 +1,133 @@
+import { afterEach, describe, expect, test } from "bun:test";
+import { mkdtemp, mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import { existsSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { createHash } from "node:crypto";
+import {
+  BACKUP_SUFFIX,
+  applyBackup,
+  determineBackupPath,
+  removeBackup,
+  writeBackup,
+} from "../src/buffer/backup.js";
+
+const cleanup = [];
+
+afterEach(async () => {
+  await Promise.all(cleanup.splice(0).map((path) => rm(path, { recursive: true, force: true })));
+});
+
+async function tempDir() {
+  const path = await mkdtemp(join(tmpdir(), "bunmicro-backup-"));
+  cleanup.push(path);
+  return path;
+}
+
+function buffer(path, text = "changed") {
+  return {
+    path,
+    AbsPath: path,
+    type: "default",
+    lines: text.split("\n"),
+    Settings: { backup: true, backupdir: "", permbackup: false },
+    _savedSerial: 0,
+    setModified(value) { this.modified = Boolean(value); },
+  };
+}
+
+describe("go-micro compatible backup paths", () => {
+  test("uses Go url.QueryEscape-compatible names", async () => {
+    const dir = await tempDir();
+    const result = determineBackupPath(dir, "/tmp/a b%~!'()*.txt");
+    expect(result).toEqual({
+      name: join(dir, "%2Ftmp%2Fa+b%25~%21%27%28%29%2A.txt"),
+      resolveName: null,
+    });
+  });
+
+  test("prefers an existing legacy name", async () => {
+    const dir = await tempDir();
+    const legacy = join(dir, "%tmp%legacy.txt");
+    await writeFile(legacy, "legacy");
+    expect(determineBackupPath(dir, "/tmp/legacy.txt").name).toBe(legacy);
+  });
+
+  test("uses Go's full MD5 hash and .path sidecar for long names", async () => {
+    const dir = await tempDir();
+    const path = "/" + "x".repeat(300);
+    const hash = createHash("md5").update(path).digest("hex");
+    expect(determineBackupPath(dir, path)).toEqual({
+      name: join(dir, hash),
+      resolveName: join(dir, hash + ".path"),
+    });
+  });
+});
+
+describe("backup lifecycle", () => {
+  test("writes atomically using the Go backup suffix", async () => {
+    const root = await tempDir();
+    const backupDir = join(root, "backups");
+    const buf = buffer("/tmp/file.txt", "one\ntwo");
+    buf.Settings.backupdir = backupDir;
+    const target = determineBackupPath(backupDir, buf.AbsPath);
+
+    expect(await writeBackup(buf, root)).toBe(true);
+    expect(await readFile(target.name, "utf8")).toBe("one\ntwo");
+    expect(existsSync(target.name + BACKUP_SUFFIX)).toBe(false);
+  });
+
+  test("recover keeps the backup and marks a distinct dirty baseline", async () => {
+    const root = await tempDir();
+    const backupDir = join(root, "backups");
+    await mkdir(backupDir);
+    const buf = buffer("/tmp/file.txt", "disk");
+    buf.Settings.backupdir = backupDir;
+    const target = determineBackupPath(backupDir, buf.AbsPath);
+    await writeFile(target.name, "recovered");
+
+    expect(await applyBackup(buf, root, async () => "recover")).toEqual({ recovered: true, abort: false });
+    expect(buf.lines).toEqual(["recovered"]);
+    expect(buf.modified).toBe(true);
+    expect(buf._savedSerial).toBe(-1);
+    expect(existsSync(target.name)).toBe(true);
+  });
+
+  test("ignore removes the backup", async () => {
+    const root = await tempDir();
+    const backupDir = join(root, "backups");
+    await mkdir(backupDir);
+    const buf = buffer("/tmp/file.txt");
+    buf.Settings.backupdir = backupDir;
+    const target = determineBackupPath(backupDir, buf.AbsPath);
+    await writeFile(target.name, "ignored");
+
+    expect(await applyBackup(buf, root, async () => "ignore")).toEqual({ recovered: false, abort: false });
+    expect(existsSync(target.name)).toBe(false);
+  });
+
+  test("permanent backups survive removal", async () => {
+    const root = await tempDir();
+    const backupDir = join(root, "backups");
+    const buf = buffer("/tmp/file.txt");
+    buf.Settings.backupdir = backupDir;
+    buf.Settings.permbackup = true;
+    await writeBackup(buf, root);
+    const target = determineBackupPath(backupDir, buf.AbsPath);
+
+    removeBackup(buf, root);
+    expect(existsSync(target.name)).toBe(true);
+  });
+
+  test("forced safe-write backups work when periodic backups are disabled", async () => {
+    const root = await tempDir();
+    const backupDir = join(root, "backups");
+    const buf = buffer("/tmp/file.txt");
+    buf.Settings.backupdir = backupDir;
+    buf.Settings.backup = false;
+
+    expect(await writeBackup(buf, root)).toBe(false);
+    expect(await writeBackup(buf, root, buf.AbsPath, { force: true })).toBe(true);
+    expect(existsSync(determineBackupPath(backupDir, buf.AbsPath).name)).toBe(true);
+  });
+});

package/todo.txt

@@ -116,7 +116,12 @@ Buffer / editing model
     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.
+[x] Implement backup recovery and permbackup behavior.
+    - src/buffer/backup.js: writeBackup/removeBackup/applyBackup; path-escaped flat filename in configDir/backups/ (>200 bytes falls back to SHA-256 hash + .resolve sidecar).
+    - Periodic backup timer (10s) in App.start() writes all modified default buffers.
+    - applyBackup called in loadBufferForPath (covers open/vsplit/hsplit/startup) via context._termPrompt; pre-TUI uses readline/promises, in-TUI uses screen fini/init wrapper.
+    - removeBackup called on save, closePane, closeCurrentTab, and stop (all buffers).
+    - backup/backupdir/permbackup settings wired through DEFAULT_SETTINGS → buf.Settings → syncEditorSettings.
 [~] Implement savecursor and saveundo serialization.
     Done: savecursor saves cursor position to configDir/buffers/cursor_state.json on Ctrl-S and on quit; position is restored when re-opening the same file; syncs from Go micro settings.json.
     Done: savecursor restore now vertically centers the viewport on the restored cursor position (deferred via _pendingCenterScroll flag, resolved on first render after layout is computed; handles softwrap/non-softwrap via _ttsScrollToCenter).