@beast01/tcurl 1.0.0 → 1.0.2

package/README.md

@@ -39,13 +39,14 @@ tcurl --theme ember            # start with the Ember theme
 tcurl --help
 ```
 
-### Keyboard
+### Keyboard — vim/nvim motions everywhere
 
 **List view**
 
 | Key          | Action                          |
 | ------------ | ------------------------------- |
-| `↑` / `↓`    | Move selection                  |
+| `j` / `k`    | Move selection down / up        |
+| `gg` / `G`   | First / last request            |
 | `n`          | New request                     |
 | `Enter` / `e`| Edit request                    |
 | `s`          | Send request                    |
@@ -55,25 +56,43 @@ tcurl --help
 | `?`          | Help                            |
 | `q` / `Ctrl+C` | Quit                          |
 
-**Editor**
+**Editor — field navigation**
 
 | Key                | Action                                       |
 | ------------------ | -------------------------------------------- |
-| `↑` / `↓` / `Tab`  | Move between fields                          |
-| `←` / `→` / `Space`| Change method, body type, toggles            |
-| `Enter`            | Edit the focused field                       |
-| `Ctrl+S`           | Save a multi-line field (body, headers…)     |
+| `j` / `k` / `Tab`  | Move between fields                          |
+| `gg` / `G`         | First / last field                           |
+| `h` / `l`          | Change method, body type, toggles            |
+| `i` / `a` / `Enter`| Edit the focused field                       |
 | `Esc`              | Back to list (auto-saves)                    |
 
+**Field editor — modal (INSERT / NORMAL, like nvim)**
+
+Fields open in **INSERT** mode so you can type right away; press `Esc` for
+**NORMAL** mode and vim motions.
+
+| Key                 | Action                                   |
+| ------------------- | ---------------------------------------- |
+| `Esc`               | INSERT → NORMAL                          |
+| `i` `a` `I` `A` `o` `O` | NORMAL → INSERT (at cursor, after, line start/end, open line) |
+| `h` `j` `k` `l`     | Move by char / line                      |
+| `w` / `b` / `e`     | Word forward / back / end                |
+| `0` / `$`           | Line start / end                         |
+| `gg` / `G`          | Buffer start / end                       |
+| `x` / `dd`          | Delete char / line                       |
+| `Enter` / `Ctrl+S`  | Save the field                           |
+| `Esc` (in NORMAL)   | Cancel the edit                          |
+
 **Response**
 
-| Key             | Action              |
-| --------------- | ------------------- |
-| `↑`/`↓`/`j`/`k` | Scroll              |
-| `PgUp`/`PgDn`   | Page scroll         |
-| `g` / `G`       | Jump to top/bottom  |
-| `Tab` / `h`     | Body ↔ Headers      |
-| `Esc`           | Back                |
+| Key               | Action                |
+| ----------------- | --------------------- |
+| `j` / `k`         | Scroll down / up      |
+| `Ctrl+d` / `Ctrl+u` | Half-page down / up |
+| `Ctrl+f` / `Ctrl+b` | Full-page down / up |
+| `g` / `G`         | Top / bottom          |
+| `h` / `l` / `Tab` | Body ↔ Headers        |
+| `q` / `Esc`       | Back                  |
 
 ## Features
 
@@ -85,11 +104,17 @@ tcurl --help
 - **Auth** — Bearer token or HTTP Basic (username / password).
 - **Redirects** — follow (with method downgrade on 301/302/303) or manual.
 - **TLS control** — toggle certificate verification for self-signed hosts.
-- **Timeouts** — per-request, in milliseconds.
+- **Timeouts & cancellation** — per-request timeout in milliseconds (default
+  30 000; set `0` to disable). While a request is in flight, press `Esc` (or
+  `q`) to abort it immediately — even with no timeout set — and `Ctrl+C`
+  always quits, so a hung server can never lock you up.
 - **Pretty responses** — JSON is auto-formatted; scrollable body & headers
   with status, timing, and size.
 - **Persistence** — requests are stored as JSON and reused across sessions.
 - **Export** — copy any saved request as an equivalent `curl` command.
+- **Vim/nvim motions** — `j`/`k`, `gg`/`G`, `h`/`l` navigation throughout, plus
+  a fully modal (INSERT / NORMAL) field editor with `w`/`b`/`e`, `0`/`$`,
+  `x`, `dd`, `o`/`O`, and `Ctrl+d`/`Ctrl+u` scrolling.
 
 ## Where is my data?
 

package/dist/app.js

@@ -1,4 +1,4 @@
-import React, { useEffect, useState } from 'react';
+import React, { useEffect, useRef, useState } from 'react';
 import { Box, Text, useApp, useInput, useStdout } from 'ink';
 import { getTheme, themes } from './theme.js';
 import { defaultRequest, saveStore } from './storage.js';
@@ -38,6 +38,10 @@ export function App({ initialStore, exitState, }) {
     const [response, setResponse] = useState(null);
     const [loading, setLoading] = useState(false);
     const [flash, setFlash] = useState(null);
+    const pendingG = useRef(false);
+    // In-flight request: controller to abort it, token to ignore stale results.
+    const abortRef = useRef(null);
+    const sendToken = useRef(0);
     const theme = getTheme(store.theme);
     const requests = store.requests;
     function persist(next) {
@@ -60,19 +64,41 @@ export function App({ initialStore, exitState, }) {
             flashMessage('Set a URL first');
             return;
         }
+        const token = ++sendToken.current;
+        const controller = new AbortController();
+        abortRef.current = controller;
         setLoading(true);
         setResponse(null);
-        const result = await executeRequest(config);
+        const result = await executeRequest(config, controller.signal);
+        // Ignore results from a request the user cancelled or superseded.
+        if (sendToken.current !== token)
+            return;
+        abortRef.current = null;
         setResponse(result);
         setLoading(false);
         setMode('response');
     }
-    // Global keys — only in list mode and when idle.
+    function cancelSend() {
+        abortRef.current?.abort();
+        abortRef.current = null;
+        sendToken.current++; // invalidate the pending result
+        setLoading(false);
+        flashMessage('Request cancelled');
+    }
+    // Ctrl+C always quits, from any mode (aborting any in-flight request).
     useInput((input, key) => {
         if (key.ctrl && input === 'c') {
+            abortRef.current?.abort();
             exit();
-            return;
         }
+    });
+    // While a request is in flight, Esc (or q) cancels it.
+    useInput((input, key) => {
+        if (key.escape || input === 'q')
+            cancelSend();
+    }, { isActive: loading });
+    // Global keys — only in list mode and when idle.
+    useInput((input, key) => {
         if (loading)
             return;
         if (input === '?') {
@@ -89,6 +115,22 @@ export function App({ initialStore, exitState, }) {
             persist({ ...store, theme: next });
             return;
         }
+        // gg → first, G → last (vim).
+        if (pendingG.current) {
+            pendingG.current = false;
+            if (input === 'g') {
+                setSelected(0);
+                return;
+            }
+        }
+        if (input === 'g') {
+            pendingG.current = true;
+            return;
+        }
+        if (input === 'G') {
+            setSelected(Math.max(0, requests.length - 1));
+            return;
+        }
         if (key.upArrow || input === 'k') {
             setSelected((s) => Math.max(0, s - 1));
             return;
@@ -161,8 +203,9 @@ export function App({ initialStore, exitState, }) {
         : [];
     return (React.createElement(Box, { flexDirection: "column", width: cols, minHeight: rows - 1 },
         React.createElement(Header, { theme: theme, subtitle: mode === 'list' ? `${requests.length} saved · ` : '' }),
-        React.createElement(Box, { flexGrow: 1, flexDirection: "column", marginTop: 1 }, loading ? (React.createElement(Box, { flexGrow: 1, borderStyle: "round", borderColor: theme.border, paddingX: 1, alignItems: "center", justifyContent: "center" },
-            React.createElement(Spinner, { theme: theme, label: "Sending request\u2026" }))) : mode === 'help' ? (React.createElement(Help, { theme: theme, onClose: () => setMode('list') })) : mode === 'editor' && working ? (React.createElement(RequestEditor, { theme: theme, request: working, isActive: mode === 'editor', onChange: onEditorChange, onSend: onEditorSend, onBack: onEditorBack })) : mode === 'response' && response ? (React.createElement(ResponseViewer, { theme: theme, response: response, isActive: mode === 'response', onBack: () => setMode('list'), width: cols, height: rows })) : (React.createElement(RequestList, { theme: theme, requests: requests, selectedIndex: selected }))),
+        React.createElement(Box, { flexGrow: 1, flexDirection: "column", marginTop: 1 }, loading ? (React.createElement(Box, { flexGrow: 1, borderStyle: "round", borderColor: theme.border, paddingX: 1, alignItems: "center", justifyContent: "center", flexDirection: "column" },
+            React.createElement(Spinner, { theme: theme, label: "Sending request\u2026" }),
+            React.createElement(Text, { color: theme.muted }, "Esc or q to cancel"))) : mode === 'help' ? (React.createElement(Help, { theme: theme, onClose: () => setMode('list') })) : mode === 'editor' && working ? (React.createElement(RequestEditor, { theme: theme, request: working, isActive: mode === 'editor', onChange: onEditorChange, onSend: onEditorSend, onBack: onEditorBack })) : mode === 'response' && response ? (React.createElement(ResponseViewer, { theme: theme, response: response, isActive: mode === 'response', onBack: () => setMode('list'), width: cols, height: rows })) : (React.createElement(RequestList, { theme: theme, requests: requests, selectedIndex: selected }))),
         React.createElement(Box, { justifyContent: "space-between" },
             React.createElement(StatusBar, { theme: theme, hints: statusHints }),
             flash ? (React.createElement(Box, { paddingX: 1 },

package/dist/components/Help.js

@@ -2,12 +2,14 @@ import React from 'react';
 import { Box, Text, useInput } from 'ink';
 const SECTIONS = [
     {
-        title: 'List view',
+        title: 'List view (vim keys)',
         rows: [
-            ['↑ / ↓', 'Move selection'],
+            ['j / k', 'Move selection down / up'],
+            ['gg / G', 'First / last request'],
             ['n', 'New request'],
             ['Enter / e', 'Edit request'],
             ['s', 'Send request'],
+            ['Esc / q', 'Cancel a request while it is sending'],
             ['d', 'Delete request'],
             ['y', 'Copy as curl (prints on exit)'],
             ['t', 'Cycle theme (gruvbox / ember)'],
@@ -16,23 +18,38 @@ const SECTIONS = [
         ],
     },
     {
-        title: 'Editor',
+        title: 'Editor (field navigation)',
         rows: [
-            ['↑ / ↓ / Tab', 'Move between fields'],
-            ['← / → / Space', 'Change method, body type, toggles'],
-            ['Enter', 'Edit the focused field'],
-            ['Ctrl+S', 'Save multi-line field'],
+            ['j / k / Tab', 'Move between fields'],
+            ['gg / G', 'First / last field'],
+            ['h / l', 'Change method, body type, toggles'],
+            ['i / a / Enter', 'Edit the focused field'],
             ['Esc', 'Back to list (auto-saves)'],
         ],
     },
     {
-        title: 'Response',
+        title: 'Field editor — modal (INSERT / NORMAL)',
         rows: [
-            ['↑ / ↓ / j / k', 'Scroll'],
-            ['PgUp / PgDn', 'Page scroll'],
+            ['Esc', 'INSERT → NORMAL'],
+            ['i a I A o O', 'NORMAL → INSERT (various)'],
+            ['h j k l', 'Move by char / line'],
+            ['w / b / e', 'Word forward / back / end'],
+            ['0 / $', 'Line start / end'],
+            ['gg / G', 'Buffer start / end'],
+            ['x / dd', 'Delete char / line'],
+            ['Enter / Ctrl+S', 'Save field'],
+            ['Esc (in NORMAL)', 'Cancel edit'],
+        ],
+    },
+    {
+        title: 'Response (vim keys)',
+        rows: [
+            ['j / k', 'Scroll down / up'],
+            ['Ctrl+d / Ctrl+u', 'Half-page down / up'],
+            ['Ctrl+f / Ctrl+b', 'Full-page down / up'],
             ['g / G', 'Top / bottom'],
-            ['Tab / h', 'Switch body / headers'],
-            ['Esc', 'Back'],
+            ['h / l / Tab', 'Switch body / headers'],
+            ['q / Esc', 'Back'],
         ],
     },
 ];

package/dist/components/RequestEditor.js

@@ -1,4 +1,4 @@
-import React, { useState } from 'react';
+import React, { useRef, useState } from 'react';
 import { Box, Text, useInput } from 'ink';
 import { HTTP_METHODS } from '../types.js';
 import { methodColor } from '../theme.js';
@@ -9,6 +9,7 @@ const AUTH_TYPES = ['none', 'bearer', 'basic'];
 export function RequestEditor({ theme, request, isActive, onChange, onSend, onBack, }) {
     const [focus, setFocus] = useState(0);
     const [editingKey, setEditingKey] = useState(null);
+    const pending = useRef(false);
     const fields = buildFields(request, theme);
     const editing = editingKey !== null;
     useInput((input, key) => {
@@ -16,23 +17,41 @@ export function RequestEditor({ theme, request, isActive, onChange, onSend, onBa
             onBack();
             return;
         }
-        if (key.upArrow || (key.shift && key.tab)) {
+        // gg → first field, G → last field (vim).
+        if (pending.current) {
+            pending.current = false;
+            if (input === 'g') {
+                setFocus(0);
+                return;
+            }
+        }
+        if (input === 'g') {
+            pending.current = true;
+            return;
+        }
+        if (input === 'G') {
+            setFocus(fields.length - 1);
+            return;
+        }
+        if (key.upArrow || input === 'k' || (key.shift && key.tab)) {
             setFocus((f) => (f - 1 + fields.length) % fields.length);
             return;
         }
-        if (key.downArrow || key.tab) {
+        if (key.downArrow || input === 'j' || key.tab) {
             setFocus((f) => (f + 1) % fields.length);
             return;
         }
         const field = fields[focus];
         if (!field)
             return;
-        if (key.leftArrow || key.rightArrow) {
-            const dir = key.leftArrow ? -1 : 1;
+        // h/l (and arrows) change cycles/toggles.
+        if (key.leftArrow || key.rightArrow || input === 'h' || input === 'l') {
+            const dir = key.leftArrow || input === 'h' ? -1 : 1;
             applyCycle(field.key, dir);
             return;
         }
-        if (key.return || input === ' ') {
+        // Enter / i / a / Space edit or activate the focused field.
+        if (key.return || input === ' ' || input === 'i' || input === 'a') {
             activate(field);
             return;
         }
@@ -136,7 +155,7 @@ export function RequestEditor({ theme, request, isActive, onChange, onSend, onBa
                 React.createElement(Text, { color: f.color ?? (focused ? theme.fg : theme.fgDim), wrap: "truncate-end" }, f.display)));
         }),
         React.createElement(Box, { height: 1 }),
-        React.createElement(Text, { color: theme.muted }, "\u2191\u2193 move \u00B7 \u2190\u2192/Space change \u00B7 Enter edit \u00B7 Esc back")));
+        React.createElement(Text, { color: theme.muted }, "j/k move \u00B7 gg/G ends \u00B7 h/l change \u00B7 i/Enter edit \u00B7 Esc back")));
 }
 function buildFields(request, theme) {
     const fields = [

package/dist/components/ResponseViewer.js

@@ -21,7 +21,7 @@ export function ResponseViewer({ theme, response, isActive, onBack, width, heigh
             onBack();
             return;
         }
-        if (input === 'h' || input === 'b' || key.tab) {
+        if ((!key.ctrl && (input === 'h' || input === 'l')) || key.tab) {
             setTab((t) => (t === 'body' ? 'headers' : 'body'));
             setScroll(0);
             return;
@@ -30,10 +30,15 @@ export function ResponseViewer({ theme, response, isActive, onBack, width, heigh
             setScroll((s) => Math.max(0, s - 1));
         if (key.downArrow || input === 'j')
             setScroll((s) => Math.min(maxScroll, s + 1));
-        if (key.pageUp)
+        if (key.pageUp || (key.ctrl && input === 'b'))
             setScroll((s) => Math.max(0, s - viewport));
-        if (key.pageDown)
+        if (key.pageDown || (key.ctrl && input === 'f'))
             setScroll((s) => Math.min(maxScroll, s + viewport));
+        // Ctrl+U / Ctrl+D — half-page scroll (vim).
+        if (key.ctrl && input === 'u')
+            setScroll((s) => Math.max(0, s - Math.floor(viewport / 2)));
+        if (key.ctrl && input === 'd')
+            setScroll((s) => Math.min(maxScroll, s + Math.floor(viewport / 2)));
         if (input === 'g')
             setScroll(0);
         if (input === 'G')
@@ -66,7 +71,7 @@ export function ResponseViewer({ theme, response, isActive, onBack, width, heigh
             React.createElement(Text, { color: theme.muted }, lines.length > viewport
                 ? `line ${clampedScroll + 1}-${Math.min(clampedScroll + viewport, lines.length)} / ${lines.length}`
                 : `${lines.length} lines`),
-            React.createElement(Text, { color: theme.muted }, "\u2191\u2193 scroll \u00B7 Tab headers/body \u00B7 g/G top/bottom \u00B7 Esc back"))));
+            React.createElement(Text, { color: theme.muted }, "j/k scroll \u00B7 Ctrl+d/u half-page \u00B7 h/l tabs \u00B7 g/G ends \u00B7 q back"))));
 }
 function Tabs({ theme, tab, headerCount, }) {
     const item = (id, label) => (React.createElement(Text, { backgroundColor: tab === id ? theme.selectionBg : undefined, color: tab === id ? theme.accent : theme.fgDim, bold: tab === id },

package/dist/components/TextEditor.js

@@ -1,90 +1,263 @@
-import React, { useState } from 'react';
+import React, { useEffect, useReducer } from 'react';
 import { Box, Text, useInput } from 'ink';
+const WORD = /\w/;
 /**
- * A self-contained text editor supporting single- and multi-line input.
- * Enter submits (single-line) or inserts a newline (multi-line).
- * Ctrl+S submits, Esc cancels. Arrow keys move the cursor.
+ * A modal (vim/nvim-style) text editor supporting single- and multi-line input.
+ *
+ * INSERT: type text; Enter inserts a newline (multiline) or submits; Esc → NORMAL.
+ * NORMAL: h/j/k/l move, w/b/e word motions, 0/$ line ends, gg/G buffer ends,
+ * x deletes a char, dd deletes a line, i/a/I/A/o/O enter INSERT, Enter or
+ * Ctrl+S saves, Esc cancels.
+ *
+ * State lives in a reducer so every keystroke is computed atomically from the
+ * previous state — this keeps combos (gg, dd) and fast typing correct.
  */
 export function TextEditor({ initialValue, multiline = false, masked = false, theme, label, onSubmit, onCancel, }) {
-    const [value, setValue] = useState(initialValue);
-    const [cursor, setCursor] = useState(initialValue.length);
+    const [state, dispatch] = useReducer(reducer, {
+        value: initialValue,
+        cursor: initialValue.length,
+        mode: 'insert',
+        pending: '',
+        multiline,
+        exit: '',
+    });
     useInput((input, key) => {
-        if (key.escape) {
-            onCancel();
-            return;
-        }
-        // Ctrl+S always submits.
-        if (key.ctrl && input === 's') {
-            onSubmit(value);
-            return;
-        }
-        if (key.return) {
-            if (multiline) {
-                insert('\n');
-            }
-            else {
-                onSubmit(value);
-            }
-            return;
-        }
-        if (key.leftArrow) {
-            setCursor((c) => Math.max(0, c - 1));
-            return;
-        }
-        if (key.rightArrow) {
-            setCursor((c) => Math.min(value.length, c + 1));
-            return;
-        }
-        if (key.upArrow || key.downArrow) {
-            moveVertical(key.upArrow ? -1 : 1);
+        if (state.exit)
             return;
-        }
-        if (key.backspace || key.delete) {
-            if (cursor > 0) {
-                setValue((v) => v.slice(0, cursor - 1) + v.slice(cursor));
-                setCursor((c) => Math.max(0, c - 1));
-            }
-            return;
-        }
-        // Ignore other control keys (tab, etc.).
-        if (key.tab || key.ctrl || key.meta)
-            return;
-        if (input)
-            insert(input);
+        dispatch({ input, key });
     });
-    function insert(text) {
-        setValue((v) => v.slice(0, cursor) + text + v.slice(cursor));
-        setCursor((c) => c + text.length);
-    }
-    function moveVertical(dir) {
-        const before = value.slice(0, cursor);
-        const lines = before.split('\n');
-        const col = lines[lines.length - 1].length;
-        const allLines = value.split('\n');
-        const curLineIdx = lines.length - 1;
-        const targetIdx = curLineIdx + dir;
-        if (targetIdx < 0 || targetIdx >= allLines.length)
-            return;
-        let offset = 0;
-        for (let i = 0; i < targetIdx; i++)
-            offset += allLines[i].length + 1;
-        offset += Math.min(col, allLines[targetIdx].length);
-        setCursor(offset);
-    }
-    const display = masked ? '•'.repeat(value.length) : value;
-    // Insert a visible cursor block.
-    const withCursor = display.slice(0, cursor) +
-        (cursor < display.length ? `█` : '█') +
-        display.slice(cursor + (cursor < display.length ? 1 : 0));
+    useEffect(() => {
+        if (state.exit === 'submit')
+            onSubmit(state.value);
+        else if (state.exit === 'cancel')
+            onCancel();
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [state.exit]);
+    const display = masked ? '•'.repeat(state.value.length) : state.value;
+    const lines = renderWithCursor(display, state.cursor, state.mode);
     return (React.createElement(Box, { flexDirection: "column" },
-        React.createElement(Box, null,
+        React.createElement(Box, { justifyContent: "space-between" },
             React.createElement(Text, { color: theme.accent, bold: true },
                 '✎ ',
-                label)),
-        React.createElement(Box, { borderStyle: "round", borderColor: theme.borderActive, paddingX: 1, flexDirection: "column", minHeight: multiline ? 6 : 1 },
-            React.createElement(Text, { color: theme.fg }, withCursor.length ? withCursor : '█')),
+                label),
+            React.createElement(Text, { backgroundColor: state.mode === 'insert' ? theme.success : theme.accentAlt, color: theme.bg, bold: true }, state.mode === 'insert' ? ' INSERT ' : ' NORMAL ')),
+        React.createElement(Box, { borderStyle: "round", borderColor: state.mode === 'insert' ? theme.success : theme.borderActive, paddingX: 1, flexDirection: "column", minHeight: multiline ? 6 : 1 }, lines.map((line, i) => (React.createElement(Text, { key: i, color: theme.fg }, line.length ? line : ' ')))),
         React.createElement(Box, null,
-            React.createElement(Text, { color: theme.muted }, multiline
-                ? 'Enter: newline · Ctrl+S: save · Esc: cancel'
-                : 'Enter: save · Esc: cancel'))));
+            React.createElement(Text, { color: theme.muted }, state.mode === 'insert'
+                ? multiline
+                    ? 'type · Enter: newline · Esc: normal · Ctrl+S: save'
+                    : 'type · Enter: save · Esc: normal · Ctrl+S: save'
+                : 'h j k l · w b e · 0 $ · gg G · x dd · i a o · Enter: save · Esc: cancel'))));
+}
+function reducer(s, a) {
+    const { input, key } = a;
+    // Ctrl+S submits from any mode.
+    if (key.ctrl && input === 's')
+        return { ...s, exit: 'submit' };
+    return s.mode === 'insert' ? insertMode(s, input, key) : normalMode(s, input, key);
+}
+function insertMode(s, input, key) {
+    if (key.escape)
+        return { ...s, mode: 'normal' };
+    if (key.return) {
+        if (s.multiline)
+            return insertText(s, '\n');
+        return { ...s, exit: 'submit' };
+    }
+    if (key.leftArrow)
+        return { ...s, cursor: Math.max(0, s.cursor - 1) };
+    if (key.rightArrow)
+        return { ...s, cursor: Math.min(s.value.length, s.cursor + 1) };
+    if (key.upArrow)
+        return moveVertical(s, -1);
+    if (key.downArrow)
+        return moveVertical(s, 1);
+    if (key.backspace || key.delete) {
+        if (s.cursor > 0) {
+            return {
+                ...s,
+                value: s.value.slice(0, s.cursor - 1) + s.value.slice(s.cursor),
+                cursor: s.cursor - 1,
+            };
+        }
+        return s;
+    }
+    if (key.tab || key.ctrl || key.meta)
+        return s;
+    if (input)
+        return insertText(s, input);
+    return s;
+}
+function normalMode(s, input, key) {
+    // Resolve pending two-key operators.
+    if (s.pending === 'g') {
+        if (input === 'g')
+            return { ...s, pending: '', cursor: 0 };
+        s = { ...s, pending: '' }; // drop, then process as a fresh key below
+    }
+    if (s.pending === 'd') {
+        if (input === 'd')
+            return deleteLine({ ...s, pending: '' });
+        s = { ...s, pending: '' };
+    }
+    if (key.escape)
+        return { ...s, exit: 'cancel' };
+    if (key.return)
+        return { ...s, exit: 'submit' };
+    // Motions
+    if (input === 'h' || key.leftArrow)
+        return { ...s, cursor: Math.max(0, s.cursor - 1) };
+    if (input === 'l' || key.rightArrow)
+        return { ...s, cursor: Math.min(s.value.length, s.cursor + 1) };
+    if (input === 'j' || key.downArrow)
+        return moveVertical(s, 1);
+    if (input === 'k' || key.upArrow)
+        return moveVertical(s, -1);
+    if (input === '0')
+        return { ...s, cursor: lineStart(s.value, s.cursor) };
+    if (input === '$')
+        return { ...s, cursor: lineEnd(s.value, s.cursor) };
+    if (input === 'w')
+        return { ...s, cursor: wordForward(s.value, s.cursor) };
+    if (input === 'b')
+        return { ...s, cursor: wordBack(s.value, s.cursor) };
+    if (input === 'e')
+        return { ...s, cursor: wordEnd(s.value, s.cursor) };
+    if (input === 'G')
+        return { ...s, cursor: lastLineStart(s.value) };
+    if (input === 'g')
+        return { ...s, pending: 'g' };
+    if (input === 'd')
+        return { ...s, pending: 'd' };
+    // Edits
+    if (input === 'x')
+        return deleteChar(s);
+    if (input === 'i')
+        return { ...s, mode: 'insert' };
+    if (input === 'a')
+        return { ...s, mode: 'insert', cursor: Math.min(s.value.length, s.cursor + 1) };
+    if (input === 'I')
+        return { ...s, mode: 'insert', cursor: lineStart(s.value, s.cursor) };
+    if (input === 'A')
+        return { ...s, mode: 'insert', cursor: lineEnd(s.value, s.cursor) };
+    if (input === 'o' && s.multiline)
+        return openLine(s, 1);
+    if (input === 'O' && s.multiline)
+        return openLine(s, -1);
+    return s;
+}
+// ---- Mutations (pure) ----------------------------------------------------
+function insertText(s, text) {
+    return {
+        ...s,
+        value: s.value.slice(0, s.cursor) + text + s.value.slice(s.cursor),
+        cursor: s.cursor + text.length,
+    };
+}
+function deleteChar(s) {
+    if (s.cursor >= s.value.length) {
+        if (s.cursor > 0) {
+            return {
+                ...s,
+                value: s.value.slice(0, s.cursor - 1) + s.value.slice(s.cursor),
+                cursor: s.cursor - 1,
+            };
+        }
+        return s;
+    }
+    return { ...s, value: s.value.slice(0, s.cursor) + s.value.slice(s.cursor + 1) };
+}
+function deleteLine(s) {
+    const start = lineStart(s.value, s.cursor);
+    let end = lineEnd(s.value, s.cursor);
+    if (s.value[end] === '\n')
+        end += 1;
+    const value = s.value.slice(0, start) + s.value.slice(end);
+    return { ...s, value, cursor: Math.min(start, value.length) };
+}
+function openLine(s, dir) {
+    if (dir === 1) {
+        const end = lineEnd(s.value, s.cursor);
+        return { ...s, value: s.value.slice(0, end) + '\n' + s.value.slice(end), cursor: end + 1, mode: 'insert' };
+    }
+    const start = lineStart(s.value, s.cursor);
+    return { ...s, value: s.value.slice(0, start) + '\n' + s.value.slice(start), cursor: start, mode: 'insert' };
+}
+function moveVertical(s, dir) {
+    const { value, cursor } = s;
+    const col = cursor - lineStart(value, cursor);
+    if (dir === -1) {
+        const ps = lineStart(value, cursor);
+        if (ps === 0)
+            return s;
+        const prevStart = lineStart(value, ps - 1);
+        const prevLen = ps - 1 - prevStart;
+        return { ...s, cursor: prevStart + Math.min(col, prevLen) };
+    }
+    const le = lineEnd(value, cursor);
+    if (le >= value.length)
+        return s;
+    const nextStart = le + 1;
+    const nextLen = lineEnd(value, nextStart) - nextStart;
+    return { ...s, cursor: nextStart + Math.min(col, nextLen) };
+}
+// ---- Motion helpers (pure) -----------------------------------------------
+function lineStart(v, pos) {
+    const nl = v.lastIndexOf('\n', pos - 1);
+    return nl === -1 ? 0 : nl + 1;
+}
+function lineEnd(v, pos) {
+    const nl = v.indexOf('\n', pos);
+    return nl === -1 ? v.length : nl;
+}
+function lastLineStart(v) {
+    const nl = v.lastIndexOf('\n');
+    return nl === -1 ? 0 : nl + 1;
+}
+function wordForward(v, pos) {
+    let i = pos;
+    const n = v.length;
+    if (i >= n)
+        return n;
+    const isWord = WORD.test(v[i]);
+    while (i < n && !/\s/.test(v[i]) && WORD.test(v[i]) === isWord)
+        i++;
+    while (i < n && /\s/.test(v[i]))
+        i++;
+    return i;
+}
+function wordBack(v, pos) {
+    let i = pos - 1;
+    while (i > 0 && /\s/.test(v[i]))
+        i--;
+    if (i <= 0)
+        return 0;
+    const isWord = WORD.test(v[i]);
+    while (i > 0 && !/\s/.test(v[i - 1]) && WORD.test(v[i - 1]) === isWord)
+        i--;
+    return Math.max(0, i);
+}
+function wordEnd(v, pos) {
+    let i = pos + 1;
+    const n = v.length;
+    while (i < n && /\s/.test(v[i]))
+        i++;
+    if (i >= n)
+        return Math.max(0, n - 1);
+    const isWord = WORD.test(v[i]);
+    while (i + 1 < n && !/\s/.test(v[i + 1]) && WORD.test(v[i + 1]) === isWord)
+        i++;
+    return i;
+}
+/** Insert a visible cursor glyph and split into display lines. */
+function renderWithCursor(display, cursor, mode) {
+    const glyph = mode === 'normal' ? '█' : '▏';
+    let out;
+    if (mode === 'normal' && cursor < display.length && display[cursor] !== '\n') {
+        out = display.slice(0, cursor) + glyph + display.slice(cursor + 1);
+    }
+    else {
+        out = display.slice(0, cursor) + glyph + display.slice(cursor);
+    }
+    return out.split('\n');
 }

package/dist/http/client.js

@@ -141,14 +141,28 @@ function doRequest(opts, redirectsLeft) {
         req.end();
     });
 }
-/** Execute a request config and return a normalized result (never throws). */
-export async function executeRequest(config) {
+/**
+ * Execute a request config and return a normalized result (never throws).
+ *
+ * The optional `externalSignal` lets the caller (the UI) cancel an in-flight
+ * request; when it fires the result carries `error: "Request cancelled"`.
+ * A per-request timeout aborts independently.
+ */
+export async function executeRequest(config, externalSignal) {
     const start = Date.now();
     const controller = new AbortController();
     let timer;
     if (config.timeoutMs > 0) {
         timer = setTimeout(() => controller.abort(), config.timeoutMs);
     }
+    // Bridge an external (user) cancellation into our controller.
+    const onExternalAbort = () => controller.abort();
+    if (externalSignal) {
+        if (externalSignal.aborted)
+            controller.abort();
+        else
+            externalSignal.addEventListener('abort', onExternalAbort, { once: true });
+    }
     try {
         const url = buildUrl(config);
         if (url.protocol !== 'http:' && url.protocol !== 'https:') {
@@ -168,6 +182,7 @@ export async function executeRequest(config) {
     }
     catch (err) {
         const aborted = err?.name === 'AbortError' || controller.signal.aborted;
+        const cancelled = externalSignal?.aborted ?? false;
         return {
             ok: false,
             status: 0,
@@ -178,13 +193,17 @@ export async function executeRequest(config) {
             durationMs: Date.now() - start,
             sizeBytes: 0,
             finalUrl: config.url,
-            error: aborted
-                ? `Request timed out after ${config.timeoutMs}ms`
-                : String(err?.message ?? err),
+            error: cancelled
+                ? 'Request cancelled'
+                : aborted
+                    ? `Request timed out after ${config.timeoutMs}ms`
+                    : String(err?.message ?? err),
         };
     }
     finally {
         if (timer)
             clearTimeout(timer);
+        if (externalSignal)
+            externalSignal.removeEventListener('abort', onExternalAbort);
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@beast01/tcurl",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "publishConfig": {
     "access": "public"
   },