bunmicro 0.8.3 → 0.9.1

package/src/highlight/parser.js

@@ -29,11 +29,12 @@ export class SyntaxHeader {
 }
 
 export class SyntaxDefinition {
-  constructor(header, source) {
+  constructor(header, source, text = "") {
     this.header = header;
     this.filetype = header.filetype;
     this.source = source;
     this.rules = parseRules(source.rules ?? []);
+    this.autocompleteWords = scanAutocompleteWordsFromText(text);
   }
 }
 
@@ -45,15 +46,27 @@ export async function loadSyntaxDefinitions(runtime) {
 
   const definitions = [];
   for (const file of runtime.list(1)) {
-    try{
-      const source = Bun.YAML.parse(await file.text());
-      const header = headers.get(file.name) ?? parseHeaderYaml(source);
-      definitions.push(new SyntaxDefinition(header, source));
-    }catch(e){
-      console.error("Failed to parse syntax yaml:",file.name)
-      console.error("  Will not highlight this kind of file")
-      console.error("  @ loadSyntaxDefinitions ")
+    let text = "";
+    try {
+      text = await file.text();
+    } catch (e) {
+      console.error("Failed to read syntax yaml:", file.name);
+      console.error("  Will not highlight this kind of file");
+      console.error("  @ loadSyntaxDefinitions ");
+      continue;
     }
+
+    let source = null;
+    try {
+      source = Bun.YAML.parse(text);
+    } catch (e) {
+      console.error("Failed to parse syntax yaml:", file.name);
+      console.error("  Will not highlight this kind of file");
+      console.error("  @ loadSyntaxDefinitions ");
+    }
+
+    const header = headers.get(file.name) ?? (source ? parseHeaderYaml(source) : parseHeaderTextFallback(text, file.name));
+    definitions.push(new SyntaxDefinition(header, source ?? { rules: [] }, text));
   }
   return definitions;
 }
@@ -86,6 +99,61 @@ export function parseHeaderYaml(source) {
   });
 }
 
+function parseHeaderTextFallback(text, fileName = "") {
+  const source = String(text ?? "");
+  const fallbackType = String(fileName).replace(/\.ya?ml$/i, "");
+  const filetype = rawYamlScalar(source.match(/^filetype:[ \t]*(.*)$/m)?.[1]) || fallbackType;
+  return new SyntaxHeader({
+    filetype,
+    filename: rawYamlDetectScalar(source, "filename"),
+    header: rawYamlDetectScalar(source, "header"),
+    signature: rawYamlDetectScalar(source, "signature"),
+  });
+}
+
+function rawYamlDetectScalar(text, key) {
+  const detect = text.match(/^detect:[ \t]*(?:#.*)?(?:\r?\n)((?:[ \t]+[^\n]*\r?\n?)*)/m)?.[1] ?? "";
+  return rawYamlScalar(detect.match(new RegExp(`^[ \t]+${key}:[ \t]*(.*)$`, "m"))?.[1]);
+}
+
+function rawYamlScalar(value) {
+  if (value == null) return "";
+  let out = String(value).trim();
+  if (!out) return "";
+  if (out.startsWith("\"") && out.endsWith("\"")) {
+    try { return JSON.parse(out); } catch { return out.slice(1, -1); }
+  }
+  if (out.startsWith("'") && out.endsWith("'")) return out.slice(1, -1).replaceAll("''", "'");
+  return out;
+}
+
+function scanAutocompleteWordsFromText(text) {
+  const source = String(text ?? "");
+  const words = [];
+  const seen = new Set();
+  let i = 0;
+  while (i < source.length) {
+    if (!isSyntaxWordChar(source[i])) { i++; continue; }
+    let j = i;
+    while (j < source.length && isSyntaxWordChar(source[j])) j++;
+    const word = source.slice(i, j);
+    if (!seen.has(word)) {
+      seen.add(word);
+      words.push(word);
+    }
+    i = j;
+  }
+  return words;
+}
+
+function isSyntaxWordChar(ch) {
+  if (!ch) return false;
+  const cp = ch.codePointAt(0);
+  if ((cp >= 65 && cp <= 90) || (cp >= 97 && cp <= 122) || (cp >= 48 && cp <= 57) || cp === 95) return true;
+  if (cp <= 127) return false;
+  return /\p{L}|\p{N}/u.test(ch);
+}
+
 function parseRules(rules) {
   return rules.map((rule) => parseRule(rule)).filter(Boolean);
 }

package/src/index.js

@@ -190,25 +190,79 @@ function isWideCodePoint(cp) {
     (cp >= 0x1F004 && cp <= 0x1F0CF) ||
     (cp >= 0x1F18F && cp <= 0x1F19A) ||
     (cp >= 0x1F200 && cp <= 0x1F2FF) ||
-    (cp >= 0x1F300 && cp <= 0x1F64F) ||
-    (cp >= 0x1F900 && cp <= 0x1F9FF) ||
+    (cp >= 0x1F300 && cp <= 0x1FAFF) ||
     (cp >= 0x20000 && cp <= 0x2FFFD) ||
     (cp >= 0x30000 && cp <= 0x3FFFD)
   );
 }
 
+function isZeroWidthCodePoint(cp) {
+  return (
+    cp === 0x200D ||
+    (cp >= 0x0300 && cp <= 0x036F) ||
+    (cp >= 0x1AB0 && cp <= 0x1AFF) ||
+    (cp >= 0x1DC0 && cp <= 0x1DFF) ||
+    (cp >= 0x20D0 && cp <= 0x20FF) ||
+    (cp >= 0xFE00 && cp <= 0xFE0F) ||
+    (cp >= 0xFE20 && cp <= 0xFE2F) ||
+    (cp >= 0xE0100 && cp <= 0xE01EF)
+  );
+}
+
 function charWidth(ch) {
   if (!ch) return 0;
   const cp = ch.codePointAt(0);
   if (cp === 9) return DEFAULT_SETTINGS.tabsize;
-  if (cp < 32 || (cp >= 0x7f && cp < 0xa0)) return 0;
+  if (cp < 32 || (cp >= 0x7f && cp < 0xa0) || isZeroWidthCodePoint(cp)) return 0;
   if (isWideCodePoint(cp)) return 2;
   return 1;
 }
 
+function isEmojiVariationBase(cp) {
+  return (
+    cp === 0x00A9 || cp === 0x00AE ||
+    cp === 0x203C || cp === 0x2049 ||
+    cp === 0x2122 || cp === 0x2139 ||
+    (cp >= 0x2194 && cp <= 0x21AA) ||
+    (cp >= 0x231A && cp <= 0x231B) ||
+    cp === 0x2328 || cp === 0x23CF ||
+    (cp >= 0x23E9 && cp <= 0x23F3) ||
+    (cp >= 0x23F8 && cp <= 0x23FA) ||
+    cp === 0x24C2 ||
+    (cp >= 0x25AA && cp <= 0x25AB) ||
+    cp === 0x25B6 || cp === 0x25C0 ||
+    (cp >= 0x25FB && cp <= 0x25FE) ||
+    (cp >= 0x2600 && cp <= 0x27BF) ||
+    (cp >= 0x2934 && cp <= 0x2935) ||
+    (cp >= 0x2B05 && cp <= 0x2B55) ||
+    cp === 0x3030 || cp === 0x303D ||
+    cp === 0x3297 || cp === 0x3299
+  );
+}
+
+function displayUnitAt(text, idx) {
+  const cp = text.codePointAt(idx);
+  if (cp == null) return { text: "", width: 0, length: 0 };
+  let length = cp > 0xFFFF ? 2 : 1;
+  let unit = String.fromCodePoint(cp);
+  let width = charWidth(unit);
+  const nextCp = text.codePointAt(idx + length);
+  if (nextCp === 0xFE0F && isEmojiVariationBase(cp)) {
+    unit += String.fromCodePoint(nextCp);
+    length += 1;
+    width = 2;
+  }
+  return { text: unit, width, length };
+}
+
 function displayWidth(text) {
   let width = 0;
-  for (const ch of text) width += charWidth(ch);
+  for (let i = 0; i < text.length;) {
+    const unit = displayUnitAt(text, i);
+    if (unit.length <= 0) break;
+    width += unit.width;
+    i += unit.length;
+  }
   return width;
 }
 
@@ -260,6 +314,16 @@ function charIdxForScrollRight(line, cursorX, visibleCols) {
   return i;
 }
 
+function normalizeCharBoundary(line, idx) {
+  idx = clamp(idx, 0, line.length);
+  if (idx > 0 && idx < line.length) {
+    const prev = line.charCodeAt(idx - 1);
+    const cur = line.charCodeAt(idx);
+    if (prev >= 0xD800 && prev <= 0xDBFF && cur >= 0xDC00 && cur <= 0xDFFF) return idx - 1;
+  }
+  return idx;
+}
+
 // --- Softwrap utilities (ported from Go internal/display/softwrap.go) ---
 
 // Returns an array of code-unit indices where each visual row starts.
@@ -581,7 +645,7 @@ class BufferModel {
 
   ensureCursor() {
     this.cursor.y = clamp(this.cursor.y, 0, this.lines.length - 1);
-    this.cursor.x = clamp(this.cursor.x, 0, this.line().length);
+    this.cursor.x = normalizeCharBoundary(this.line(), this.cursor.x);
   }
 
   invalidateHighlightFrom(lineNo = 0, options = {}) {
@@ -1038,6 +1102,13 @@ class BufferModel {
         }
       }
     }
+    const syntaxWords = this.syntaxDefinition?.autocompleteWords ?? [];
+    for (const w of syntaxWords) {
+      if (w.length > wordLen && w.startsWith(word) && !seen.has(w)) {
+        seen.add(w);
+        suggestions.push(w);
+      }
+    }
     if (suggestions.length === 0) return false;
     if (suggestions.length === 1) {
       // Single match: insert suffix directly without entering cycling mode
@@ -1252,6 +1323,7 @@ class TerminalPane {
     this.app = app;
     this.proc = null;
     this.vt = null;
+    this.decoder = new TextDecoder();
   }
 
   open(cols, rows) {
@@ -1269,7 +1341,8 @@ class TerminalPane {
         cols,
         rows,
         data: (_terminal, data) => {
-          const text = decoder.decode(data);
+          const text = this.decoder.decode(data, { stream: true });
+          if (!text) return;
           const responses = this.vt.feed(text);
           for (const resp of responses) this.proc?.terminal?.write(resp);
           this.app.render();
@@ -1464,9 +1537,10 @@ class App {
       const resize = this.screen.updateSize();
       this.rows = resize.rows;
       this.cols = resize.cols;
+      this.layoutEditorArea();
       for (const tab of this.tabs)
         for (const p of tab.panes())
-          if (p.type === "term") p.terminal?.resize(p.w, Math.max(4, p.h));
+          if (p.type === "term") p.terminal?.resize(p.w, Math.max(4, p.h - 1));
       if (!this.shellRunning && !this._alertRunning) this.render();
     });
     process.on("SIGINT", () => {}); // Ctrl+C is handled as copy in handleEvent
@@ -1500,9 +1574,7 @@ class App {
     process.exit(code);
   }
 
-  render() {
-    if (!this.running) return;
-    const tab = this.tab;
+  layoutEditorArea() {
     const promptHeight = this.prompt ? 1 : 0;
     const tabBarHeight = this.tabs.length > 1 ? 1 : 0;
     const keymenuHeight = this.keymenu ? KEYDISPLAY.length : 0;
@@ -1517,15 +1589,40 @@ class App {
     const editorAreaH = Math.max(1, this.rows - 1 - promptHeight - tabBarHeight - keymenuHeight - infoHeight);
     const statusRow = this.rows - promptHeight - 1;
 
+    for (const tab of this.tabs) computeLayout(tab.root, 0, editorAreaTop, this.cols, editorAreaH);
+
+    return {
+      tabBarHeight,
+      keymenuHeight,
+      activeSuggestions,
+      activeSuggestionIdx,
+      activeMessage,
+      suggestionsHeight,
+      messageHeight,
+      statusRow,
+    };
+  }
+
+  render() {
+    if (!this.running) return;
+    const tab = this.tab;
+    const {
+      tabBarHeight,
+      keymenuHeight,
+      activeSuggestions,
+      activeSuggestionIdx,
+      activeMessage,
+      suggestionsHeight,
+      messageHeight,
+      statusRow,
+    } = this.layoutEditorArea();
+
     const defaultStyle = this.context.colorscheme?.defaultStyle ?? {};
     this.screen.fill(" ", defaultStyle);
 
     this.tabRects = [];
     if (tabBarHeight) this.renderTabbar(defaultStyle);
 
-    // Compute pane rects for this tab
-    computeLayout(tab.root, 0, editorAreaTop, this.cols, editorAreaH);
-
     // Center scroll for any buffer restored from savecursor (deferred until layout is known)
     for (const p of tab.panes()) {
       if (p.buffer?._pendingCenterScroll) {
@@ -1649,8 +1746,9 @@ class App {
       if (softwrap) {
         const scrollSloc = { line: buf.scroll.y, row: buf.scroll.row ?? 0 };
         const cursorLine = buf.lines[buf.cursor.y] ?? "";
+        const cursorX = normalizeCharBoundary(cursorLine, buf.cursor.x);
         const cursorBreaks = softwrapBreaks(cursorLine, bufW, wordwrap, tabsize);
-        const cursorSubRow = softwrapRowOfCharIdx(cursorBreaks, buf.cursor.x);
+        const cursorSubRow = softwrapRowOfCharIdx(cursorBreaks, cursorX);
         const cursorSloc = { line: buf.cursor.y, row: cursorSubRow };
         const cursorAbove = cursorSloc.line < scrollSloc.line ||
           (cursorSloc.line === scrollSloc.line && cursorSloc.row < scrollSloc.row);
@@ -1659,10 +1757,12 @@ class App {
           : slocDiff(buf.lines, scrollSloc, cursorSloc, bufW, wordwrap, tabsize);
         cursorRow = p.y + visualRowOffset;
         const segStart = cursorBreaks[cursorSubRow] ?? 0;
-        cursorCol = p.x + gutterW + displayWidth(cursorLine.slice(segStart, buf.cursor.x));
+        cursorCol = p.x + gutterW + displayWidth(cursorLine.slice(segStart, cursorX));
       } else {
+        const line = buf.line();
+        const cursorX = normalizeCharBoundary(line, buf.cursor.x);
         cursorRow = p.y + buf.cursor.y - buf.scroll.y;
-        cursorCol = p.x + gutterW + displayWidth(buf.line().slice(buf.scroll.x, buf.cursor.x));
+        cursorCol = p.x + gutterW + displayWidth(line.slice(buf.scroll.x, cursorX));
       }
 
       const cursorVisible = cursorRow >= p.y && cursorRow < p.y + p.h && cursorCol >= p.x && cursorCol < p.x + p.w;
@@ -1891,11 +1991,16 @@ class App {
       for (let col = 0; col < Math.min(pane.w, vt.cols); col++) {
         const cell = vtRow[col];
         if (!cell) continue;
-        this.screen.setContent(pane.x + col, pane.y + 1 + row, cell.ch || " ", {
+        const style = {
           fg: cell.fg, bg: cell.bg,
           bold: cell.bold, italic: cell.italic,
           underline: cell.underline, reverse: cell.reverse,
-        });
+        };
+        if (cell.filler) {
+          this.screen.setFillerContent(pane.x + col, pane.y + 1 + row, style);
+          continue;
+        }
+        this.screen.setContent(pane.x + col, pane.y + 1 + row, cell.ch || " ", style, cell.combining ?? []);
       }
     }
     // Show VT cursor only when live (not scrolled back) and active
@@ -2316,6 +2421,7 @@ class App {
     switch (seq) {
       case "escape": {
         this.pane.selection = null;
+        this._markSelStart = null;
         if (buf) buf.searchPattern = "";
         const count = forceRehighlightDirtyLongLines(buf, this);
         if (count > 0) this.message = `Rehighlighted ${count} long line${count === 1 ? "" : "s"}`;
@@ -2620,6 +2726,20 @@ class App {
       case "alt-down":
         await runAction("MoveLinesDown", this);
         break;
+      case "alt-d": //DedentSelection
+        await runAction("OutdentSelection", this);
+        break;
+      case "alt-s": { //Mark selection start / extend selection to mark
+        if (!this._markSelStart) {
+          this._markSelStart = { ...buf.cursor };
+          this.message = "selectionStart, ESC:cancel";
+        } else {
+          this.pane.selection = { start: { ...this._markSelStart }, end: { ...buf.cursor } };
+          buf.cursor = { ...buf.cursor };
+          this.message = "selectionEnd, ESC:cancel";
+        }
+        break;
+      }
       case "alt-p": //PreviousTab
         await runAction("PreviousTab", this);
         break;
@@ -5285,8 +5405,11 @@ function renderHighlightedCells(buf, lineNo, scrollX, maxWidth, colorscheme, sel
   let i = scrollX;
   while (i < raw.length && width < maxWidth) {
     const cp = raw.codePointAt(i);
-    const ch = String.fromCodePoint(cp);
-    const charLen = cp > 0xFFFF ? 2 : 1;
+    const unit = displayUnitAt(raw, i);
+    const ch = unit.text;
+    const charLen = unit.length;
+    const w = unit.width;
+    if (charLen <= 0) break;
     while (changeIndex + 1 < changes.length && i >= changes[changeIndex + 1][0]) changeIndex++;
     const group = changes[changeIndex]?.[1] ?? "default";
     const syntaxStyle = colorscheme?.get(group) ?? colorscheme?.defaultStyle ?? {};
@@ -5311,13 +5434,12 @@ function renderHighlightedCells(buf, lineNo, scrollX, maxWidth, colorscheme, sel
     if (selected) {
       style = { ...style, reverse: !style.reverse };
     }
-    const w = charWidth(ch);
     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;
     } else if (w > 0 && width + w <= maxWidth) {
-      cells.push({ ch, style, wide: w === 2 });
+      cells.push({ ch, style, width: w });
       width += w;
     }
     i += charLen;
@@ -5333,20 +5455,29 @@ function renderHighlightedCells(buf, lineNo, scrollX, maxWidth, colorscheme, sel
 function putText(screen, x, y, text, style = null, maxWidth = Infinity) {
   let col = x;
   let width = 0;
-  for (const ch of String(text)) {
+  const str = String(text);
+  for (let i = 0; i < str.length;) {
     if (width >= maxWidth) break;
+    const unit = displayUnitAt(str, i);
+    const ch = unit.text;
+    const w = unit.width;
+    if (unit.length <= 0) break;
     if (ch === "\t") {
       const spaces = Math.min(DEFAULT_SETTINGS.tabsize, maxWidth - width);
       for (let i = 0; i < spaces; i++) screen.setContent(col++, y, " ", style);
       width += spaces;
+      i += unit.length;
+      continue;
+    }
+    if (w <= 0 || width + w > maxWidth) {
+      i += unit.length;
       continue;
     }
-    const w = charWidth(ch);
-    if (w <= 0 || width + w > maxWidth) continue;
     screen.setContent(col, y, ch, style);
     if (w === 2) screen.setFillerContent(col + 1, y, style);
     col += w;
     width += w;
+    i += unit.length;
   }
   return col;
 }
@@ -5356,7 +5487,7 @@ function putCells(screen, x, y, cells, maxWidth = Infinity) {
   let width = 0;
   for (const cell of cells) {
     if (width >= maxWidth) break;
-    const w = charWidth(cell.ch);
+    const w = cell.width ?? charWidth(cell.ch);
     if (w <= 0 || width + w > maxWidth) continue;
     screen.setContent(col, y, cell.ch, cell.style);
     if (w === 2) screen.setFillerContent(col + 1, y, cell.style);

package/src/plugins/js-bridge.js

@@ -180,6 +180,11 @@ function registerBuiltinActions() {
       buf.modified = true;
     }
   });
+  // Aliases for OutdentSelection / OutdentLine
+  reg("DedentSelection",   (app) => ACTIONS.get("OutdentSelection")(app));
+  reg("UnindentSelection", (app) => ACTIONS.get("OutdentSelection")(app));
+  reg("DedentLine",        (app) => ACTIONS.get("OutdentLine")(app));
+  reg("UnindentLine",      (app) => ACTIONS.get("OutdentLine")(app));
 
   // Editing
   reg("Backspace",          (app) => app.buffer?.backspace());

package/src/screen/screen.js

@@ -59,7 +59,19 @@ export class Screen {
     let out = "\x1b[?25l";
     let activeStyleKey = null;
     for (const { x, y, cell } of changes) {
-      if (cell.filler) continue; // right-half of a wide char; the char itself already covers this column
+      if (cell.filler) continue; // right-half of a wide char; the base cell covers this column
+      // If this is a wide char (next cell is its filler), clear the filler column with
+      // default style first. On narrow-emoji terminals this leaves a default-bg blank
+      // at the right-half column instead of stale cursor-line / syntax background, so
+      // the area next to the glyph doesn't look like a colored block "covering" it.
+      // On wide-emoji terminals the glyph's right half overwrites the blank harmlessly.
+      const nextCell = this.cells.getContent(x + 1, y);
+      if (nextCell?.filler) {
+        out += this.move(y + 1, x + 2);
+        out += styleToAnsi({});
+        activeStyleKey = "";
+        out += " ";
+      }
       out += this.move(y + 1, x + 1);
       if (cell.styleKey !== activeStyleKey) {
         out += styleToAnsi(cell.style ?? {});

package/src/screen/vt100.js

@@ -8,7 +8,7 @@ const ANSI_COLORS = [
 ];
 
 function blankCell() {
-  return { ch: " ", fg: "default", bg: "default", bold: false, italic: false, underline: false, reverse: false };
+  return { ch: " ", combining: [], filler: false, fg: "default", bg: "default", bold: false, italic: false, underline: false, reverse: false };
 }
 
 function findCSIEnd(str, start) {
@@ -24,6 +24,52 @@ function toHex2(n) {
   return ((n ?? 0) & 0xFF).toString(16).padStart(2, "0");
 }
 
+function isZeroWidthCodePoint(cp) {
+  return (
+    cp === 0x200D ||
+    (cp >= 0x0300 && cp <= 0x036F) ||
+    (cp >= 0x1AB0 && cp <= 0x1AFF) ||
+    (cp >= 0x1DC0 && cp <= 0x1DFF) ||
+    (cp >= 0x20D0 && cp <= 0x20FF) ||
+    (cp >= 0xFE00 && cp <= 0xFE0F) ||
+    (cp >= 0xFE20 && cp <= 0xFE2F) ||
+    (cp >= 0xE0100 && cp <= 0xE01EF)
+  );
+}
+
+function isWideCodePoint(cp) {
+  if (cp < 0x1100) return false;
+  return (
+    cp <= 0x115F ||
+    cp === 0x2329 || cp === 0x232A ||
+    (cp >= 0x2E80 && cp <= 0x303E) ||
+    (cp >= 0x3040 && cp <= 0x33FF) ||
+    (cp >= 0x3400 && cp <= 0x4DBF) ||
+    (cp >= 0x4E00 && cp <= 0xA4C6) ||
+    (cp >= 0xA960 && cp <= 0xA97C) ||
+    (cp >= 0xAC00 && cp <= 0xD7A3) ||
+    (cp >= 0xF900 && cp <= 0xFAFF) ||
+    (cp >= 0xFE10 && cp <= 0xFE19) ||
+    (cp >= 0xFE30 && cp <= 0xFE4F) ||
+    (cp >= 0xFF01 && cp <= 0xFF60) ||
+    (cp >= 0xFFE0 && cp <= 0xFFE6) ||
+    (cp >= 0x1B000 && cp <= 0x1B0FF) ||
+    (cp >= 0x1F004 && cp <= 0x1F0CF) ||
+    (cp >= 0x1F18F && cp <= 0x1F19A) ||
+    (cp >= 0x1F200 && cp <= 0x1F2FF) ||
+    (cp >= 0x1F300 && cp <= 0x1FAFF) ||
+    (cp >= 0x20000 && cp <= 0x2FFFD) ||
+    (cp >= 0x30000 && cp <= 0x3FFFD)
+  );
+}
+
+function charWidth(ch) {
+  if (!ch) return 0;
+  const cp = ch.codePointAt(0);
+  if (cp < 32 || (cp >= 0x7f && cp < 0xa0) || isZeroWidthCodePoint(cp)) return 0;
+  return isWideCodePoint(cp) ? 2 : 1;
+}
+
 export class VT100 {
   constructor(cols, rows) {
     this.cols = Math.max(1, cols);
@@ -56,10 +102,7 @@ export class VT100 {
     return this.cells[this._idx(x, y)];
   }
 
-  _setCell(x, y, ch) {
-    const cell = this._cell(x, y);
-    if (!cell) return;
-    cell.ch = ch;
+  _copyStyleTo(cell) {
     cell.fg = this.sgr.fg;
     cell.bg = this.sgr.bg;
     cell.bold = this.sgr.bold;
@@ -68,11 +111,54 @@ export class VT100 {
     cell.reverse = this.sgr.reverse;
   }
 
-  _clearCell(x, y) {
+  _clearCellRaw(x, y) {
     const cell = this._cell(x, y);
     if (cell) Object.assign(cell, blankCell());
   }
 
+  _breakWideAt(x, y) {
+    const cell = this._cell(x, y);
+    if (!cell) return;
+    if (cell.filler) this._clearCellRaw(x - 1, y);
+    if (x + 1 < this.cols && this._cell(x + 1, y)?.filler) this._clearCellRaw(x + 1, y);
+  }
+
+  _setCell(x, y, ch, width = 1) {
+    if (width === 0) {
+      const targetX = this.cx > 0 ? this.cx - 1 : 0;
+      const cell = this._cell(targetX, this.cy);
+      if (cell && !cell.filler) cell.combining.push(ch);
+      return;
+    }
+    if (width > 1 && x >= this.cols - 1) {
+      this.cx = 0;
+      this._lineFeed();
+      x = this.cx;
+      y = this.cy;
+    }
+    this._breakWideAt(x, y);
+    if (width > 1) this._breakWideAt(x + 1, y);
+    const cell = this._cell(x, y);
+    if (!cell) return;
+    cell.ch = ch;
+    cell.combining = [];
+    cell.filler = false;
+    this._copyStyleTo(cell);
+    if (width > 1) {
+      const filler = this._cell(x + 1, y);
+      if (filler) {
+        Object.assign(filler, blankCell());
+        filler.filler = true;
+        this._copyStyleTo(filler);
+      }
+    }
+  }
+
+  _clearCell(x, y) {
+    this._breakWideAt(x, y);
+    this._clearCellRaw(x, y);
+  }
+
   _clearLineFrom(x, y) {
     for (let i = x; i < this.cols; i++) this._clearCell(i, y);
   }
@@ -198,12 +284,15 @@ export class VT100 {
         i++; // SO/SI charset switch, ignore
       } else if (code >= 0x20) {
         // Printable
-        this._setCell(this.cx, this.cy, ch);
-        this.cx++;
+        const cp = data.codePointAt(i);
+        const rune = String.fromCodePoint(cp);
+        const width = charWidth(rune);
+        this._setCell(this.cx, this.cy, rune, width);
+        this.cx += width;
         if (this.cx >= this.cols) {
           this.cx = 0; this._lineFeed();
         }
-        i++;
+        i += cp > 0xFFFF ? 2 : 1;
       } else {
         i++; // other control: skip
       }

package/todo.txt

@@ -30,6 +30,10 @@ Current handoff notes
     - Matchbrace highlights (), {}, [] and statusline column click cycles between matched braces when cursor is on a matched brace.
     - Ctrl-C/Ctrl-X/Ctrl-V/Ctrl-Y work for line and selection clipboard flows; external clipboard failures fall back to the internal register.
     - Copy/cut/paste and similar status messages render on a standalone info row above the statusline.
+[x] term pane Unicode input/output support:
+    - PTY output now uses a streaming UTF-8 decoder so multi-byte Unicode split across chunks is preserved.
+    - VT100 printable handling iterates by code point, stores combining marks on the base cell, and uses filler cells for wide CJK/emoji output.
+    - Terminal pane rendering skips filler cells and emits combining marks through Screen.SetContent.
 [x] replace/replaceall commands aligned with Go behavior:
     - Flags: -a (replace all at once), -l (literal/no-regex, uses RegExp.escape).
     - replace without -a shows interactive Y/N prompt per match (Perform replacement (y,n,esc)).