jaitus 0.3.13 → 0.3.14

package/src/tui-ink.js

@@ -293,6 +293,13 @@ function Hero({ state, width, height }) {
     room(3) ? h(Box, { marginTop: 1 },
       h(Text, { color: mix(p.bg, p.dim, lineIn) },
         `a coding agent in your terminal  ${g('·', '-')}  v${state.meta.version || ''}`)) : null,
+    // Start-up notices (a service outage or maintenance, a newer version) are transcript
+    // entries, which the welcome hides until the first message; without this they were
+    // printed but never seen. The newest two, one line each.
+    room(5) ? h(Box, { marginTop: 1, flexDirection: 'column' },
+      state.transcript.filter((e) => e.kind === 'notice' && (e.data?.tone === 'warn' || e.data?.tone === 'info')).slice(-2)
+        .map((e, index) => h(Text, { key: index, color: e.data.tone === 'warn' ? p.yellow : p.muted, wrap: 'truncate-end' },
+          `${e.data.tone === 'warn' ? '!' : g('›', '>')} ${String(e.data.text ?? '').replace(/\x1b\[[0-9;]*m/g, '')}`))) : null,
     room(8) ? h(Box, { marginTop: 1, flexDirection: 'column' },
       tips.map(([marker, title, note], index) => {
         const on = Math.max(0, Math.min(1, tipsIn * 3 - index));
@@ -326,19 +333,25 @@ function layoutTranscript(state, width, height, top) {
   // Where each prompt starts, so the sticky header can name the one whose answer is
   // currently on screen rather than always the newest.
   const prompts = [];
+  // The entry each row comes from (the live, streaming entry included) and where each
+  // entry starts — what keeps a scrolled-back view pinned to the line it shows.
+  const rowEntry = [];
+  const entryStart = new Map();
   for (const entry of state.transcript) {
     const built = rowsFor(entry, inner);
     if (!built.length) continue;
-    if (rows.length) { rows.push([]); owners.push(null); }
+    if (rows.length) { rows.push([]); owners.push(null); rowEntry.push(null); }
     if (entry.kind === 'user') prompts.push({ at: rows.length, text: String(entry.data.text || '') });
-    built.forEach((row, i) => { rows.push(row); owners.push({ entry, head: i === 0 }); });
+    entryStart.set(entry.id, rows.length);
+    built.forEach((row, i) => { rows.push(row); owners.push({ entry, head: i === 0 }); rowEntry.push(entry.id); });
   }
   if (state.live && state.live.text) {
     const built = rowsFor(state.live.entry, inner);
     if (built.length) {
-      if (rows.length) { rows.push([]); owners.push(null); }
+      if (rows.length) { rows.push([]); owners.push(null); rowEntry.push(null); }
+      entryStart.set(state.live.entry.id, rows.length);
       rows.push(...built);
-      for (let i = 0; i < built.length; i++) owners.push(null);
+      for (let i = 0; i < built.length; i++) { owners.push(null); rowEntry.push(state.live.entry.id); }
     }
   }
 
@@ -349,6 +362,17 @@ function layoutTranscript(state, width, height, top) {
   // not stuck, it was somewhere off the top of a list that had already ended.
   const maxOffset = Math.max(0, rows.length - height);
   state.maxScroll = maxOffset;
+  // Scrolled back, the view stays on the line it shows while the answer streams in below.
+  // The offset counts rows up from the BOTTOM, so every new line of a streaming answer
+  // used to slide the view down a line: whatever you had scrolled up to read crept away
+  // a few lines a second, and scrolling felt like fighting the screen. Instead the view
+  // is pinned to the entry (and row within it) at its top; the offset is re-derived from
+  // that each frame. A scroll by the user, a width change or returning to live drops the pin.
+  const pin = state._scrollPin;
+  if (state.viewingTranscript && pin && pin.width === width && entryStart.has(pin.entry)) {
+    const wantFirst = entryStart.get(pin.entry) + pin.row;
+    state.transcriptOffset = rows.length - height - wantFirst;
+  }
   const offset = state.viewingTranscript ? clamp(state.transcriptOffset, 0, maxOffset) : 0;
   // Snap the stored offset to what will actually be drawn: this is the only place that
   // knows how many rows exist at this width, so it is the authority, and writing the
@@ -358,6 +382,13 @@ function layoutTranscript(state, width, height, top) {
 
   const end = rows.length - offset;
   const first = Math.max(0, end - height);
+  // Pin to the first visible row that belongs to an entry.
+  state._scrollPin = null;
+  if (state.viewingTranscript && offset > 0) {
+    for (let i = first; i < end; i++) {
+      if (rowEntry[i] != null) { state._scrollPin = { entry: rowEntry[i], row: i - entryStart.get(rowEntry[i]) - (i - first), width }; break; }
+    }
+  }
   const visible = rows.slice(first, end);
   const visibleOwners = owners.slice(first, end);
   // Bottom-anchored: a short conversation sits at the composer, not floating at the top
@@ -610,7 +641,16 @@ function Composer({ state, width }) {
   // The same lines the App measured the composer's height from (composerLayout): the
   // frame height is fixed, so a composer one row taller than it was counted as pushes
   // the whole screen up — that was the header vanishing after a multi-line paste.
-  const { lines, caretLine, caretCol } = composerLayout(state, inner - 2, composed);
+  const layout = composerLayout(state, inner - 2, composed);
+  const { caretLine, caretCol } = layout;
+  // The selected part of the input, drawn inverted like a selection in the transcript.
+  const sel = inputSelection(state);
+  const lines = !sel ? layout.lines : layout.lines.map((row, i) => {
+    const start = layout.starts[i];
+    const from = Math.max(0, sel[0] - start);
+    const to = Math.min(layout.lens[i], sel[1] - start);
+    return to > from ? inverseRange(row, from, to) : row;
+  });
   const placeholder = state.placeholder || 'Describe a change, ask a question, or / for commands';
 
   const borderColor = state.busy ? p.brand : state.menu.length ? p.teal : p.line;
@@ -695,10 +735,17 @@ function splitSpansAtNewlines(spans) {
  */
 function composerLayout(state, width, spans = null) {
   const input = state.input || '';
-  if (!input) return { lines: [[]], caretLine: 0, total: 1 };
+  if (!input) return { lines: [[]], caretLine: 0, caretCol: 0, total: 1, starts: [0], lens: [0] };
   const paragraphs = splitSpansAtNewlines(spans || [{ t: input }]);
   const all = [];
-  let caret = 0;
+  // Where each drawn line starts in `input`, and how long it is. Found by locating each
+  // line's own text in its paragraph rather than assumed: a wrap at a space drops the
+  // space but a hard break inside a long word drops nothing, so "+1 per wrap" put the
+  // caret one character off on every line after a hard break — and a click or a mouse
+  // selection needs the exact offset of every cell.
+  const starts = [];
+  const lens = [];
+  let caret = -1;
   let caretCol = 0;
   let start = 0;                                   // offset of this paragraph in `input`
   const cursor = Math.max(0, Math.min(input.length, state.cursor ?? input.length));
@@ -707,24 +754,45 @@ function composerLayout(state, width, spans = null) {
     // One column is kept spare for the cursor to sit on after a line's last character,
     // so a full line never grows a cell when the cursor reaches its end.
     const rows = para.length ? wrapRow(para, Math.max(4, width - 1)) : [[]];
-    if (cursor >= start && cursor <= start + text.length) {
-      let rowStart = start;
-      let line = rows.length - 1;
-      let col = 0;
-      for (let i = 0; i < rows.length; i++) {
-        const len = rows[i].map((s) => s.t).join('').length;
-        if (cursor <= rowStart + len || i === rows.length - 1) { line = i; col = Math.max(0, Math.min(len, cursor - rowStart)); break; }
-        rowStart += len + 1;                       // + the space the wrap consumed
+    let from = 0;
+    rows.forEach((row, i) => {
+      const rowText = row.map((s) => s.t).join('');
+      const found = rowText ? text.indexOf(rowText, from) : from;
+      const at = found >= 0 ? found : from;
+      const len = rowText.length;
+      starts.push(start + at);
+      lens.push(len);
+      // The caret's line: the first line whose span reaches the cursor (a cursor at a
+      // wrap point sits in the spare cell at the end of the line, as it always has).
+      const lineStart = start + at;
+      if (caret < 0 && cursor >= lineStart && cursor <= lineStart + len) {
+        caret = all.length + i;
+        caretCol = cursor - lineStart;
       }
-      caret = all.length + line;
-      caretCol = col;
+      from = at + len;
+    });
+    // A cursor sitting on a space a wrap consumed: the end of the line before it.
+    if (caret < 0 && cursor >= start && cursor <= start + text.length) {
+      caret = all.length + rows.length - 1;
+      caretCol = lens[lens.length - 1];
     }
     all.push(...rows);
     start += text.length + 1;                      // + the newline
   }
-  if (all.length <= COMPOSER_MAX_LINES) return { lines: all, caretLine: caret, caretCol, total: all.length };
+  if (caret < 0) { caret = all.length - 1; caretCol = lens[lens.length - 1]; }
+  if (all.length <= COMPOSER_MAX_LINES) return { lines: all, caretLine: caret, caretCol, total: all.length, starts, lens };
   const first = Math.max(0, Math.min(caret - COMPOSER_MAX_LINES + 1, all.length - COMPOSER_MAX_LINES));
-  return { lines: all.slice(first, first + COMPOSER_MAX_LINES), caretLine: caret - first, caretCol, total: all.length };
+  return {
+    lines: all.slice(first, first + COMPOSER_MAX_LINES), caretLine: caret - first, caretCol, total: all.length,
+    starts: starts.slice(first, first + COMPOSER_MAX_LINES), lens: lens.slice(first, first + COMPOSER_MAX_LINES),
+  };
+}
+
+/** The selected part of the input as [from, to), or null — the anchor to the cursor. */
+function inputSelection(state) {
+  const a = state.inputAnchor;
+  if (a == null || a === state.cursor) return null;
+  return a < state.cursor ? [a, state.cursor] : [state.cursor, a];
 }
 
 /** A row of spans cut at character `n`: [before, after]. */
@@ -1051,6 +1119,17 @@ function App({ controller }) {
   const state = controller.state;
   // One empty frame after a resize — see onResize.
   if (state.blankFrame) return h(Box, { height: 1 });
+  // Smaller than the layout can fit: say so instead of drawing a frame wider or taller
+  // than the window, which the terminal wraps and scrolls into a heap of half-lines with
+  // the header pushed off the top. Everything comes back as soon as it is bigger.
+  const realCols = size?.columns || process.stdout.columns || 80;
+  const realRows = size?.rows || process.stdout.rows || 24;
+  if (realCols < 30 || realRows < 11) {
+    controller.hits.reset();
+    return h(Box, { width: realCols, height: Math.max(1, realRows - 1), flexDirection: 'column', justifyContent: 'center' },
+      h(Text, { color: p.dim, wrap: 'truncate-end' }, realCols < 22 ? 'Too small' : 'Window too small for Jaitus'),
+      realRows > 2 ? h(Text, { color: p.faint, wrap: 'truncate-end' }, 'Make it at least 30 × 11') : null);
+  }
   const composerRows = CHROME.composerFrame
     + (state.menu.length ? state.menu.length + 1 : 0)
     + Math.max(0, composerTextRows(state, width) - 1)
@@ -1088,6 +1167,17 @@ function App({ controller }) {
   registerLinkHits(layout.visible, layout.screenTop, hits);
   registerHeaderHits(state, width, hits);
   hits.add({ x1: 1, x2: width, y1: height, y2: height, action: { type: 'status' } });
+  // The composer's text, cell by cell, so a click places the cursor and a drag selects —
+  // the transcript was the only selectable text, so nothing typed could be selected or
+  // copied back out. Its border sits right above the status bar; the text starts after
+  // the menu (when open), two columns of border and padding and the two-column prompt.
+  {
+    const top = height - CHROME.status - composerRows + 1;           // the border row
+    const textTop = top + 1 + (state.menu.length ? state.menu.length + 1 : 0);
+    const geo = composerLayout(state, Math.max(16, width - 6) - 2);
+    state._composer = { textTop, textLeft: 6, starts: geo.starts, lens: geo.lens };
+    hits.add({ x1: 2, x2: width - 1, y1: textTop, y2: textTop + geo.lines.length - 1, action: { type: 'composer' } });
+  }
   if (state.menu.length) {
     const menuTop = height - CHROME.status - composerRows + 1;       // inside the composer border
     state.menu.forEach((_item, index) => {
@@ -1215,6 +1305,19 @@ export function createTui({ slashCommands = [], fileProvider = null, meta = {},
     const n = Number(settings?.scrollSpeed);
     return Math.max(1, Math.round((Number.isFinite(n) && n > 0 ? n : 1) * 3));
   };
+  // Wheel acceleration: a slow notch moves one step, a fast spin moves further — up to
+  // five steps a notch. At a flat 3 rows a notch, getting to the top of a long session
+  // took hundreds of notches. `wheelAccel off` keeps every notch the same (the setting
+  // existed and was listed, but nothing read it).
+  let wheelAt = 0;
+  let wheelStreak = 0;
+  const wheelRows = () => {
+    const now = Date.now();
+    wheelStreak = now - wheelAt < 80 ? Math.min(wheelStreak + 1, 12) : 0;
+    wheelAt = now;
+    const accel = settings?.wheelAccel === false ? 1 : 1 + Math.floor(wheelStreak / 3);
+    return scrollStep() * accel;
+  };
 
   /**
    * Coalesce notifications to one per animation frame.
@@ -1289,6 +1392,8 @@ export function createTui({ slashCommands = [], fileProvider = null, meta = {},
   }
 
   function insert(text) {
+    // Typing over a selection replaces it, as in every text field.
+    deleteInputSelection();
     state.input = state.input.slice(0, state.cursor) + text + state.input.slice(state.cursor);
     state.cursor += text.length;
     refreshMenu();
@@ -1298,6 +1403,7 @@ export function createTui({ slashCommands = [], fileProvider = null, meta = {},
   function clearInput() {
     state.input = '';
     state.cursor = 0;
+    state.inputAnchor = null;
     state.menu = [];
     state.menuIndex = -1;
     notifyNow();
@@ -1513,6 +1619,7 @@ export function createTui({ slashCommands = [], fileProvider = null, meta = {},
   function historyMove(direction) {
     if (!state.history.length) return;
     if (state.historyIndex === state.history.length) state.draft = state.input;
+    state.inputAnchor = null;
     state.historyIndex = clamp(state.historyIndex + direction, 0, state.history.length);
     state.input = state.historyIndex === state.history.length ? (state.draft || '') : state.history[state.historyIndex];
     state.cursor = state.input.length;
@@ -1591,11 +1698,85 @@ export function createTui({ slashCommands = [], fileProvider = null, meta = {},
       return;
     }
     state.transcriptOffset = next;
+    state._scrollPin = null;              // the user moved: the next frame pins anew
     state.viewingTranscript = next > 0;
     if (!next) state.newMessages = 0;
     notifyNow();
   }
 
+  // ── selecting text in the composer ──
+  //
+  // The composer is a text field, so it selects like one: drag with the mouse (copied on
+  // release, like the transcript), click to place the cursor, double-click a word,
+  // triple-click everything; Shift with the arrows, Home and End from the keyboard;
+  // Ctrl+C copies, Ctrl+X cuts, and typing, Backspace or Delete replace the selection.
+  // Before this nothing typed could be selected or copied back out of the box at all.
+  let composerPress = false;
+
+  /** The input offset under a screen cell, clamped into the composer's lines. */
+  function inputOffsetAt(point, { through = false } = {}) {
+    const geo = state._composer;
+    if (!geo?.starts?.length) return state.cursor;
+    const n = geo.starts.length;
+    if (point.y < geo.textTop) return geo.starts[0];
+    if (point.y > geo.textTop + n - 1) return geo.starts[n - 1] + geo.lens[n - 1];
+    const i = point.y - geo.textTop;
+    // `through`: a drag to the right covers the character under the pointer too, as a
+    // terminal's own selection does — otherwise the last letter was always left out.
+    return geo.starts[i] + clamp(point.x - geo.textLeft + (through ? 1 : 0), 0, geo.lens[i]);
+  }
+
+  // A paste or image chip is one object: a selection that cuts through one takes all of it.
+  function snapToChips(from, to) {
+    for (const m of state.input.matchAll(/\[#\d+ pasted [^\]]*\]|\[Image #\d+\]/g)) {
+      const a = m.index;
+      const b = a + m[0].length;
+      if (from > a && from < b) from = a;
+      if (to > a && to < b) to = b;
+    }
+    return [from, to];
+  }
+
+  function selectedInputText() {
+    const sel = inputSelection(state);
+    return sel ? state.input.slice(...snapToChips(sel[0], sel[1])) : '';
+  }
+
+  /** Remove the selected part of the input. True when there was one. */
+  function deleteInputSelection() {
+    const sel = inputSelection(state);
+    state.inputAnchor = null;
+    if (!sel) return false;
+    const [from, to] = snapToChips(sel[0], sel[1]);
+    for (const m of state.input.slice(from, to).matchAll(/\[#(\d+) pasted [^\]]*\]|\[Image #(\d+)\]/g)) dropPaste(m);
+    state.input = state.input.slice(0, from) + state.input.slice(to);
+    state.cursor = from;
+    refreshMenu();
+    return true;
+  }
+
+  async function copyInputSelection({ cut = false } = {}) {
+    const text = selectedInputText();
+    if (!text) return false;
+    const ok = await (state.onCopy ? state.onCopy(text) : Promise.resolve(false));
+    if (ok && cut) deleteInputSelection();
+    flash(ok ? `${cut ? 'Cut' : 'Copied'} ${text.length} character${text.length === 1 ? '' : 's'}` : 'Nothing could copy it — no clipboard tool found', ok ? 'ok' : 'warn', 1600);
+    notifyNow();
+    return ok;
+  }
+
+  /**
+   * Move the cursor to `to`. With Shift the selection grows from where it started;
+   * without it any selection goes.
+   */
+  function moveCursor(to, shift) {
+    if (shift) { if (state.inputAnchor == null) state.inputAnchor = state.cursor; }
+    else state.inputAnchor = null;
+    state.cursor = clamp(to, 0, state.input.length);
+    if (state.inputAnchor === state.cursor) state.inputAnchor = null;
+    return notifyNow();
+  }
+
   /** Every screen cell between two points, as text. */
   function selectedText() {
     const sel = state.selection;
@@ -1827,7 +2008,8 @@ export function createTui({ slashCommands = [], fileProvider = null, meta = {},
         if (state.dialog) return undefined;
         if (state.panel?.palette) { state.panel.index = clamp(state.panel.index + (up ? -1 : 1), 0, Math.max(0, state.panel.options.length - 1)); return notifyNow(); }
         if (state.panel) return scrollPanel(up ? -3 : 3);
-        return scroll(up ? scrollStep() : -scrollStep());
+        const rows = wheelRows();
+        return scroll(up ? rows : -rows);
       }
       // Right-click pastes, as it does in a Windows console — the terminal cannot do it
       // itself while the app has the mouse.
@@ -1836,8 +2018,43 @@ export function createTui({ slashCommands = [], fileProvider = null, meta = {},
         return;
       }
 
+      if (event.kind === 'down' && event.button === 'left' && !state.dialog && !state.panel && hits.at(event.x, event.y)?.action.type === 'composer') {
+        clearSelection();
+        composerPress = true;
+        state.cursor = inputOffsetAt(event);
+        state.inputAnchor = state.cursor;
+        return notifyNow();
+      }
+      if (event.kind === 'drag' && composerPress) {
+        const plain = inputOffsetAt(event);
+        state.cursor = plain >= (state.inputAnchor ?? plain) ? inputOffsetAt(event, { through: true }) : plain;
+        return notifyNow();
+      }
+      if (event.kind === 'up' && composerPress) {
+        composerPress = false;
+        const now = Date.now();
+        const again = lastClick && now - lastClick.at < 450 && lastClick.y === event.y && Math.abs(lastClick.x - event.x) <= 1;
+        clickCount = again ? clickCount + 1 : 1;
+        lastClick = { x: event.x, y: event.y, at: now };
+        if (clickCount >= 3) { state.inputAnchor = 0; state.cursor = state.input.length; }
+        else if (clickCount === 2) {
+          // A word is what you would want to paste: a path, a URL, an identifier.
+          const inWord = (ch) => ch && !/[\s"'`()[\]{}<>,;]/.test(ch);
+          let a = state.cursor; let b = state.cursor;
+          while (inWord(state.input[a - 1])) a -= 1;
+          while (inWord(state.input[b])) b += 1;
+          if (b > a) { state.inputAnchor = a; state.cursor = b; }
+        }
+        if (!inputSelection(state)) { state.inputAnchor = null; return notifyNow(); }
+        notifyNow();
+        // Copied on release, like a selection in the transcript (unless copyOnSelect is off).
+        if (settings?.copyOnSelect !== false) void copyInputSelection();
+        else flash(`${selectedInputText().length} characters selected · Ctrl+C copies them`, 'info', 3000);
+        return;
+      }
       if (event.kind === 'down' && event.button === 'left') {
         clearTimeout(returnToLiveTimer); // a second click: this is a double-click, stay put
+        if (state.inputAnchor != null) { state.inputAnchor = null; notifyNow(); }
         // A press starts a possible drag AND a possible click. Which it was is only
         // known on release, so nothing is dispatched yet — dispatching here made every
         // attempt to select text also press whatever was under the cursor.
@@ -1981,6 +2198,8 @@ export function createTui({ slashCommands = [], fileProvider = null, meta = {},
     // readline keypress objects) can drive the same handler.
     const ctrlKey = key.ctrl ? String(key.name || input || '').toLowerCase() : '';
 
+    if (ctrlKey === 'c' && inputSelection(state)) { void copyInputSelection(); return; }
+    if (ctrlKey === 'x' && inputSelection(state)) { void copyInputSelection({ cut: true }); return; }
     if (ctrlKey === 'c') {
       // With text selected, Ctrl+C copies it (as the README says) — including mid-turn,
       // where it used to stop the turn instead. With copyOnSelect off it was the only way.
@@ -2009,6 +2228,7 @@ export function createTui({ slashCommands = [], fileProvider = null, meta = {},
     if (ctrlKey === 'v') { void pasteFromClipboard(); return; }
     if (key.meta && String(input).toLowerCase() === 'v') { void pasteFromClipboard({ imageOnly: true }); return; }
     if (key.escape) {
+      if (inputSelection(state)) { state.inputAnchor = null; return notifyNow(); }
       if (state.busy) return state.onEscape?.();
       // Esc closes the suggestion menu first, as the README says. It went straight to the
       // rewind countdown, so a message ending in `@word` or `/word` could not be sent —
@@ -2058,25 +2278,25 @@ export function createTui({ slashCommands = [], fileProvider = null, meta = {},
 
     // ── line editing ──
     if (key.leftArrow || key.left) {
-      if (key.ctrl || key.meta) state.cursor = wordLeft();
-      else {
-        // Step over a chip, not into it. A cursor sitting inside `[#1 pasted 120 …]`
-        // can only do damage: anything typed there breaks the token.
-        const chip = chipBefore(state.input, state.cursor);
-        state.cursor = Math.max(0, state.cursor - (chip ? chip[0].length : 1));
-      }
-      return notifyNow();
+      const sel = inputSelection(state);
+      // Left with a selection and no Shift lands at its start, as in any text field.
+      if (sel && !key.shift) return moveCursor(sel[0], false);
+      if (key.ctrl || key.meta) return moveCursor(wordLeft(), key.shift);
+      // Step over a chip, not into it. A cursor sitting inside `[#1 pasted 120 …]`
+      // can only do damage: anything typed there breaks the token.
+      const chip = chipBefore(state.input, state.cursor);
+      return moveCursor(state.cursor - (chip ? chip[0].length : 1), key.shift);
     }
     if (key.rightArrow || key.right) {
-      if (key.ctrl || key.meta) state.cursor = wordRight();
-      else {
-        const chip = chipAfter(state.input, state.cursor);
-        state.cursor = Math.min(state.input.length, state.cursor + (chip ? chip[0].length : 1));
-      }
-      return notifyNow();
+      const sel = inputSelection(state);
+      if (sel && !key.shift) return moveCursor(sel[1], false);
+      if (key.ctrl || key.meta) return moveCursor(wordRight(), key.shift);
+      const chip = chipAfter(state.input, state.cursor);
+      return moveCursor(state.cursor + (chip ? chip[0].length : 1), key.shift);
     }
-    if (key.home || (ctrlKey === 'a')) { state.cursor = 0; return notifyNow(); }
-    if (key.end || (ctrlKey === 'e')) { state.cursor = state.input.length; return notifyNow(); }
+    if (key.home || (ctrlKey === 'a')) return moveCursor(0, key.shift);
+    if (key.end || (ctrlKey === 'e')) return moveCursor(state.input.length, key.shift);
+    if (['w', 'u', 'k'].includes(ctrlKey)) state.inputAnchor = null;
     if (ctrlKey === 'w') {
       // A chip is one word. Deleting "the last word" of `…, 969 chars]` would otherwise
       // leave a broken token behind.
@@ -2088,6 +2308,7 @@ export function createTui({ slashCommands = [], fileProvider = null, meta = {},
       refreshMenu();
       return notifyNow();
     }
+    if ((key.backspace || key.delete) && deleteInputSelection()) return notifyNow();
     if (key.backspace) {
       if (state.cursor === 0) return;
       // A chip is inserted with a space after it; Backspace right after that space means
@@ -2185,6 +2406,7 @@ export function createTui({ slashCommands = [], fileProvider = null, meta = {},
         const offset = Math.max(0, total - o.value - 1 - half);
         state.viewingTranscript = offset > 0;
         state.transcriptOffset = offset;
+        state._scrollPin = null;
         flash(`Line ${o.value + 1} of ${total} — Ctrl+End returns to the end`, 'info', 2200);
         notifyNow();
       },