parallel-codex-tui 0.1.3 → 0.1.4

package/dist/tui/WorkerOverviewView.js

@@ -0,0 +1,250 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from "ink";
+import { compactEndByDisplayWidth, displayWidth } from "./display-width.js";
+import { effectiveWorkerWatchdog } from "./status-line.js";
+import { TUI_THEME } from "./theme.js";
+export function WorkerOverviewView({ workers, selectedIndex, nowMs = Date.now(), activityPolicies = {}, height = 20, terminalWidth = process.stdout.columns || 120 }) {
+    const viewportHeight = Math.max(1, height);
+    const width = workerOverviewContentWidth(terminalWidth);
+    const lines = workerOverviewDisplayLines(workers, selectedIndex, viewportHeight, terminalWidth, {
+        nowMs,
+        policies: activityPolicies
+    });
+    const blankRows = Math.max(0, viewportHeight - lines.length);
+    return (_jsxs(Box, { flexDirection: "column", height: viewportHeight, children: [lines.map((line, index) => (_jsx(WorkerOverviewRow, { line: line, width: width }, `${line.workerIndex ?? line.tone}-${index}`))), Array.from({ length: blankRows }, (_, index) => (_jsx(Text, { backgroundColor: TUI_THEME.surface, children: " ".repeat(width) }, `worker-overview-fill-${index}`)))] }));
+}
+export function workerOverviewDisplayLines(workers, selectedIndex, height, terminalWidth, activity = {
+    nowMs: Date.now(),
+    policies: {}
+}) {
+    const viewportHeight = Math.max(1, Math.trunc(height));
+    const width = workerOverviewContentWidth(terminalWidth);
+    const lines = [
+        { text: fitWorkerOverviewCandidates(["Workers", "Work", "W"], width), tone: "heading" }
+    ];
+    if (viewportHeight >= 3) {
+        lines.push({ text: workerOverviewSummary(workers, width), tone: "muted" });
+    }
+    const slots = Math.max(0, viewportHeight - lines.length);
+    if (workers.length === 0) {
+        if (slots > 0) {
+            lines.push({ text: fitWorkerOverviewText("No workers yet", width), tone: "muted" });
+        }
+        return lines;
+    }
+    if (slots === 0) {
+        return lines;
+    }
+    const selected = clampWorkerIndex(selectedIndex, workers.length);
+    const selectedWorker = workers[selected];
+    const selectedActivity = selectedWorker
+        ? workerOverviewActivityLine(selectedWorker, activity.nowMs, activity.policies[selectedWorker.engine] ?? {})
+        : null;
+    const activityRows = selectedActivity && slots >= 2 ? 1 : 0;
+    const visibleCount = Math.min(Math.max(0, slots - activityRows), workers.length);
+    const start = workerOverviewWindowStart(selected, workers.length, visibleCount);
+    for (let index = start; index < start + visibleCount; index += 1) {
+        const worker = workers[index];
+        if (!worker) {
+            continue;
+        }
+        const state = worker.runtimeStatus?.state ?? "waiting";
+        lines.push({
+            text: workerOverviewWorkerText(worker, index === selected, width),
+            tone: workerOverviewStateTone(state),
+            workerIndex: index
+        });
+        if (index === selected && selectedActivity && activityRows > 0) {
+            lines.push({
+                text: fitWorkerOverviewText(`    ${selectedActivity.text}`, width),
+                tone: selectedActivity.tone,
+                workerIndex: index
+            });
+        }
+    }
+    return lines;
+}
+export function workerOverviewActivityLine(worker, nowMs, policy) {
+    const status = worker.runtimeStatus;
+    if (!status || (status.state !== "starting" && status.state !== "running")) {
+        return null;
+    }
+    const lastEventMs = Date.parse(status.last_event_at);
+    if (!Number.isFinite(lastEventMs)) {
+        return null;
+    }
+    const ageMs = Math.max(0, nowMs - lastEventMs);
+    if (status.phase === "process-stopping") {
+        return {
+            text: `activity · stopping process tree · ${formatWorkerActivityDuration(ageMs)} elapsed`,
+            tone: "warning"
+        };
+    }
+    const starting = status.state === "starting";
+    const limitMs = effectiveWorkerWatchdog(starting ? policy.firstOutputTimeoutMs : policy.idleTimeoutMs, policy.timeoutMs);
+    const activity = starting ? "started" : "output";
+    const timeout = starting ? "first output timeout" : "idle timeout";
+    if (!limitMs || limitMs <= 0) {
+        return {
+            text: `activity · ${activity} ${formatWorkerActivityDuration(ageMs)} ago · no ${timeout}`,
+            tone: "muted"
+        };
+    }
+    const remainingMs = limitMs - ageMs;
+    if (remainingMs <= 0) {
+        return {
+            text: [
+                "activity",
+                starting
+                    ? `waiting for first output ${formatWorkerActivityDuration(ageMs)}`
+                    : `no output for ${formatWorkerActivityDuration(ageMs)}`,
+                `${timeout} overdue ${formatWorkerActivityDuration(Math.abs(remainingMs))}`
+            ].join(" · "),
+            tone: "danger"
+        };
+    }
+    return {
+        text: `activity · ${activity} ${formatWorkerActivityDuration(ageMs)} ago · ${timeout} in ${formatWorkerActivityDuration(remainingMs)}`,
+        tone: remainingMs <= limitMs * 0.2 ? "warning" : "muted"
+    };
+}
+export function moveWorkerSelection(current, delta, workerCount, wrap = false) {
+    if (workerCount <= 0) {
+        return 0;
+    }
+    const normalizedCurrent = clampWorkerIndex(current, workerCount);
+    const next = normalizedCurrent + Math.trunc(delta);
+    if (wrap) {
+        return ((next % workerCount) + workerCount) % workerCount;
+    }
+    return Math.min(workerCount - 1, Math.max(0, next));
+}
+function WorkerOverviewRow({ line, width }) {
+    const trailingWidth = Math.max(0, width - displayWidth(line.text));
+    const theme = workerOverviewLineTheme(line.tone);
+    return (_jsxs(Text, { children: [_jsx(Text, { ...theme, children: line.text }), trailingWidth > 0 ? _jsx(Text, { backgroundColor: TUI_THEME.surface, children: " ".repeat(trailingWidth) }) : null] }));
+}
+function workerOverviewSummary(workers, width) {
+    const counts = new Map();
+    let sessions = 0;
+    for (const worker of workers) {
+        const state = worker.runtimeStatus?.state ?? "waiting";
+        counts.set(state, (counts.get(state) ?? 0) + 1);
+        if (worker.runtimeStatus?.native_session_id) {
+            sessions += 1;
+        }
+    }
+    const stateParts = ["running", "starting", "done", "failed", "waiting", "cancelled", "idle"]
+        .flatMap((state) => {
+        const count = counts.get(state) ?? 0;
+        return count > 0 ? [`${count} ${state}`] : [];
+    });
+    const full = [
+        `${workers.length} ${workers.length === 1 ? "worker" : "workers"}`,
+        ...stateParts,
+        ...(sessions > 0 ? [`${sessions} ${sessions === 1 ? "session" : "sessions"}`] : [])
+    ].join(" · ");
+    const active = (counts.get("running") ?? 0) + (counts.get("starting") ?? 0);
+    const failed = counts.get("failed") ?? 0;
+    const candidates = [
+        full,
+        `${workers.length} workers · ${active} active · ${failed} failed`,
+        `${workers.length} workers`,
+        `${workers.length}w`
+    ];
+    return fitWorkerOverviewCandidates(candidates, width);
+}
+function workerOverviewWorkerText(worker, selected, width) {
+    const marker = selected ? "> " : "  ";
+    const label = safeWorkerOverviewText(worker.label);
+    const state = worker.runtimeStatus?.state ?? "waiting";
+    const phase = humanizeWorkerOverviewPhase(worker.runtimeStatus?.phase ?? "status pending");
+    const session = worker.runtimeStatus?.native_session_id ? "session" : "";
+    const summary = safeWorkerOverviewText(worker.runtimeStatus?.summary ?? "");
+    const identity = `${worker.role}/${worker.engine}`;
+    return fitWorkerOverviewCandidates([
+        [marker + label, state, phase, session, summary].filter(Boolean).join(" · "),
+        [marker + label, state, phase, session].filter(Boolean).join(" · "),
+        [marker + label, state, session].filter(Boolean).join(" · "),
+        [marker + identity, state].join(" · "),
+        marker.trimEnd()
+    ], width);
+}
+function workerOverviewWindowStart(selected, count, visibleCount) {
+    if (visibleCount <= 0 || count <= visibleCount) {
+        return 0;
+    }
+    return Math.min(count - visibleCount, Math.max(0, selected - Math.floor(visibleCount / 2)));
+}
+function clampWorkerIndex(index, count) {
+    return Math.min(Math.max(0, count - 1), Math.max(0, Math.trunc(index)));
+}
+function fitWorkerOverviewCandidates(candidates, width) {
+    const fitted = candidates.find((candidate) => displayWidth(candidate) <= width);
+    return fitted ?? fitWorkerOverviewText(candidates.at(-1) ?? "", width);
+}
+function fitWorkerOverviewText(text, width) {
+    return compactEndByDisplayWidth(text, Math.max(1, width));
+}
+function formatWorkerActivityDuration(durationMs) {
+    const totalSeconds = Math.max(0, Math.floor(durationMs / 1000));
+    if (totalSeconds === 0) {
+        return "now";
+    }
+    if (totalSeconds < 60) {
+        return `${totalSeconds}s`;
+    }
+    const minutes = Math.floor(totalSeconds / 60);
+    const seconds = totalSeconds % 60;
+    if (minutes < 60) {
+        return seconds > 0 ? `${minutes}m ${seconds}s` : `${minutes}m`;
+    }
+    const hours = Math.floor(minutes / 60);
+    const remainingMinutes = minutes % 60;
+    return remainingMinutes > 0 ? `${hours}h ${remainingMinutes}m` : `${hours}h`;
+}
+function safeWorkerOverviewText(text) {
+    return text
+        .replace(/\x1b\[[0-?]*[ -/]*[@-~]/g, "")
+        .replace(/[\u0000-\u001f\u007f]/g, " ")
+        .replace(/\s+/g, " ")
+        .trim();
+}
+function humanizeWorkerOverviewPhase(phase) {
+    return safeWorkerOverviewText(phase).replace(/[_-]+/g, " ");
+}
+function workerOverviewStateTone(state) {
+    if (state === "done") {
+        return "success";
+    }
+    if (state === "failed") {
+        return "danger";
+    }
+    if (state === "running" || state === "starting") {
+        return "active";
+    }
+    if (state === "waiting") {
+        return "warning";
+    }
+    return "muted";
+}
+function workerOverviewLineTheme(tone) {
+    return {
+        backgroundColor: TUI_THEME.surface,
+        color: tone === "heading" || tone === "active"
+            ? TUI_THEME.accent
+            : tone === "success"
+                ? TUI_THEME.success
+                : tone === "warning"
+                    ? TUI_THEME.warning
+                    : tone === "danger"
+                        ? TUI_THEME.danger
+                        : tone === "muted"
+                            ? TUI_THEME.muted
+                            : TUI_THEME.text,
+        ...(tone === "heading" || tone === "danger" ? { bold: true } : {})
+    };
+}
+function workerOverviewContentWidth(terminalWidth) {
+    return Math.max(1, terminalWidth - 2);
+}

package/dist/tui/chat-history.js

@@ -0,0 +1,25 @@
+export function chatRequestHistory(messages) {
+    return messages
+        .filter((message) => message.from === "user")
+        .map((message) => message.text);
+}
+export function navigateChatDraftHistory(history, current, state, delta) {
+    const nextOffset = clampOffset(state.offset + Math.trunc(delta), history.length);
+    if (nextOffset === state.offset) {
+        return { ...current, state };
+    }
+    const draft = state.offset === 0 && nextOffset > 0 ? current : state.draft;
+    const nextState = { offset: nextOffset, draft };
+    if (nextOffset === 0) {
+        return { ...draft, state: nextState };
+    }
+    const value = history[history.length - nextOffset] ?? "";
+    return {
+        value,
+        cursor: Array.from(value).length,
+        state: nextState
+    };
+}
+function clampOffset(offset, historyLength) {
+    return Math.min(Math.max(0, offset), historyLength);
+}

package/dist/tui/chat-input.js

@@ -1,37 +1,85 @@
-export function applyChatInputChunk(currentValue, chunk) {
+export function applyChatInputChunk(currentValue, chunk, currentCursor) {
+    let chars = Array.from(currentValue);
+    let cursor = clampCursor(currentCursor ?? chars.length, chars.length);
     if (chunk === "\x03") {
         return {
             value: currentValue,
+            cursor,
             submit: null,
             exit: true
         };
     }
-    let value = currentValue;
     let submit = null;
-    const visible = chunk
-        .replaceAll("\x1b[200~", "")
-        .replaceAll("\x1b[201~", "")
-        .replace(/\x1b\[M[\s\S]{3}/g, "")
-        .replace(/\x1b\[[0-?]*[ -/]*[@-~]/g, "")
-        .replace(/\x1bO./g, "");
-    for (const char of visible) {
-        if (char === "\r" || char === "\n") {
-            submit = value;
-            value = "";
+    for (const match of chunk.matchAll(/\x1b\[M[\s\S]{3}|\x1b\[[0-?]*[ -/]*[@-~]|\x1bO.|\x1b.|./gsu)) {
+        const token = match[0];
+        if (token === "\x1b[D" || token === "\x1bOD") {
+            cursor = Math.max(0, cursor - 1);
+        }
+        else if (token === "\x1b[C" || token === "\x1bOC") {
+            cursor = Math.min(chars.length, cursor + 1);
+        }
+        else if (token === "\x1b[H" || token === "\x1b[1~" || token === "\x1bOH" || token === "\x01") {
+            cursor = 0;
+        }
+        else if (token === "\x1b[F" || token === "\x1b[4~" || token === "\x1bOF" || token === "\x05") {
+            cursor = chars.length;
+        }
+        else if (token === "\x1b[3~") {
+            if (cursor < chars.length) {
+                chars.splice(cursor, 1);
+            }
+        }
+        else if (token.startsWith("\x1b")) {
+            continue;
+        }
+        else if (token === "\r" || token === "\n") {
+            submit = chars.join("");
+            chars = [];
+            cursor = 0;
         }
-        else if (char === "\x7f" || char === "\b") {
-            value = dropLastCodePoint(value);
+        else if (token === "\x7f" || token === "\b") {
+            if (cursor > 0) {
+                chars.splice(cursor - 1, 1);
+                cursor -= 1;
+            }
         }
-        else if (char >= " " && char !== "\x1b") {
-            value += char;
+        else if (token >= " ") {
+            chars.splice(cursor, 0, token);
+            cursor += 1;
         }
     }
     return {
-        value,
+        value: chars.join(""),
+        cursor,
         submit,
         exit: false
     };
 }
-function dropLastCodePoint(value) {
-    return [...value].slice(0, -1).join("");
+export function insertChatPaste(currentValue, paste, currentCursor) {
+    const chars = Array.from(currentValue);
+    const cursor = clampCursor(currentCursor ?? chars.length, chars.length);
+    const pastedChars = Array.from(sanitizeChatPaste(paste));
+    chars.splice(cursor, 0, ...pastedChars);
+    return {
+        value: chars.join(""),
+        cursor: cursor + pastedChars.length,
+        submit: null,
+        exit: false
+    };
+}
+function sanitizeChatPaste(value) {
+    const withoutTerminalControls = value
+        .replace(/\x1b\][^\x07]*(?:\x07|\x1b\\)/g, "")
+        .replace(/\x1b\[[0-?]*[ -/]*[@-~]/g, "")
+        .replace(/\x1bO./g, "")
+        .replace(/\r\n?/g, "\n");
+    return Array.from(withoutTerminalControls)
+        .filter((char) => {
+        const codePoint = char.codePointAt(0) ?? 0;
+        return char === "\n" || char === "\t" || (codePoint >= 32 && codePoint !== 127 && !(codePoint >= 128 && codePoint < 160));
+    })
+        .join("");
+}
+function clampCursor(cursor, length) {
+    return Math.min(length, Math.max(0, Math.trunc(cursor)));
 }

package/dist/tui/chat-paste.js

@@ -0,0 +1,76 @@
+const BRACKETED_PASTE_START = "\x1b[200~";
+const BRACKETED_PASTE_END = "\x1b[201~";
+const MIN_BUFFERED_START_PREFIX = 4;
+export function createChatPasteDecoder() {
+    let startPrefix = "";
+    let pasteText = null;
+    let endPrefix = "";
+    return {
+        write(chunk) {
+            const hadStartPrefix = startPrefix.length > 0;
+            let data = `${startPrefix}${chunk}`;
+            startPrefix = "";
+            const events = [];
+            let intercepted = hadStartPrefix || pasteText !== null;
+            while (data) {
+                if (pasteText !== null) {
+                    data = `${endPrefix}${data}`;
+                    endPrefix = "";
+                    const endIndex = data.indexOf(BRACKETED_PASTE_END);
+                    if (endIndex < 0) {
+                        const keep = suffixPrefixLength(data, BRACKETED_PASTE_END);
+                        pasteText += data.slice(0, data.length - keep);
+                        endPrefix = data.slice(data.length - keep);
+                        return { intercepted: true, events };
+                    }
+                    pasteText += data.slice(0, endIndex);
+                    events.push({ kind: "paste", text: pasteText });
+                    pasteText = null;
+                    data = data.slice(endIndex + BRACKETED_PASTE_END.length);
+                    intercepted = true;
+                    continue;
+                }
+                const startIndex = data.indexOf(BRACKETED_PASTE_START);
+                if (startIndex >= 0) {
+                    intercepted = true;
+                    if (startIndex > 0) {
+                        events.push({ kind: "input", text: data.slice(0, startIndex) });
+                    }
+                    pasteText = "";
+                    data = data.slice(startIndex + BRACKETED_PASTE_START.length);
+                    continue;
+                }
+                const keep = suffixPrefixLength(data, BRACKETED_PASTE_START);
+                if (keep >= MIN_BUFFERED_START_PREFIX) {
+                    intercepted = true;
+                    const input = data.slice(0, data.length - keep);
+                    if (input) {
+                        events.push({ kind: "input", text: input });
+                    }
+                    startPrefix = data.slice(data.length - keep);
+                    return { intercepted, events };
+                }
+                if (intercepted) {
+                    events.push({ kind: "input", text: data });
+                    return { intercepted, events };
+                }
+                return { intercepted: false, events: [] };
+            }
+            return { intercepted, events };
+        },
+        reset() {
+            startPrefix = "";
+            pasteText = null;
+            endPrefix = "";
+        }
+    };
+}
+function suffixPrefixLength(value, marker) {
+    const limit = Math.min(value.length, marker.length - 1);
+    for (let length = limit; length > 0; length -= 1) {
+        if (value.endsWith(marker.slice(0, length))) {
+            return length;
+        }
+    }
+    return 0;
+}

package/dist/tui/display-width.js

@@ -50,12 +50,50 @@ export function wrapByDisplayWidth(value, maxWidth) {
             : breakWidth > Math.floor(maxWidth * 0.3)
                 ? breakAt + 1
                 : splitAtWidth;
-        chunks.push(rest.slice(0, splitAt).trimEnd());
-        rest = rest.slice(splitAt).trimStart();
+        const balanced = balanceClosingPunctuation(rest.slice(0, splitAt).trimEnd(), rest.slice(splitAt).trimStart(), maxWidth);
+        chunks.push(balanced.line);
+        rest = balanced.rest;
+    }
+    if (rest || chunks.length === 0) {
+        chunks.push(rest);
     }
-    chunks.push(rest);
     return chunks;
 }
+const lineStartForbiddenPunctuation = new Set(Array.from(",.!?;:)]}，。！？；：、）》】」』〕〉》〗〙〛）］｝’”»"));
+function balanceClosingPunctuation(line, rest, maxWidth) {
+    let punctuation = "";
+    for (const char of Array.from(rest)) {
+        if (!lineStartForbiddenPunctuation.has(char)) {
+            break;
+        }
+        punctuation += char;
+    }
+    if (!punctuation) {
+        return { line, rest };
+    }
+    const split = splitLastDisplayCharacter(line);
+    if (!split || !split.head || displayWidth(`${split.tail}${punctuation}`) > maxWidth) {
+        return { line, rest };
+    }
+    return {
+        line: split.head,
+        rest: `${split.tail}${rest}`
+    };
+}
+function splitLastDisplayCharacter(value) {
+    const chars = Array.from(value);
+    if (chars.length < 2) {
+        return null;
+    }
+    let tailStart = chars.length - 1;
+    while (tailStart > 0 && isCombiningCodePoint(chars[tailStart]?.codePointAt(0) ?? 0)) {
+        tailStart -= 1;
+    }
+    return {
+        head: chars.slice(0, tailStart).join("").trimEnd(),
+        tail: chars.slice(tailStart).join("")
+    };
+}
 function takeStartByDisplayWidth(value, maxWidth) {
     let result = "";
     let width = 0;

package/dist/tui/incremental-text-file.js

@@ -0,0 +1,101 @@
+import { open } from "node:fs/promises";
+import { StringDecoder } from "node:string_decoder";
+const READ_CHUNK_BYTES = 64 * 1024;
+const CHECKPOINT_BYTES = 64;
+export function createIncrementalTextFileReader(path) {
+    let offset = 0;
+    let text = "";
+    let checkpoint = Buffer.alloc(0);
+    let identity = null;
+    let initialized = false;
+    let decoder = new StringDecoder("utf8");
+    let queue = Promise.resolve();
+    const clear = () => {
+        offset = 0;
+        text = "";
+        checkpoint = Buffer.alloc(0);
+        identity = null;
+        initialized = false;
+        decoder = new StringDecoder("utf8");
+    };
+    const readOnce = async () => {
+        let file;
+        try {
+            file = await open(path, "r");
+        }
+        catch (error) {
+            if (error.code !== "ENOENT") {
+                throw error;
+            }
+            const reset = initialized || offset > 0 || text.length > 0;
+            clear();
+            return { text, changed: reset, reset, bytesRead: 0, size: 0 };
+        }
+        try {
+            const stats = await file.stat();
+            const currentIdentity = `${stats.dev}:${stats.ino}`;
+            const wasInitialized = initialized;
+            let reset = initialized && (identity !== currentIdentity || stats.size < offset);
+            if (!reset && initialized && checkpoint.length > 0) {
+                const existing = await readExact(file, checkpoint.length, offset - checkpoint.length);
+                reset = existing.length !== checkpoint.length || !existing.equals(checkpoint);
+            }
+            if (reset) {
+                clear();
+            }
+            initialized = true;
+            identity = currentIdentity;
+            const targetSize = stats.size;
+            let bytesRead = 0;
+            while (offset < targetSize) {
+                const length = Math.min(READ_CHUNK_BYTES, targetSize - offset);
+                const buffer = Buffer.allocUnsafe(length);
+                const result = await file.read(buffer, 0, length, offset);
+                if (result.bytesRead === 0) {
+                    break;
+                }
+                const chunk = buffer.subarray(0, result.bytesRead);
+                text += decoder.write(chunk);
+                checkpoint = nextCheckpoint(checkpoint, chunk);
+                offset += result.bytesRead;
+                bytesRead += result.bytesRead;
+            }
+            return {
+                text,
+                changed: !wasInitialized || reset || bytesRead > 0,
+                reset,
+                bytesRead,
+                size: offset
+            };
+        }
+        finally {
+            await file.close();
+        }
+    };
+    return {
+        read() {
+            const operation = queue.then(readOnce);
+            queue = operation.then(() => undefined, () => undefined);
+            return operation;
+        }
+    };
+}
+async function readExact(file, length, position) {
+    const buffer = Buffer.allocUnsafe(length);
+    let offset = 0;
+    while (offset < length) {
+        const result = await file.read(buffer, offset, length - offset, position + offset);
+        if (result.bytesRead === 0) {
+            break;
+        }
+        offset += result.bytesRead;
+    }
+    return buffer.subarray(0, offset);
+}
+function nextCheckpoint(previous, chunk) {
+    if (chunk.length >= CHECKPOINT_BYTES) {
+        return Buffer.from(chunk.subarray(chunk.length - CHECKPOINT_BYTES));
+    }
+    const combined = Buffer.concat([previous, chunk]);
+    return Buffer.from(combined.subarray(Math.max(0, combined.length - CHECKPOINT_BYTES)));
+}

package/dist/tui/keyboard.js

@@ -7,6 +7,36 @@ export function isAttachShortcut(input, key) {
 export function isExitShortcut(input, key) {
     return (key.ctrl === true && input.toLowerCase() === "c") || input === "\u0003";
 }
+export function isNewTaskShortcut(input, key) {
+    return (key.ctrl === true && input.toLowerCase() === "n") || input === "\u000e";
+}
+export function isWorkspaceShortcut(input, key) {
+    return (key.ctrl === true && input.toLowerCase() === "p") || input === "\u0010";
+}
+export function isRouterDiagnosticsShortcut(input, key) {
+    return (key.ctrl === true && input.toLowerCase() === "g") || input === "\u0007";
+}
+export function isWorkerOverviewShortcut(input, key) {
+    return (key.ctrl === true && input.toLowerCase() === "b") || input === "\u0002";
+}
+export function isTaskSessionsShortcut(input, key) {
+    return (key.ctrl === true && input.toLowerCase() === "t") || input === "\u0014";
+}
+export function isTaskResultShortcut(input, key) {
+    return (key.ctrl === true && input.toLowerCase() === "d") || input === "\u0004";
+}
+export function isWorkerSearchShortcut(input, key) {
+    return (key.ctrl === true && input.toLowerCase() === "f") || input === "\u0006";
+}
+export function workerLogJumpKind(input) {
+    if (input === "e" || input === "E") {
+        return "error";
+    }
+    if (input === "d" || input === "D") {
+        return "diff";
+    }
+    return null;
+}
 export function scrollDelta(input, key, pageSize) {
     if (key.pageUp || (key.ctrl === true && input.toLowerCase() === "u")) {
         return pageSize;
@@ -16,6 +46,22 @@ export function scrollDelta(input, key, pageSize) {
     }
     return 0;
 }
+export function rawPageScrollDelta(input, pageSize) {
+    const size = Math.max(1, pageSize);
+    let delta = 0;
+    for (const match of input.matchAll(/\x1b\[(5|6)~/g)) {
+        delta += match[1] === "5" ? size : -size;
+    }
+    return delta;
+}
+export function rawHistoryDelta(input) {
+    let delta = 0;
+    for (const match of input.matchAll(/\x1b(?:O([AB])|\[[0-9;?]*([AB]))/g)) {
+        const direction = match[1] ?? match[2];
+        delta += direction === "A" ? 1 : -1;
+    }
+    return delta;
+}
 export function mouseScrollDelta(input, linesPerWheel = 3) {
     let delta = 0;
     for (const match of input.matchAll(/\x1b\[<(\d+);\d+;\d+[mM]/g)) {