bunmicro 0.9.23 → 0.9.30

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,
@@ -101,7 +106,11 @@ const DEFAULT_SETTINGS = {
   fileformat: process.platform === "win32" ? "dos" : "unix",
   "comment.type": "",
   commenttype: "",
-  trailingws: false,
+  hltrailingws: false,
+  hltaberrors: false,
+  colorcolumn: 0,
+  showchars: "",
+  indentchar: " ",
 };
 
 const LONG_LINE_REHIGHLIGHT_LIMIT = 300;
@@ -115,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`;
 }
@@ -607,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;
@@ -640,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,
@@ -647,7 +681,11 @@ class BufferModel {
       reload: DEFAULT_SETTINGS.reload,
       eofnewline: DEFAULT_SETTINGS.eofnewline,
       fileformat: this.fileformat,
-      trailingws: DEFAULT_SETTINGS.trailingws,
+      hltrailingws: DEFAULT_SETTINGS.hltrailingws,
+      hltaberrors: DEFAULT_SETTINGS.hltaberrors,
+      colorcolumn: DEFAULT_SETTINGS.colorcolumn,
+      showchars: DEFAULT_SETTINGS.showchars,
+      indentchar: DEFAULT_SETTINGS.indentchar,
       encoding: this.encoding,
       readonly,
     };
@@ -666,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;
@@ -681,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;
   }
@@ -1093,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) ---
@@ -1692,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;
@@ -1747,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();
@@ -1766,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();
@@ -1782,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);
   }
 
@@ -1879,7 +2015,9 @@ class App {
     const ft = (buf?.filetype && buf.filetype !== "unknown") ? buf.filetype : "?";
     const fmt = buf?.fileformat ?? "unix";
     const enc = buf?.encoding ?? "utf-8";
-    const baseStatus = { ...defaultStyle, reverse: true };
+    const baseStatus = this.context.colorscheme?.styles?.has("statusline")
+      ? this.context.colorscheme.get("statusline")
+      : { ...defaultStyle, reverse: true };
     const redStatus = { ...baseStatus, fg: "red" };
     // Fill entire row with base style first
     putText(this.screen, 0, statusRow, " ".repeat(this.cols), baseStatus, this.cols);
@@ -2010,8 +2148,9 @@ class App {
   }
 
   renderMessageRow(defaultStyle, row, message) {
-    const statusStyle = this.context.colorscheme?.get("statusline") ?? { ...defaultStyle, reverse: true };
-    const style = { ...statusStyle, reverse: false };
+    const style = this.context.colorscheme?.styles?.has("message")
+      ? this.context.colorscheme.get("message")
+      : defaultStyle;
     putText(this.screen, 0, row, " ".repeat(this.cols), style, this.cols);
     this._messageRowY = row;
     this._messageRowClickZone = null;
@@ -2041,15 +2180,15 @@ class App {
   }
 
   renderSuggestions(defaultStyle, row, suggestions, curIdx) {
-    const suggestionStyle = this.context.colorscheme?.get("statusline.suggestions")
-      ?? this.context.colorscheme?.get("statusline")
-      ?? defaultStyle;
-    const baseStyle = { ...suggestionStyle, reverse: false };
+    const cs = this.context.colorscheme;
+    const baseStyle = cs?.styles?.has("statusline.suggestions")
+      ? cs.get("statusline.suggestions")
+      : cs?.styles?.has("statusline")
+        ? cs.get("statusline")
+        : { ...defaultStyle, reverse: true };
     const selStyle = {
       ...baseStyle,
-      fg: baseStyle.bg === "default" ? "black" : baseStyle.bg,
-      bg: baseStyle.fg === "default" ? "brightwhite" : baseStyle.fg,
-      reverse: false,
+      reverse: true,
     };
 
     // Compute each item's position in the virtual (pre-scroll) space.
@@ -2172,9 +2311,16 @@ class App {
     const softwrap = buf.Settings?.softwrap ?? false;
     const wordwrap = softwrap && (buf.Settings?.wordwrap ?? false);
     const tabsize = buf.Settings?.tabsize ?? DEFAULT_SETTINGS.tabsize;
-    const gutterStyle = { ...defaultStyle, fg: "brightblack" };
-    const dirtyGutterStyle = { ...gutterStyle, fg: "red" };
     const isActivePane = pane === this.tab.activePane;
+    const gutterStyle = this.context.colorscheme?.styles?.has("line-number")
+      ? this.context.colorscheme.get("line-number")
+      : defaultStyle;
+    const cursorlineOn = buf.Settings?.cursorline ?? DEFAULT_SETTINGS.cursorline;
+    const csHasCurNum = this.context.colorscheme?.styles?.has("current-line-number");
+    const curNumStyle = !csHasCurNum
+      ? defaultStyle
+      : (cursorlineOn ? this.context.colorscheme.get("current-line-number") : gutterStyle);
+    const dirtyGutterStyle = { ...gutterStyle, fg: "red" };
     const useCursorline = (buf.Settings?.cursorline ?? DEFAULT_SETTINGS.cursorline) && isActivePane;
     const clBg = (useCursorline && this.context.colorscheme?.styles?.has("cursor-line"))
       ? (this.context.colorscheme.get("cursor-line")?.fg ?? null)
@@ -2187,12 +2333,12 @@ class App {
     const diffCol   = (buf.Settings?.diffgutter ?? false) ? 1 : 0;
     const lineNumW  = gutterW - msgW - diffCol;
     const cs = this.context.colorscheme;
-    const diffAddStyle = cs?.get("diff-added")    ?? { ...defaultStyle, fg: "green" };
-    const diffModStyle = cs?.get("diff-modified") ?? { ...defaultStyle, fg: "yellow" };
-    const diffDelStyle = cs?.get("diff-deleted")  ?? { ...defaultStyle, fg: "red" };
-    const msgInfoStyle  = cs?.get("gutter-info")    ?? { ...defaultStyle, fg: "cyan" };
-    const msgWarnStyle  = cs?.get("gutter-warning") ?? { ...defaultStyle, fg: "yellow" };
-    const msgErrStyle   = cs?.get("gutter-error")   ?? { ...defaultStyle, fg: "red" };
+    const diffAddStyle = cs?.styles?.has("diff-added") ? cs.get("diff-added") : null;
+    const diffModStyle = cs?.styles?.has("diff-modified") ? cs.get("diff-modified") : null;
+    const diffDelStyle = cs?.styles?.has("diff-deleted") ? cs.get("diff-deleted") : null;
+    const msgInfoStyle = cs?.styles?.has("gutter-info") ? cs.get("gutter-info") : defaultStyle;
+    const msgWarnStyle = cs?.styles?.has("gutter-warning") ? cs.get("gutter-warning") : defaultStyle;
+    const msgErrStyle = cs?.styles?.has("gutter-error") ? cs.get("gutter-error") : defaultStyle;
 
     const renderGutter = (lineNo, row, screenRow, subRow = 0) => {
       // Message indicator: 2 cols, '> ' with kind-based style (Go: drawGutter)
@@ -2209,19 +2355,22 @@ class App {
         }
         putText(this.screen, pane.x, screenRow, msgCh + " ", msgSt, 2);
       }
+      const isCurrentLine = isActivePane && !pane.selection && lineNo === buf.cursor.y;
+      const lineStyle = isCurrentLine ? curNumStyle : gutterStyle;
       if (diffCol > 0) {
         const m = diffMarks?.[lineNo] ?? 0;
-        const [ch, st] = m === 1 ? ["▌", diffAddStyle]
-                       : m === 2 ? ["▌", diffModStyle]
-                       : m === 3 ? ["▔", diffDelStyle]
-                       : [" ", gutterStyle];
+        const [ch, colorStyle] = m === 1 ? ["▌", diffAddStyle]
+                              : m === 2 ? ["▌", diffModStyle]
+                              : m === 3 ? ["▔", diffDelStyle]
+                              : [" ", null];
+        const st = colorStyle ? { ...lineStyle, fg: colorStyle.fg } : lineStyle;
         putText(this.screen, pane.x + msgW, screenRow, subRow === 0 ? ch : " ", st, 1);
       }
       if (lineNumW > 0) {
         const prefix = subRow === 0
           ? lineNumberText(buf, lineNo, row, lineNumW)
           : visualLineNumberText(subRow, lineNumW);
-        putText(this.screen, pane.x + msgW + diffCol, screenRow, prefix, isDirtyLongLine(buf, lineNo) ? dirtyGutterStyle : gutterStyle, lineNumW);
+        putText(this.screen, pane.x + msgW + diffCol, screenRow, prefix, isDirtyLongLine(buf, lineNo) ? dirtyGutterStyle : lineStyle, lineNumW);
       }
     };
 
@@ -2305,7 +2454,11 @@ class App {
 
   renderDividers(node, defaultStyle) {
     if (node instanceof Pane) return;
-    const divStyle = { ...defaultStyle, fg: "brightblack" };
+    const divReverse = this.context.config?.globalSettings?.divreverse ?? true;
+    const baseDiv = this.context.colorscheme?.styles?.has("divider")
+      ? this.context.colorscheme.get("divider")
+      : defaultStyle;
+    const divStyle = divReverse ? { ...baseDiv, reverse: true } : baseDiv;
     for (let i = 0; i < node.children.length - 1; i++) {
       const child = node.children[i];
       if (node.dir === "h") {
@@ -2322,21 +2475,37 @@ class App {
   }
 
   renderTabbar(defaultStyle) {
-    const tabBarStyle = this.context.colorscheme?.get("tabbar") ?? { ...defaultStyle, reverse: true };
-    const activeStyle = this.context.colorscheme?.get("tabbar.active") ?? { ...tabBarStyle, bold: true };
+    const cs = this.context.colorscheme;
+    const gs = this.context.config?.globalSettings;
+    const tabReverse = gs?.tabreverse ?? true;
+    const tabHighlight = gs?.tabhighlight ?? false;
+    const tabCharReverse = (tabReverse || tabHighlight) && !(tabReverse && tabHighlight);
+
+    const stylesFor = (reverse) => {
+      const base = cs?.styles?.has("tabbar")
+        ? cs.get("tabbar")
+        : { ...defaultStyle, reverse };
+      const active = cs?.styles?.has("tabbar.active")
+        ? cs.get("tabbar.active")
+        : base;
+      return [base, active];
+    };
+    const [sepStyle] = stylesFor(tabReverse);
+    const [charBase, charActive] = stylesFor(tabCharReverse);
+
     let x = 0;
     for (let i = 0; i < this.tabs.length && x < this.cols; i++) {
       const name = this.tabs[i].name || "No name";
       const isActive = i === this.activeTabIdx;
       const label = isActive ? `[${name}]` : ` ${name} `;
-      const style = isActive ? activeStyle : tabBarStyle;
+      const style = isActive ? charActive : charBase;
       const start = x;
       x = putText(this.screen, x, 0, label, style, this.cols - x);
       this.tabRects.push({ index: i, start, end: x });
       if (i < this.tabs.length - 1 && x < this.cols)
-        x = putText(this.screen, x, 0, "  ", tabBarStyle, this.cols - x);
+        x = putText(this.screen, x, 0, "  ", sepStyle, this.cols - x);
     }
-    if (x < this.cols) putText(this.screen, x, 0, " ".repeat(this.cols - x), tabBarStyle, this.cols - x);
+    if (x < this.cols) putText(this.screen, x, 0, " ".repeat(this.cols - x), sepStyle, this.cols - x);
   }
 
   updateScrollForPane(pane) {
@@ -3818,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) {
@@ -3832,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);
@@ -4016,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; }
@@ -4032,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);
@@ -4044,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) => {
@@ -4401,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": {
@@ -5690,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];
@@ -6047,22 +6251,79 @@ function renderHighlightedCells(buf, lineNo, scrollX, maxWidth, colorscheme, sel
   // Go: cursor-line bg is skipped when a syntax style already has a non-default background (preservebg)
   const defBg = colorscheme?.defaultStyle?.bg ?? "default";
 
-  const showTrailingWs = buf.Settings?.trailingws ?? false;
+  const showTrailingWs = buf.Settings?.hltrailingws ?? false;
   let trailingWsIdx = raw.length;
   if (showTrailingWs) {
     let k = raw.length - 1;
     while (k >= 0 && (raw[k] === " " || raw[k] === "\t")) k--;
     trailingWsIdx = k + 1;
   }
-  const trailingWsStyle = showTrailingWs
-    ? (colorscheme?.get("trailingws") ?? { fg: "red", underline: true })
+  const trailingWsColor = showTrailingWs && colorscheme?.styles?.has("trailingws")
+    ? colorscheme.get("trailingws")?.fg
+    : null;
+
+  // showchars parsing (Go bufwindow.go:455-476)
+  const indentchar = buf.Settings?.indentchar ?? " ";
+  let spacechars = " ";
+  let tabchars = indentchar;
+  let indentspacechars = "";
+  let indenttabchars = "";
+  for (const entry of String(buf.Settings?.showchars ?? "").split(",")) {
+    const eq = entry.indexOf("=");
+    if (eq < 0) continue;
+    const key = entry.slice(0, eq);
+    const val = entry.slice(eq + 1);
+    if (key === "space") spacechars = val;
+    else if (key === "tab") tabchars = val;
+    else if (key === "ispace") indentspacechars = val;
+    else if (key === "itab") indenttabchars = val;
+  }
+  // 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;
+  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;
+  const tabErrorFg = hltaberrors && colorscheme?.styles?.has("tab-error")
+    ? colorscheme.get("tab-error")?.fg
+    : null;
+  const indentCharFg = colorscheme?.styles?.has("indent-char")
+    ? colorscheme.get("indent-char")?.fg
     : null;
+  const colorcolumn = Number(buf.Settings?.colorcolumn ?? 0) | 0;
+  const colorColumnBg = colorcolumn > 0 && colorscheme?.styles?.has("color-column")
+    ? colorscheme.get("color-column")?.fg
+    : null;
+  const tabsize = buf.Settings?.tabsize ?? DEFAULT_SETTINGS.tabsize;
+
+  // 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) => {
+    const sy = m.Start?.Y ?? 0, ey = m.End?.Y ?? 0;
+    return sy <= lineNo && ey >= lineNo;
+  });
+  const inMessageAt = (charIdx) => {
+    for (const m of lineMessages) {
+      const sY = m.Start?.Y ?? 0, sX = m.Start?.X ?? 0;
+      const eY = m.End?.Y ?? 0, eX = m.End?.X ?? 0;
+      const ge = lineNo > sY || (lineNo === sY && charIdx >= sX);
+      const lt = lineNo < eY || (lineNo === eY && charIdx < eX);
+      if (ge && lt) return true;
+    }
+    return false;
+  };
 
   let changeIndex = 0;
   let searchIdx = 0;
   let i = scrollX;
   while (i < raw.length && width < maxWidth) {
-    const cp = raw.codePointAt(i);
     const unit = displayUnitAt(raw, i);
     const ch = unit.text;
     const charLen = unit.length;
@@ -6071,16 +6332,30 @@ function renderHighlightedCells(buf, lineNo, scrollX, maxWidth, colorscheme, sel
     while (changeIndex + 1 < changes.length && i >= changes[changeIndex + 1][0]) changeIndex++;
     const group = changes[changeIndex]?.[1] ?? "default";
     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;
+    let preservebg = syntaxStyle.bg !== undefined && syntaxStyle.bg !== defBg;
+    let baseStyle = (cursorLineBg && !preservebg) ? { ...syntaxStyle, bg: cursorLineBg } : syntaxStyle;
     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;
+
+    // tab-error in leading whitespace
+    let style = baseStyle;
+    const inLeading = i < leadingwsEnd;
+    if (tabErrorFg != null && inLeading) {
+      if ((tabstospaces && ch === "\t") || (!tabstospaces && ch === " ")) {
+        style = { ...style, bg: tabErrorFg };
+        preservebg = true;
+      }
+    }
+    if (trailingWsColor != null && i >= trailingWsIdx) {
+      style = { ...style, bg: trailingWsColor };
+      preservebg = true;
+    }
     if (inSearch) {
       const searchStyle = colorscheme?.styles?.has("hlsearch") ? colorscheme.get("hlsearch") : null;
-      style = searchStyle ?? { ...baseStyle, reverse: !baseStyle.reverse };
+      style = searchStyle ?? { ...(colorscheme?.defaultStyle ?? {}), reverse: true };
+      if ((style.bg ?? "default") !== defBg) preservebg = true;
     }
     if (braceMatched) {
       if ((buf.Settings?.matchbracestyle ?? DEFAULT_SETTINGS.matchbracestyle) === "highlight") {
@@ -6091,22 +6366,73 @@ function renderHighlightedCells(buf, lineNo, scrollX, maxWidth, colorscheme, sel
       }
     }
     if (selected) {
-      style = { ...style, reverse: !style.reverse };
+      const selectionStyle = colorscheme?.styles?.has("selection") ? colorscheme.get("selection") : null;
+      style = selectionStyle ?? { ...(colorscheme?.defaultStyle ?? {}), reverse: true };
+    }
+    if (lineMessages.length > 0 && inMessageAt(i)) {
+      style = { ...style, underline: true };
+    }
+
+    // Visualize whitespace
+    let displayCh = ch;
+    let useIndentCharFg = false;
+    if (ch === " ") {
+      // Go bufwindow.go:554-559: ispace only kicks in at tabsize boundaries (indent guide).
+      const visualCol = scrollVisualCol + width;
+      const useIspace = inLeading && indentspacechars && (visualCol % tabsize === 0);
+      const candidate = useIspace ? indentspacechars : spacechars;
+      if (candidate && candidate !== " ") {
+        displayCh = candidate[0] ?? " ";
+        useIndentCharFg = true;
+      }
+    } else if (ch === "\t") {
+      const candidate = (inLeading && indenttabchars) ? indenttabchars : tabchars;
+      if (candidate && candidate !== " ") {
+        displayCh = candidate[0] ?? " ";
+        useIndentCharFg = true;
+      } else {
+        displayCh = " ";
+      }
     }
+    if (useIndentCharFg && indentCharFg != null) {
+      style = { ...style, fg: indentCharFg };
+    }
+
+    const ccAt = (visualCol) => {
+      if (colorColumnBg == null || preservebg) return null;
+      return visualCol === colorcolumn ? colorColumnBg : null;
+    };
+
     if (ch === "\t") {
-      const spaces = Math.min(DEFAULT_SETTINGS.tabsize, maxWidth - width);
-      for (let j = 0; j < spaces; j++) cells.push({ ch: " ", style });
-      width += spaces;
+      const spaces = Math.min(tabsize, maxWidth - width);
+      for (let j = 0; j < spaces; j++) {
+        const visualCol = scrollVisualCol + width;
+        const cellCh = j === 0 ? displayCh : " ";
+        const ccBg = ccAt(visualCol);
+        const cellStyle = ccBg != null ? { ...style, bg: ccBg } : style;
+        cells.push({ ch: cellCh, style: cellStyle });
+        width++;
+      }
     } else if (w > 0 && width + w <= maxWidth) {
-      cells.push({ ch, style, width: w });
+      const visualCol = scrollVisualCol + width;
+      const ccBg = ccAt(visualCol);
+      const cellStyle = ccBg != null ? { ...style, bg: ccBg } : style;
+      cells.push({ ch: displayCh, style: cellStyle, width: w });
       width += w;
     }
     i += charLen;
   }
-  // Fill rest of line with cursorline background
-  if (cursorLineBg) {
-    const padStyle = { ...(colorscheme?.defaultStyle ?? {}), bg: cursorLineBg };
-    while (width < maxWidth) { cells.push({ ch: " ", style: padStyle }); width++; }
+  // Trailing fill: cursor-line bg and color-column always apply (Go bufwindow.go:807-826)
+  while (width < maxWidth) {
+    const visualCol = scrollVisualCol + width;
+    let padStyle = cursorLineBg
+      ? { ...(colorscheme?.defaultStyle ?? {}), bg: cursorLineBg }
+      : (colorscheme?.defaultStyle ?? {});
+    if (colorColumnBg != null && visualCol === colorcolumn) {
+      padStyle = { ...padStyle, bg: colorColumnBg };
+    }
+    cells.push({ ch: " ", style: padStyle });
+    width++;
   }
   return cells;
 }
@@ -6373,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)