@ai-matrx/terminal 0.0.0-stage → 0.1.1

package/CHANGELOG.md

@@ -0,0 +1,30 @@
+# Changelog
+
+## 0.1.1
+
+From the first independent phone walk.
+
+- Accessory keys are 44px tall (a full touch target); the bar is 52px (`ACCESSORY_BAR_HEIGHT`).
+- Text zoom: pass `onFontSizeChange` (and feed the size back as `fontSize`) and the person can
+  pinch on touch or press ⌘+ / ⌘− / ⌘0; the host decides where the size is remembered. A pinch zooms
+  the text, never the page. Helpers `stepFontSize`, `pinchFontSize`, `FONT_SIZE_MIN/MAX`.
+
+Consumer action: none required. Hosts that reserve the bar's height read `ACCESSORY_BAR_HEIGHT`.
+
+## 0.1.0
+
+First release — Matrx 2 lane E (the phone console), extracted from AI Matrx web.
+
+- `<Terminal>`: xterm 6 (DOM renderer); fit to its box or to the visual viewport above the
+  on-screen keyboard; theme that follows the host's `.dark` class; a transport-free
+  `TerminalHandle` (`write` resolves after parse — pace credit-based streams on it; `reset`,
+  `clear`, `getText`); hardware Ctrl-C hook (`onInterrupt`).
+- Phone layer: tap focuses, drag scrolls with momentum (arrows in the alternate screen),
+  press-and-hold selects a word and drags to extend, Copy pill; hidden input at 16px with
+  autocorrect and autocapitalize off.
+- `<AccessoryBar>`: Esc Tab Ctrl Alt | ← ↓ ↑ → | `| / ~ -` | Home End PgUp PgDn | Paste, hide
+  keyboard; Ctrl/Alt one-shot or locked; keys keep the keyboard up.
+- `createLineEditor`: a shell's line discipline for backends that run one command per call —
+  prompt, cursor editing, ↑/↓ history, Ctrl-A/E/K/U/L/C, multi-line paste run line by line,
+  typeahead kept while a command runs, `setLine` for text staged from outside.
+- Stylesheets ship in the package and `<Terminal>` imports them; `tokens.css` holds defaults.

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 AI Matrix Engine
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,53 @@
-# Temporary Holding Version
+# `@ai-matrx/terminal`
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+The AI Matrx terminal: xterm 6 with everything a host would otherwise rebuild, phone first.
+
+```bash
+pnpm add @ai-matrx/terminal
+```
+
+| Entry | What it is |
+|---|---|
+| `@ai-matrx/terminal` | Framework-free core: accessory keys and their bytes, the Ctrl/Alt latch, the touch gesture recognizer, selection and visual-viewport math, the theme, and `createLineEditor`. |
+| `@ai-matrx/terminal/react` | `<Terminal>` and `<AccessoryBar>`. |
+| `@ai-matrx/terminal/styles.css` | Structural CSS (imported by `<Terminal>` itself). |
+| `@ai-matrx/terminal/tokens.css` | Default `--mxt-*` colours, for a host without its own theme. |
+
+## A PTY
+
+```tsx
+import { Terminal } from "@ai-matrx/terminal/react";
+
+<Terminal
+  fit="viewport" // phones: grow to the bottom of the visual viewport, above the keyboard
+  onReady={(term) => pty.onOutput((bytes) => term.write(bytes))} // write() resolves after parse
+  onData={(keys) => pty.write(keys)} // already modified by the bar's Ctrl / Alt
+  onResize={({ cols, rows }) => pty.resize(cols, rows)}
+/>;
+```
+
+## One command per call (no PTY)
+
+```ts
+import { createLineEditor } from "@ai-matrx/terminal";
+
+const editor = createLineEditor({
+  write: (d) => term.xterm.write(d),
+  prompt: () => "$ ",
+  history: () => commands,
+  onSubmit: async (line) => {
+    term.write(await run(line));
+    editor.done(); // prompt again, then any typeahead or pasted lines
+  },
+});
+// <Terminal onData={(d) => editor.input(d)} … />
+```
+
+On a coarse pointer the terminal turns on its phone layer: tap to type, drag to scroll with
+momentum, press and hold to select a word (drag to extend, Copy), and a 44px keyboard bar
+(Esc Tab Ctrl Alt, arrows, `| / ~ -`, Home End PgUp PgDn, Paste, hide keyboard). Ctrl: tap = the
+next key, double-tap = locked.
+
+Colours: map the `--mxt-*` tokens to your theme, or import `tokens.css`.
+
+MIT © AI Matrix Engine

package/dist/index.cjs

@@ -0,0 +1,567 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  ACCESSORY_BAR_HEIGHT: () => ACCESSORY_BAR_HEIGHT,
+  ACCESSORY_KEYS: () => ACCESSORY_KEYS,
+  DOUBLE_TAP_MS: () => DOUBLE_TAP_MS,
+  FLING_FRICTION: () => FLING_FRICTION,
+  FLING_STOP: () => FLING_STOP,
+  FONT_SIZE_MAX: () => FONT_SIZE_MAX,
+  FONT_SIZE_MIN: () => FONT_SIZE_MIN,
+  KEYBOARD_MIN_PX: () => KEYBOARD_MIN_PX,
+  LONG_PRESS_MS: () => LONG_PRESS_MS,
+  MODIFIER_OFF: () => MODIFIER_OFF,
+  TERMINAL_DEFAULTS: () => TERMINAL_DEFAULTS,
+  TERMINAL_FONT_FAMILY: () => TERMINAL_FONT_FAMILY,
+  afterKey: () => afterKey,
+  applyModifiers: () => applyModifiers,
+  cellAt: () => cellAt,
+  controlCode: () => controlCode,
+  createGestureRecognizer: () => createGestureRecognizer,
+  createLineEditor: () => createLineEditor,
+  flingStep: () => flingStep,
+  isActive: () => isActive,
+  keySequence: () => keySequence,
+  keyboardInset: () => keyboardInset,
+  pinchFontSize: () => pinchFontSize,
+  spanBetween: () => spanBetween,
+  stepFontSize: () => stepFontSize,
+  tapModifier: () => tapModifier,
+  terminalTheme: () => terminalTheme,
+  visibleHeightBelow: () => visibleHeightBelow,
+  wordBounds: () => wordBounds
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/core/keys.ts
+var ACCESSORY_KEYS = [
+  { id: "esc", label: "Esc", aria: "Escape", kind: "send", group: 0 },
+  { id: "tab", label: "Tab", aria: "Tab", kind: "send", group: 0 },
+  { id: "ctrl", label: "Ctrl", aria: "Control", kind: "modifier", group: 0 },
+  { id: "alt", label: "Alt", aria: "Alt", kind: "modifier", group: 0 },
+  { id: "left", label: "\u2190", aria: "Left arrow", kind: "send", group: 1 },
+  { id: "down", label: "\u2193", aria: "Down arrow", kind: "send", group: 1 },
+  { id: "up", label: "\u2191", aria: "Up arrow", kind: "send", group: 1 },
+  { id: "right", label: "\u2192", aria: "Right arrow", kind: "send", group: 1 },
+  { id: "pipe", label: "|", aria: "Pipe", kind: "send", group: 2 },
+  { id: "slash", label: "/", aria: "Slash", kind: "send", group: 2 },
+  { id: "tilde", label: "~", aria: "Tilde", kind: "send", group: 2 },
+  { id: "dash", label: "-", aria: "Dash", kind: "send", group: 2 },
+  { id: "home", label: "Home", aria: "Home", kind: "send", group: 3 },
+  { id: "end", label: "End", aria: "End", kind: "send", group: 3 },
+  { id: "pgup", label: "PgUp", aria: "Page up", kind: "send", group: 3 },
+  { id: "pgdn", label: "PgDn", aria: "Page down", kind: "send", group: 3 },
+  { id: "paste", label: "Paste", aria: "Paste", kind: "action", group: 4 },
+  { id: "hide", label: "Hide", aria: "Hide keyboard", kind: "action", group: 4 }
+];
+var ESC = "\x1B";
+var CURSOR = { up: "A", down: "B", right: "C", left: "D", home: "H", end: "F" };
+var TILDE = { pgup: "5", pgdn: "6" };
+var LITERAL = { pipe: "|", slash: "/", tilde: "~", dash: "-", tab: "	", esc: ESC };
+function modParam(mods) {
+  return 1 + (mods.alt ? 2 : 0) + (mods.ctrl ? 4 : 0);
+}
+function keySequence(id, mods, modes) {
+  const cursor = CURSOR[id];
+  if (cursor !== void 0) {
+    const m = modParam(mods);
+    if (m > 1) return `${ESC}[1;${m}${cursor}`;
+    return modes.applicationCursor ? `${ESC}O${cursor}` : `${ESC}[${cursor}`;
+  }
+  const tilde = TILDE[id];
+  if (tilde !== void 0) {
+    const m = modParam(mods);
+    return m > 1 ? `${ESC}[${tilde};${m}~` : `${ESC}[${tilde}~`;
+  }
+  const literal = LITERAL[id];
+  if (literal !== void 0) {
+    if (id === "tab" && mods.ctrl === false && mods.alt === false) return literal;
+    if (id === "esc") return mods.alt ? ESC + ESC : ESC;
+    return applyModifiers(literal, mods).data;
+  }
+  return null;
+}
+function controlCode(char) {
+  if (char.length !== 1) return null;
+  const code = char.charCodeAt(0);
+  if (code >= 97 && code <= 122) return String.fromCharCode(code - 96);
+  if (code >= 64 && code <= 95) return String.fromCharCode(code - 64);
+  switch (char) {
+    case " ":
+    case "2":
+      return "\0";
+    case "3":
+      return "\x1B";
+    case "4":
+      return "";
+    case "5":
+      return "";
+    case "6":
+      return "";
+    case "7":
+    case "/":
+    case "-":
+      return "";
+    case "8":
+    case "?":
+      return "\x7F";
+    default:
+      return null;
+  }
+}
+function applyModifiers(data, mods) {
+  if (!mods.ctrl && !mods.alt) return { data, consumed: false };
+  const chars = Array.from(data);
+  if (chars.length !== 1) {
+    const m = /^\x1b(?:\[|O)([ABCDHF])$/.exec(data);
+    if (m) return { data: `${ESC}[1;${modParam(mods)}${m[1]}`, consumed: true };
+    return { data, consumed: false };
+  }
+  let out = data;
+  if (mods.ctrl) {
+    const ctl = controlCode(data);
+    if (ctl !== null) out = ctl;
+  }
+  if (mods.alt) out = ESC + out;
+  return { data: out, consumed: true };
+}
+
+// src/core/modifiers.ts
+var DOUBLE_TAP_MS = 350;
+var MODIFIER_OFF = { state: "off", tappedAt: null };
+function tapModifier(latch, now) {
+  switch (latch.state) {
+    case "off":
+      return { state: "once", tappedAt: now };
+    case "once":
+      return latch.tappedAt !== null && now - latch.tappedAt <= DOUBLE_TAP_MS ? { state: "locked", tappedAt: now } : { state: "off", tappedAt: now };
+    case "locked":
+      return { state: "off", tappedAt: now };
+  }
+}
+function afterKey(latch) {
+  return latch.state === "once" ? { state: "off", tappedAt: latch.tappedAt } : latch;
+}
+function isActive(latch) {
+  return latch.state !== "off";
+}
+
+// src/core/gesture.ts
+var LONG_PRESS_MS = 450;
+var FLING_FRICTION = 0.95;
+var FLING_STOP = 2e-3;
+var FLING_MIN = 0.01;
+function createGestureRecognizer(options) {
+  const slop = options.slopPx ?? 8;
+  const lineHeight = Math.max(1, options.lineHeight);
+  let phase = "idle";
+  let start = { x: 0, y: 0, t: 0 };
+  let last = start;
+  let carryPx = 0;
+  let trail = [];
+  function scrollBy(fromY, toY) {
+    carryPx += fromY - toY;
+    const lines = carryPx > 0 ? Math.floor(carryPx / lineHeight) : Math.ceil(carryPx / lineHeight);
+    if (lines === 0) return [];
+    carryPx -= lines * lineHeight;
+    return [{ kind: "scroll", lines }];
+  }
+  return {
+    get phase() {
+      return phase;
+    },
+    down(s) {
+      phase = "pressed";
+      start = s;
+      last = s;
+      carryPx = 0;
+      trail = [s];
+      return [];
+    },
+    move(s) {
+      if (phase === "idle") return [];
+      const out = [];
+      if (phase === "pressed") {
+        if (Math.hypot(s.x - start.x, s.y - start.y) <= slop) return [];
+        phase = "scrolling";
+      }
+      if (phase === "scrolling") {
+        out.push(...scrollBy(last.y, s.y));
+        trail.push(s);
+        while (trail.length > 2 && s.t - trail[0].t > 100) trail.shift();
+      } else if (phase === "selecting") {
+        out.push({ kind: "select-extend", x: s.x, y: s.y });
+      }
+      last = s;
+      return out;
+    },
+    up(s) {
+      const was = phase;
+      phase = "idle";
+      if (was === "pressed") return [{ kind: "tap", x: start.x, y: start.y }];
+      if (was === "selecting") return [{ kind: "select-end" }];
+      if (was === "scrolling") {
+        const out = scrollBy(last.y, s.y);
+        trail.push(s);
+        const first = trail[0];
+        const dt = s.t - first.t;
+        const velocity = dt > 0 ? (first.y - s.y) / dt / lineHeight : 0;
+        if (Math.abs(velocity) >= FLING_MIN) out.push({ kind: "fling", velocity });
+        return out;
+      }
+      return [];
+    },
+    cancel() {
+      const was = phase;
+      phase = "idle";
+      return was === "selecting" ? [{ kind: "select-end" }] : [];
+    },
+    longPress() {
+      if (phase !== "pressed") return [];
+      phase = "selecting";
+      return [{ kind: "select-start", x: start.x, y: start.y }];
+    }
+  };
+}
+function flingStep(velocity, dtMs) {
+  const lines = velocity * dtMs;
+  const next = velocity * Math.pow(FLING_FRICTION, dtMs / 16);
+  return { lines, velocity: Math.abs(next) < FLING_STOP ? 0 : next };
+}
+
+// src/core/selection.ts
+var WORD = /[A-Za-z0-9_\-./~:@%+=,?&#]/;
+function wordBounds(line, col) {
+  const chars = Array.from(line);
+  if (col < 0 || col >= chars.length || !WORD.test(chars[col] ?? " ")) return { start: col, end: col + 1 };
+  let start = col;
+  let end = col + 1;
+  while (start > 0 && WORD.test(chars[start - 1])) start--;
+  while (end < chars.length && WORD.test(chars[end])) end++;
+  return { start, end };
+}
+function spanBetween(anchor, focus, cols) {
+  const a = anchor.row * cols + anchor.col;
+  const b = focus.row * cols + focus.col;
+  const from = Math.min(a, b);
+  const to = Math.max(a, b);
+  return { col: from % cols, row: Math.floor(from / cols), length: to - from + 1 };
+}
+function cellAt(point, box, grid) {
+  const cw = box.width / Math.max(1, grid.cols);
+  const ch = box.height / Math.max(1, grid.rows);
+  const col = Math.min(grid.cols - 1, Math.max(0, Math.floor((point.x - box.left) / cw)));
+  const screenRow = Math.min(grid.rows - 1, Math.max(0, Math.floor((point.y - box.top) / ch)));
+  return { col, row: grid.viewportY + screenRow };
+}
+
+// src/core/viewport.ts
+var KEYBOARD_MIN_PX = 120;
+function keyboardInset(layoutHeight, vv) {
+  if (!vv) return 0;
+  const inset = Math.round(layoutHeight - vv.height - vv.offsetTop);
+  return inset >= KEYBOARD_MIN_PX ? inset : 0;
+}
+function visibleHeightBelow(top, vv, layoutHeight) {
+  const bottom = vv ? vv.offsetTop + vv.height : layoutHeight;
+  return Math.max(0, Math.floor(bottom - top));
+}
+
+// src/core/theme.ts
+var TERMINAL_FONT_FAMILY = 'ui-monospace, "SF Mono", SFMono-Regular, Menlo, Consolas, "Liberation Mono", monospace';
+var TERMINAL_DEFAULTS = {
+  fontSize: 13,
+  lineHeight: 1.2,
+  scrollback: 5e3,
+  /** Side padding inside the terminal box, px. */
+  padding: 8
+};
+var ACCESSORY_BAR_HEIGHT = 52;
+var FONT_SIZE_MIN = 9;
+var FONT_SIZE_MAX = 24;
+function stepFontSize(current, delta) {
+  return Math.min(FONT_SIZE_MAX, Math.max(FONT_SIZE_MIN, Math.round(current) + delta));
+}
+function pinchFontSize(startSize, startDistance, distance) {
+  if (startDistance <= 0) return startSize;
+  return Math.min(FONT_SIZE_MAX, Math.max(FONT_SIZE_MIN, Math.round(startSize * distance / startDistance)));
+}
+function terminalTheme(dark) {
+  return dark ? {
+    background: "#1e1e1e",
+    foreground: "#e4e4e7",
+    cursor: "#e4e4e7",
+    cursorAccent: "#1e1e1e",
+    black: "#1e1e1e",
+    red: "#f87171",
+    green: "#4ade80",
+    yellow: "#facc15",
+    blue: "#60a5fa",
+    magenta: "#c084fc",
+    cyan: "#22d3ee",
+    white: "#e5e7eb",
+    brightBlack: "#71717a",
+    brightRed: "#fca5a5",
+    brightGreen: "#86efac",
+    brightYellow: "#fde047",
+    brightBlue: "#93c5fd",
+    brightMagenta: "#d8b4fe",
+    brightCyan: "#67e8f9",
+    brightWhite: "#f4f4f5",
+    selectionBackground: "#3b82f680"
+  } : {
+    background: "#ffffff",
+    foreground: "#18181b",
+    cursor: "#18181b",
+    cursorAccent: "#ffffff",
+    black: "#18181b",
+    red: "#b91c1c",
+    green: "#15803d",
+    yellow: "#b45309",
+    blue: "#1d4ed8",
+    magenta: "#7c3aed",
+    cyan: "#0e7490",
+    white: "#d4d4d8",
+    brightBlack: "#71717a",
+    brightRed: "#dc2626",
+    brightGreen: "#16a34a",
+    brightYellow: "#d97706",
+    brightBlue: "#2563eb",
+    brightMagenta: "#9333ea",
+    brightCyan: "#0891b2",
+    brightWhite: "#a1a1aa",
+    selectionBackground: "#93c5fd99"
+  };
+}
+
+// src/core/line-editor.ts
+var CSI = "\x1B[";
+function createLineEditor(host) {
+  let line = "";
+  let cursor = 0;
+  let recall = null;
+  let busy = false;
+  const queue = [];
+  let typeahead = "";
+  const changed = () => host.onChange?.(line);
+  function redraw() {
+    host.write(`\r${CSI}K${host.prompt()}${line}`);
+    const back = line.length - cursor;
+    if (back > 0) host.write(`${CSI}${back}D`);
+  }
+  function promptRow() {
+    host.write(`${host.prompt()}${line}`);
+    const back = line.length - cursor;
+    if (back > 0) host.write(`${CSI}${back}D`);
+  }
+  function submit() {
+    const text = line;
+    line = "";
+    cursor = 0;
+    recall = null;
+    host.write("\r\n");
+    if (!text.trim()) {
+      promptRow();
+      next();
+      return;
+    }
+    busy = true;
+    host.onSubmit(text);
+  }
+  function next() {
+    const queued = queue.shift();
+    if (queued === void 0) return;
+    line = queued;
+    cursor = line.length;
+    host.write(line);
+    submit();
+  }
+  function insert(text) {
+    line = line.slice(0, cursor) + text + line.slice(cursor);
+    cursor += text.length;
+    if (cursor === line.length) host.write(text);
+    else redraw();
+  }
+  function setFromHistory(index) {
+    const history = host.history();
+    recall = index;
+    line = index === null ? "" : history[index] ?? "";
+    cursor = line.length;
+    redraw();
+    changed();
+  }
+  function paste(data) {
+    const parts = data.replace(/\r\n?/g, "\n").split("\n");
+    const first = parts.shift() ?? "";
+    if (first) insert(first);
+    if (parts.length === 0) {
+      changed();
+      return;
+    }
+    queue.push(...parts.filter((p, i) => p !== "" || i < parts.length - 1));
+    changed();
+    submit();
+  }
+  function input(data) {
+    if (busy) {
+      if (data === "") {
+        typeahead = "";
+        host.onInterrupt?.();
+      } else {
+        typeahead += data.replace(/\x1b(?:\[[0-9;]*[A-Za-z~]|O[A-Za-z])/g, "").replace(/[^\r\n\t\x20-\x7e\u00a0-\uffff]/g, "");
+      }
+      return;
+    }
+    const clean = data.replace(/\x1b\[20[01]~/g, "");
+    if (clean.length > 1 && !clean.startsWith("\x1B")) {
+      paste(clean);
+      return;
+    }
+    switch (clean) {
+      case "\r":
+      case "\n":
+        submit();
+        return;
+      case "\x7F":
+      case "\b":
+        if (cursor === 0) return;
+        line = line.slice(0, cursor - 1) + line.slice(cursor);
+        cursor -= 1;
+        redraw();
+        changed();
+        return;
+      case `${CSI}3~`:
+        if (cursor >= line.length) return;
+        line = line.slice(0, cursor) + line.slice(cursor + 1);
+        redraw();
+        changed();
+        return;
+      case `${CSI}A`:
+      case "\x1BOA": {
+        const history = host.history();
+        if (history.length === 0) return;
+        setFromHistory(recall === null ? history.length - 1 : Math.max(0, recall - 1));
+        return;
+      }
+      case `${CSI}B`:
+      case "\x1BOB": {
+        if (recall === null) return;
+        const nextIndex = recall + 1;
+        setFromHistory(nextIndex >= host.history().length ? null : nextIndex);
+        return;
+      }
+      case `${CSI}C`:
+      case "\x1BOC":
+        if (cursor < line.length) {
+          cursor += 1;
+          host.write(`${CSI}C`);
+        }
+        return;
+      case `${CSI}D`:
+      case "\x1BOD":
+        if (cursor > 0) {
+          cursor -= 1;
+          host.write(`${CSI}D`);
+        }
+        return;
+      case "
":
+      case `${CSI}H`:
+      case "\x1BOH":
+        if (cursor > 0) {
+          host.write(`${CSI}${cursor}D`);
+          cursor = 0;
+        }
+        return;
+      case "":
+      case `${CSI}F`:
+      case "\x1BOF": {
+        const distance = line.length - cursor;
+        if (distance > 0) {
+          host.write(`${CSI}${distance}C`);
+          cursor = line.length;
+        }
+        return;
+      }
+      case "\v":
+        line = line.slice(0, cursor);
+        redraw();
+        changed();
+        return;
+      case "":
+        line = line.slice(cursor);
+        cursor = 0;
+        redraw();
+        changed();
+        return;
+      case "\f":
+        host.onClearScreen?.();
+        redraw();
+        return;
+      case "":
+        host.write("^C\r\n");
+        line = "";
+        cursor = 0;
+        recall = null;
+        queue.length = 0;
+        promptRow();
+        changed();
+        return;
+      default:
+        if (clean.length === 1 && clean >= " ") {
+          insert(clean);
+          changed();
+        }
+    }
+  }
+  return {
+    input,
+    prompt: promptRow,
+    refresh: redraw,
+    setLine(text) {
+      line = text;
+      cursor = text.length;
+      recall = null;
+      if (!busy) redraw();
+    },
+    done() {
+      busy = false;
+      promptRow();
+      if (queue.length > 0) {
+        next();
+        return;
+      }
+      if (typeahead) {
+        const pending = typeahead;
+        typeahead = "";
+        if (pending.length === 1) input(pending);
+        else paste(pending);
+      }
+    },
+    get line() {
+      return line;
+    },
+    get busy() {
+      return busy;
+    }
+  };
+}
+//# sourceMappingURL=index.cjs.map