nexrall-code 0.5.173 → 0.5.174

package/dist/index.js

@@ -153361,7 +153361,17 @@ function renderInputSlices(line, cursorPos) {
 }
 
 // src/ui/vimMode.ts
-var initialVim = (mode = "insert") => ({ mode, count: "", op: "", reg: { text: "", linewise: false }, undo: [] });
+var initialVim = (mode = "insert") => ({
+  mode,
+  count: "",
+  op: "",
+  reg: { text: "", linewise: false },
+  undo: [],
+  visual: null,
+  anchor: 0,
+  last: [],
+  pend: []
+});
 var MAX_UNDO = 100;
 var isSpace2 = (c) => /\s/.test(c);
 function nextWordStart(text, pos) {
@@ -153387,32 +153397,89 @@ function clampNormal(text, pos) {
     return ls;
   return p >= le ? prevGraphemeBoundary(text, le) : p;
 }
+function visualRange(text, vim, cursor) {
+  if (!vim.visual)
+    return null;
+  const a = clampNormal(text, vim.anchor), b = clampNormal(text, cursor);
+  const lo = Math.min(a, b), hi = Math.max(a, b);
+  if (vim.visual === "line") {
+    const from = lineStart(text, lo);
+    const le = lineEnd(text, hi);
+    return { from, to: le < text.length ? le + 1 : le, linewise: true };
+  }
+  return { from: lo, to: nextGraphemeBoundary(text, hi) };
+}
+function tokenToKey(tok) {
+  if (tok === "<Esc>")
+    return { char: "", key: { escape: true } };
+  if (tok === "<BS>")
+    return { char: "", key: { backspace: true } };
+  return { char: tok, key: {} };
+}
+function replayKeys(text, cursor, vim, keys, n) {
+  let t2 = text, c = cursor, v = vim;
+  for (let i2 = 0; i2 < n; i2++) {
+    for (const tok of keys) {
+      const { char, key } = tokenToKey(tok);
+      const r2 = handleVimKey(t2, c, v, char, key);
+      t2 = r2.text;
+      c = r2.cursor;
+      v = r2.vim;
+      if (!r2.handled && v.mode === "insert") {
+        if (key.backspace) {
+          const p = prevGraphemeBoundary(t2, c);
+          t2 = t2.slice(0, p) + t2.slice(c);
+          c = p;
+        } else if (char) {
+          t2 = t2.slice(0, c) + char + t2.slice(c);
+          c += char.length;
+        }
+      }
+    }
+  }
+  return { text: t2, cursor: c, vim: v };
+}
 function handleVimKey(text, cursor, vim, char, key) {
   const pass = (v = vim) => ({ text, cursor, vim: v, handled: false });
   const done = (t2, c, v) => ({ text: t2, cursor: c, vim: v, handled: true });
+  const push2 = (v, tok) => ({ ...v, pend: [...v.pend, tok] });
+  const commit = (v) => ({ ...v, last: v.pend, pend: [] });
+  const noChange = (v) => ({ ...v, pend: [] });
   if (vim.mode === "insert") {
     if (key.escape) {
       const c = cursor > 0 ? prevGraphemeBoundary(text, cursor) : 0;
-      return done(text, clampNormal(text, c), { ...vim, mode: "normal", count: "", op: "" });
+      const closed = {
+        ...vim,
+        mode: "normal",
+        count: "",
+        op: "",
+        last: vim.pend.length ? [...vim.pend, "<Esc>"] : vim.last,
+        pend: []
+      };
+      return done(text, clampNormal(text, c), closed);
     }
-    return pass();
+    const typed = !key.ctrl && !key.meta && !key.return && !key.tab && !key.escape && !key.delete && (key.backspace || char.length > 0 && char.length <= 2);
+    const v = typed ? push2(vim, key.backspace ? "<BS>" : char) : vim;
+    return pass(v);
   }
   if (key.escape) {
+    if (vim.visual)
+      return done(text, clampNormal(text, cursor), { ...vim, visual: null, count: "", op: "", pend: [] });
     if (!vim.count && !vim.op)
       return pass();
-    return done(text, clampNormal(text, cursor), { ...vim, count: "", op: "" });
+    return done(text, clampNormal(text, cursor), { ...vim, count: "", op: "", pend: [] });
   }
   if (key.ctrl || key.meta)
     return pass();
   if (key.return || key.tab || key.upArrow || key.downArrow || key.leftArrow || key.rightArrow || key.delete)
     return pass();
   if (key.backspace)
-    return done(text, clampNormal(text, prevGraphemeBoundary(text, cursor)), { ...vim, count: "", op: "" });
+    return done(text, clampNormal(text, prevGraphemeBoundary(text, cursor)), noChange({ ...vim, count: "", op: "" }));
   if (!char || char.length > 2)
     return pass();
   const pos = clampNormal(text, cursor);
   if (/^[1-9]$/.test(char) || char === "0" && vim.count)
-    return done(text, pos, { ...vim, count: vim.count + char });
+    return done(text, pos, push2({ ...vim, count: vim.count + char }, char));
   const n = vim.count ? Math.min(parseInt(vim.count, 10), 999) : 1;
   const clear = { ...vim, count: "", op: "" };
   const pushUndo = (v) => ({ ...v, undo: [...v.undo, { text, cursor: pos }].slice(-MAX_UNDO) });
@@ -153449,9 +153516,69 @@ function handleVimKey(text, cursor, vim, char, key) {
         return null;
     }
   };
+  const vertical = (dir) => {
+    let p = pos;
+    for (let i2 = 0; i2 < n && p !== null; i2++) {
+      const nx = moveVertical({ text, cursor: p }, dir);
+      if (nx === null) {
+        if (i2 === 0)
+          return null;
+        break;
+      }
+      p = nx;
+    }
+    return p === null ? null : clampNormal(text, p);
+  };
+  const cut = (from, to, linewise) => {
+    let nt = text.slice(0, from) + text.slice(to);
+    let nc = from;
+    if (linewise && nt.length && to >= text.length && from > 0) {
+      nt = nt.slice(0, from - 1);
+      nc = lineStart(nt, from - 1);
+    }
+    return { text: nt, cursor: clampNormal(nt, nc) };
+  };
+  if (vim.visual) {
+    const mv = motion(char);
+    if (mv !== null)
+      return done(text, clampNormal(text, mv), noChange(clear));
+    if (char === "j" || char === "k") {
+      const p = vertical(char === "j" ? 1 : -1);
+      if (p === null)
+        return pass(noChange(clear));
+      return done(text, p, noChange(clear));
+    }
+    if (char === "v" || char === "V") {
+      const want = char === "v" ? "char" : "line";
+      return done(text, pos, { ...clear, visual: vim.visual === want ? null : want, pend: [] });
+    }
+    const sel = visualRange(text, vim, pos);
+    const removed = text.slice(sel.from, sel.to);
+    const reg = { text: removed, linewise: !!sel.linewise };
+    if (char === "y")
+      return done(text, clampNormal(text, sel.from), noChange({ ...clear, visual: null, reg }));
+    if (char === "d" || char === "x" || char === "c") {
+      const base = pushUndo({ ...clear, visual: null, reg });
+      const { text: nt, cursor: nc } = cut(sel.from, sel.to, !!sel.linewise);
+      if (char === "c") {
+        const keep = sel.linewise && removed.endsWith("\n") ? "\n" : "";
+        const wt = text.slice(0, sel.from) + keep + text.slice(sel.to);
+        return done(wt, sel.from, { ...base, mode: "insert" });
+      }
+      return done(nt, nc, noChange(base));
+    }
+    if ((char === "p" || char === "P") && vim.reg.text) {
+      const base = pushUndo({ ...clear, visual: null });
+      const body = vim.reg.linewise ? vim.reg.text.replace(/\n$/, "") : vim.reg.text;
+      const nt = text.slice(0, sel.from) + body + text.slice(sel.to);
+      return done(nt, clampNormal(nt, sel.from + Math.max(0, body.length - 1)), noChange(base));
+    }
+    return done(text, pos, noChange(clear));
+  }
   if (vim.op) {
     const op = vim.op;
     let r2 = null;
+    let seq = "";
     if (char === op) {
       let end = pos;
       for (let i2 = 0; i2 < n; i2++) {
@@ -153461,153 +153588,158 @@ function handleVimKey(text, cursor, vim, char, key) {
           break;
       }
       r2 = { from: lineStart(text, pos), to: end, linewise: true };
+      seq = char;
     } else if (char === "w" && op === "c") {
       const e2 = repeat((p) => wordLastChar(text, p));
       r2 = { from: pos, to: nextGraphemeBoundary(text, e2) };
+      seq = char;
     } else {
       const m3 = motion(char);
       if (m3 !== null) {
         const inclusive = char === "e";
-        const to2 = m3;
-        r2 = to2 >= pos ? { from: pos, to: inclusive ? nextGraphemeBoundary(text, to2) : to2 } : { from: to2, to: pos };
+        const to = m3;
+        r2 = to >= pos ? { from: pos, to: inclusive ? nextGraphemeBoundary(text, to) : to } : { from: to, to: pos };
+        seq = char;
       }
     }
+    const recorded = vim.count ? push2(push2(vim, vim.count), seq) : push2(vim, seq);
     if (!r2)
-      return done(text, pos, clear);
-    let { from, to } = r2;
-    if (from === to)
-      return done(text, pos, clear);
-    const removed = text.slice(from, to);
-    const reg = { text: removed, linewise: !!r2.linewise };
+      return done(text, pos, noChange(clear));
+    if (r2.from === r2.to)
+      return done(text, pos, noChange(clear));
+    const removed2 = text.slice(r2.from, r2.to);
+    const opend = { ...clear, visual: null, reg: { text: removed2, linewise: !!r2.linewise }, pend: recorded.pend };
     if (op === "y")
-      return done(text, from === pos ? pos : clampNormal(text, from), { ...clear, reg });
-    let nt = text.slice(0, from) + text.slice(to);
-    let nc = from;
-    if (r2.linewise && op === "d" && nt.length && to >= text.length && from > 0) {
-      nt = nt.slice(0, from - 1);
-      nc = lineStart(nt, from - 1);
-    }
-    if (r2.linewise && op === "c") {
-      const keep = removed.endsWith("\n") ? "\n" : "";
-      nt = text.slice(0, from) + keep + text.slice(to);
-      nc = from;
+      return done(text, r2.from === pos ? pos : clampNormal(text, r2.from), noChange(opend));
+    const { text: nt, cursor: nc } = cut(r2.from, r2.to, !!r2.linewise);
+    if (op === "c") {
+      const keep = r2.linewise && removed2.endsWith("\n") ? "\n" : "";
+      const wt = text.slice(0, r2.from) + keep + text.slice(r2.to);
+      return done(wt, r2.from, { ...pushUndo(opend), mode: "insert" });
     }
-    const base = pushUndo({ ...clear, reg });
-    if (op === "c")
-      return done(nt, nc, { ...base, mode: "insert" });
-    return done(nt, clampNormal(nt, nc), base);
+    return done(nt, nc, noChange(commit(pushUndo(opend))));
   }
   const m2 = motion(char);
   if (m2 !== null)
-    return done(text, clampNormal(text, m2), clear);
+    return done(text, clampNormal(text, m2), noChange(clear));
   if (char === "j" || char === "k") {
-    const dir = char === "j" ? 1 : -1;
-    let p = pos;
-    for (let i2 = 0; i2 < n && p !== null; i2++) {
-      const nx = moveVertical({ text, cursor: p }, dir);
-      if (nx === null) {
-        if (i2 === 0)
-          return pass(clear);
-        break;
-      }
-      p = nx;
-    }
-    return done(text, clampNormal(text, p ?? pos), clear);
+    const p = vertical(char === "j" ? 1 : -1);
+    if (p === null)
+      return pass(noChange(clear));
+    return done(text, p, noChange(clear));
   }
   switch (char) {
     case "d":
     case "c":
     case "y":
-      return done(text, pos, { ...vim, op: char, count: vim.count });
+      return done(text, pos, push2({ ...vim, op: char, count: vim.count }, char));
+    case ".": {
+      if (!vim.last.length)
+        return done(text, pos, noChange(clear));
+      const rep = replayKeys(text, pos, { ...clear, last: vim.last, pend: [] }, vim.last, n);
+      return done(rep.text, clampNormal(rep.text, rep.cursor), { ...rep.vim, last: vim.last, pend: [] });
+    }
+    case "v":
+    case "V":
+      return done(text, pos, noChange({ ...clear, visual: char === "v" ? "char" : "line", anchor: pos }));
     case "i":
-      return done(text, pos, { ...pushUndo(clear), mode: "insert" });
+      return done(text, pos, push2({ ...pushUndo(clear), mode: "insert" }, char));
     case "a":
-      return done(text, text.length && lineEnd(text, pos) > pos ? nextGraphemeBoundary(text, pos) : pos, { ...pushUndo(clear), mode: "insert" });
+      return done(text, text.length && lineEnd(text, pos) > pos ? nextGraphemeBoundary(text, pos) : pos, push2({ ...pushUndo(clear), mode: "insert" }, char));
     case "I": {
       let p = lineStart(text, pos);
       const e2 = lineEnd(text, pos);
       while (p < e2 && isSpace2(text[p]))
         p++;
-      return done(text, p, { ...pushUndo(clear), mode: "insert" });
+      return done(text, p, push2({ ...pushUndo(clear), mode: "insert" }, char));
     }
     case "A":
-      return done(text, lineEnd(text, pos), { ...pushUndo(clear), mode: "insert" });
+      return done(text, lineEnd(text, pos), push2({ ...pushUndo(clear), mode: "insert" }, char));
     case "o": {
       const e2 = lineEnd(text, pos);
-      return done(text.slice(0, e2) + "\n" + text.slice(e2), e2 + 1, { ...pushUndo(clear), mode: "insert" });
+      return done(text.slice(0, e2) + "\n" + text.slice(e2), e2 + 1, push2({ ...pushUndo(clear), mode: "insert" }, char));
     }
     case "O": {
       const s2 = lineStart(text, pos);
-      return done(text.slice(0, s2) + "\n" + text.slice(s2), s2, { ...pushUndo(clear), mode: "insert" });
+      return done(text.slice(0, s2) + "\n" + text.slice(s2), s2, push2({ ...pushUndo(clear), mode: "insert" }, char));
     }
     case "x": {
       const e2 = lineEnd(text, pos);
       if (pos >= e2)
-        return done(text, pos, clear);
+        return done(text, pos, noChange(clear));
       let to = pos;
       for (let i2 = 0; i2 < n && to < e2; i2++)
         to = nextGraphemeBoundary(text, to);
       const nt = text.slice(0, pos) + text.slice(to);
-      return done(nt, clampNormal(nt, pos), { ...pushUndo(clear), reg: { text: text.slice(pos, to), linewise: false } });
+      return done(nt, clampNormal(nt, pos), commit(push2({ ...pushUndo(clear), reg: { text: text.slice(pos, to), linewise: false } }, char)));
     }
     case "X": {
       const s2 = lineStart(text, pos);
       if (pos <= s2)
-        return done(text, pos, clear);
+        return done(text, pos, noChange(clear));
       let from = pos;
       for (let i2 = 0; i2 < n && from > s2; i2++)
         from = prevGraphemeBoundary(text, from);
       const nt = text.slice(0, from) + text.slice(pos);
-      return done(nt, clampNormal(nt, from), { ...pushUndo(clear), reg: { text: text.slice(from, pos), linewise: false } });
+      return done(nt, clampNormal(nt, from), commit(push2({ ...pushUndo(clear), reg: { text: text.slice(from, pos), linewise: false } }, char)));
     }
     case "D":
     case "C": {
       const e2 = lineEnd(text, pos);
       const nt = text.slice(0, pos) + text.slice(e2);
-      const v = { ...pushUndo(clear), reg: { text: text.slice(pos, e2), linewise: false } };
-      return char === "C" ? done(nt, pos, { ...v, mode: "insert" }) : done(nt, clampNormal(nt, pos), v);
+      const v = push2({ ...pushUndo(clear), reg: { text: text.slice(pos, e2), linewise: false } }, char);
+      return char === "C" ? done(nt, pos, { ...v, mode: "insert" }) : done(nt, clampNormal(nt, pos), commit(v));
     }
     case "p":
     case "P": {
       if (!vim.reg.text)
-        return done(text, pos, clear);
-      const v = pushUndo(clear);
+        return done(text, pos, noChange(clear));
+      const v = push2(pushUndo(clear), char);
       if (vim.reg.linewise) {
         const body = vim.reg.text.replace(/\n$/, "");
         if (char === "p") {
           const e2 = lineEnd(text, pos);
           const nt3 = text.slice(0, e2) + "\n" + body + text.slice(e2);
-          return done(nt3, clampNormal(nt3, e2 + 1), v);
+          return done(nt3, clampNormal(nt3, e2 + 1), commit(v));
         }
         const s2 = lineStart(text, pos);
         const nt2 = text.slice(0, s2) + body + "\n" + text.slice(s2);
-        return done(nt2, clampNormal(nt2, s2), v);
+        return done(nt2, clampNormal(nt2, s2), commit(v));
       }
       const at = char === "p" && text.length && lineEnd(text, pos) > pos ? nextGraphemeBoundary(text, pos) : pos;
       const nt = text.slice(0, at) + vim.reg.text + text.slice(at);
-      return done(nt, clampNormal(nt, at + vim.reg.text.length - 1), v);
+      return done(nt, clampNormal(nt, at + vim.reg.text.length - 1), commit(v));
     }
     case "u": {
       const last = vim.undo[vim.undo.length - 1];
       if (!last)
-        return done(text, pos, clear);
-      return done(last.text, clampNormal(last.text, last.cursor), { ...clear, undo: vim.undo.slice(0, -1) });
+        return done(text, pos, noChange(clear));
+      return done(last.text, clampNormal(last.text, last.cursor), noChange({ ...clear, undo: vim.undo.slice(0, -1) }));
     }
     default:
-      return done(text, pos, clear);
+      return done(text, pos, noChange(clear));
   }
 }
+var INSERT_ENTRY = /* @__PURE__ */ new Set(["i", "a", "I", "A", "o", "O", "C"]);
 function handleVimChunk(text, cursor, vim, chunk, key) {
   const chars = [...chunk];
   const plain = !key.escape && !key.ctrl && !key.meta && !key.return && !key.tab && !key.backspace && !key.delete;
-  if (vim.mode !== "normal" || !plain || chars.length < 2 || chars.length > 4)
+  if (vim.mode !== "normal" || !plain || chars.length < 2)
+    return handleVimKey(text, cursor, vim, chunk, key);
+  const insertRun = INSERT_ENTRY.has(chars[0]) && chars.slice(1).every((c2) => c2 >= " " && c2 !== "\x7F");
+  if (chars.length > 4 && !insertRun)
     return handleVimKey(text, cursor, vim, chunk, key);
   let t2 = text, c = cursor, v = vim;
   for (const ch of chars) {
-    const r2 = handleVimKey(t2, c, v, ch, {});
+    const esc = ch === "\x1B";
+    const r2 = handleVimKey(t2, c, v, esc ? "" : ch, esc ? { escape: true } : {});
     t2 = r2.text;
     c = r2.cursor;
     v = r2.vim;
+    if (!r2.handled && v.mode === "insert" && !esc) {
+      t2 = t2.slice(0, c) + ch + t2.slice(c);
+      c += ch.length;
+    }
   }
   return { text: t2, cursor: c, vim: v, handled: true };
 }
@@ -157292,21 +157424,22 @@ function rowsOccupied(text, columns = process.stdout.columns || 80) {
 function reserveBlockRows(previous, showing) {
   return Math.max(0, previous, showing);
 }
-function fillerRowCount(rowsAlreadyPrinted, footerTextValue = "", columns = process.stdout.columns ?? 80, rows = process.stdout.rows) {
+var LIVE_BLOCK_MAX_ROWS = 5;
+function fillerRowCount(rowsAlreadyPrinted, footerTextValue = "", columns = process.stdout.columns ?? 80, rows = process.stdout.rows, reservedRows = 0, headroom = 2) {
   if (!rows)
     return 0;
   const chromeRows = bottomChromeRows({ footerText: footerTextValue, columns });
-  const filler = rows - rowsAlreadyPrinted - chromeRows - 2;
+  const filler = rows - rowsAlreadyPrinted - reservedRows - chromeRows - headroom;
   const MIN_WORTHWHILE_FILLER = 3;
   return filler < MIN_WORTHWHILE_FILLER ? 0 : filler;
 }
-function padToBottom(rowsAlreadyPrinted, footerText2 = "") {
+function padToBottom(rowsAlreadyPrinted, footerText2 = "", sink = (text) => console.log(text)) {
   if (!process.stdout.isTTY)
     return false;
   const filler = fillerRowCount(rowsAlreadyPrinted, footerText2);
   if (filler <= 0)
     return false;
-  console.log("\n".repeat(filler - 1));
+  sink("\n".repeat(filler - 1));
   return true;
 }
 var rowCounter = null;
@@ -168577,6 +168710,7 @@ var App2 = ({ onReady }) => {
   const cursorRef = (0, import_react36.useRef)(0);
   const vimRef = (0, import_react36.useRef)(initialVim("insert"));
   const [vimMode, setVimMode] = (0, import_react36.useState)("insert");
+  const [vimVisual, setVimVisual] = (0, import_react36.useState)(false);
   const setCursorPos = (0, import_react36.useCallback)((next) => {
     const value = typeof next === "function" ? next(cursorRef.current) : next;
     cursorRef.current = value;
@@ -168693,7 +168827,9 @@ var App2 = ({ onReady }) => {
     if (opts?.isBanner)
       bannerChunkRef.current = bufferRef.current.length;
     bufferRef.current.append(text);
-    setItems((prev) => [...prev, { id: idCounter++, content: text, isBanner: opts?.isBanner }]);
+    setItems((prev) => {
+      return [...prev, { id: idCounter++, content: text, isBanner: opts?.isBanner, isFiller: opts?.isFiller }];
+    });
   }, []);
   const bannerRegeneratorRef = (0, import_react36.useRef)(null);
   const setBannerRegenerator = (0, import_react36.useCallback)((fn) => {
@@ -168986,6 +169122,8 @@ var App2 = ({ onReady }) => {
         if (r2.handled) {
           if (r2.vim.mode !== vimRef.current.mode)
             setVimMode(r2.vim.mode);
+          if (!!r2.vim.visual !== !!vimRef.current.visual)
+            setVimVisual(!!r2.vim.visual);
           vimRef.current = r2.vim;
           if (r2.text !== lineRef.current)
             setLine(r2.text);
@@ -169389,20 +169527,32 @@ var App2 = ({ onReady }) => {
     ctrlDArmedAtRef.current = null;
     setHintText(null);
   });
-  const repadBottomChrome = (0, import_react36.useCallback)(() => {
+  const repadBottomChrome = (0, import_react36.useCallback)((pendingRows = 0) => {
     if (!process.stdout.isTTY)
       return;
     if (fullscreenRef.current)
       return;
-    liveReserveRef.current = 0;
     searchReserveRef.current = 0;
     setItems((prev) => {
+      const columns = process.stdout.columns || 80;
       const withoutOldFiller = prev.filter((it) => !it.isFiller);
       const printedRows = withoutOldFiller.reduce(
-        (sum, it) => sum + rowsOccupied(it.content, process.stdout.columns || 80),
+        (sum, it) => sum + rowsOccupied(it.content, columns),
         0
       );
-      const filler = fillerRowCount(printedRows, footerRef.current ? footerText(footerRef.current) : "");
+      const liveRows = liveRef.current ? rowsOccupied(liveRef.current, columns) : 0;
+      const footer2 = footerRef.current ? footerText(footerRef.current) : "";
+      const slack = fillerRowCount(printedRows, footer2, columns, void 0, liveRows, 1);
+      const seed = Math.min(LIVE_BLOCK_MAX_ROWS, slack);
+      liveReserveRef.current = seed;
+      const filler = fillerRowCount(
+        printedRows,
+        footer2,
+        columns,
+        void 0,
+        Math.max(liveRows, seed) + Math.max(0, pendingRows),
+        1
+      );
       if (filler <= 0)
         return withoutOldFiller;
       return [...withoutOldFiller, { id: idCounter++, content: fillerContent(filler), isFiller: true }];
@@ -169442,12 +169592,12 @@ var App2 = ({ onReady }) => {
     repadBottomChrome();
     setStaticKey((k) => k + 1);
   }, [repadBottomChrome]);
-  const collapseStartupPadding = (0, import_react36.useCallback)(async () => {
+  const collapseStartupPadding = (0, import_react36.useCallback)(async (opts) => {
     if (fullscreenRef.current)
       return;
     await inkInstance?.waitUntilRenderFlush();
     process.stdout.write("\x1B[2J\x1B[3J\x1B[H");
-    repadBottomChrome();
+    repadBottomChrome(opts?.pendingRows ?? 0);
     setStaticKey((k) => k + 1);
   }, [repadBottomChrome]);
   const setFullscreen = (0, import_react36.useCallback)(async (on) => {
@@ -169545,6 +169695,7 @@ var App2 = ({ onReady }) => {
   }, []);
   const slices = renderInputSlices(line, cursorPos);
   const shownPrompt = prompt2 ?? (isVimEnabled() && vimMode === "normal" ? paint.yellow("[N] ") : null);
+  const vsel = isVimEnabled() && vimVisual ? visualRange(line, vimRef.current, cursorPos) : null;
   const colorsOn = colorEnabled();
   const inputRowRef = (0, import_react36.useRef)(null);
   const inputMetrics = use_box_metrics_default(inputRowRef);
@@ -169646,7 +169797,7 @@ var App2 = ({ onReady }) => {
         borderRight: false,
         borderDimColor: colorsOn
       }
-    ), /* @__PURE__ */ import_react36.default.createElement(Box_default, { ref: inputRowRef }, /* @__PURE__ */ import_react36.default.createElement(Text, { wrap: "hard" }, /* @__PURE__ */ import_react36.default.createElement(Text, null, promptFor(shownPrompt)), /* @__PURE__ */ import_react36.default.createElement(Text, null, slices.before), /* @__PURE__ */ import_react36.default.createElement(Text, { inverse: true }, slices.atCursor), /* @__PURE__ */ import_react36.default.createElement(Text, null, slices.after))), /* @__PURE__ */ import_react36.default.createElement(
+    ), /* @__PURE__ */ import_react36.default.createElement(Box_default, { ref: inputRowRef }, /* @__PURE__ */ import_react36.default.createElement(Text, { wrap: "hard" }, /* @__PURE__ */ import_react36.default.createElement(Text, null, promptFor(shownPrompt)), vsel ? /* @__PURE__ */ import_react36.default.createElement(import_react36.default.Fragment, null, /* @__PURE__ */ import_react36.default.createElement(Text, null, line.slice(0, vsel.from)), /* @__PURE__ */ import_react36.default.createElement(Text, { inverse: true }, line.slice(vsel.from, vsel.to)), /* @__PURE__ */ import_react36.default.createElement(Text, null, line.slice(vsel.to))) : /* @__PURE__ */ import_react36.default.createElement(import_react36.default.Fragment, null, /* @__PURE__ */ import_react36.default.createElement(Text, null, slices.before), /* @__PURE__ */ import_react36.default.createElement(Text, { inverse: true }, slices.atCursor), /* @__PURE__ */ import_react36.default.createElement(Text, null, slices.after)))), /* @__PURE__ */ import_react36.default.createElement(
       Box_default,
       {
         borderStyle: "single",
@@ -173738,7 +173889,13 @@ ${text}` : "");
   let startupPadded = false;
   if (interactive) {
     await flushInkFrame();
-    startupPadded = padToBottom(stopRowCount(), footerText(currentFooter()));
+    startupPadded = padToBottom(stopRowCount(), footerText(currentFooter()), (text) => {
+      const inkHandle = getInkTerminal();
+      if (inkHandle)
+        inkHandle.print(text, { isFiller: true });
+      else
+        console.log(text);
+    });
   }
   let agentRunning = false;
   const abortSignal = { aborted: false };
@@ -174386,7 +174543,8 @@ ${text}` : "");
     userInput = intent.text;
     if (startupPadded) {
       startupPadded = false;
-      await getInkTerminal().collapseStartupPadding();
+      const pendingRows = !userInput.startsWith("/") && parseBang(userInput) === null ? 1 : 0;
+      await getInkTerminal().collapseStartupPadding({ pendingRows });
     }
     if (userInput.startsWith("/")) {
       const parts = userInput.split(/\s+/);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nexrall-code",
-  "version": "0.5.173",
+  "version": "0.5.174",
   "description": "Nexrall Code — AI coding assistant for your terminal (headless agent for scripts, CI and automation)",
   "keywords": [
     "ai",