@giovannijecha/jecode 0.3.2 → 0.5.0

package/dist/start.js

@@ -3,12 +3,16 @@ import * as path from "node:path";
 import { runBatch } from "./batch.js";
 import { showCliInfo } from "./cli-info.js";
 import { loadConfig } from "./config.js";
+import { ConversationTree } from "./conversation.js";
+import { parseLaunch } from "./launch.js";
 import { systemPrompt } from "./prompt.js";
 import { configureProviders, selectProvider } from "./providers/index.js";
+import { SessionPersistence } from "./sessions/runtime.js";
+import { DurableSessionStore } from "./sessions/store.js";
 import { builtinTools } from "./tools/index.js";
 import { configureColor } from "./ui/render.js";
 import { STEEL } from "./ui/theme.js";
-import { emptyUsage } from "./usage.js";
+import { emptyUsage, usageFromHistory } from "./usage.js";
 import { runApp } from "./tui/app.js";
 import { interactive } from "./tui/screen.js";
 export async function start(args = process.argv.slice(2), environment = {}) {
@@ -17,10 +21,17 @@ export async function start(args = process.argv.slice(2), environment = {}) {
     const write = environment.write ?? ((text) => process.stdout.write(text));
     if (await showCliInfo(args, applicationRoot, write))
         return;
-    const config = loadConfig(args);
+    const launch = parseLaunch(args);
+    const config = loadConfig(launch.configArgs);
     configureProviders(config);
     const provider = selectProvider(config.providerId);
     const hasScreen = environment.interactive?.() ?? interactive();
+    if (launch.kind === "resume" && !hasScreen) {
+        throw new Error("resume needs an interactive terminal");
+    }
+    if (launch.kind === "resume" && config.ephemeral) {
+        throw new Error("--ephemeral cannot be combined with resume");
+    }
     // A provider whose catalogue is not fixed has no sensible default model.
     // The TUI can ask; a pipe cannot, so batch mode still requires one up front.
     const model = config.model === "" ? provider.defaultModel : config.model;
@@ -35,13 +46,65 @@ export async function start(args = process.argv.slice(2), environment = {}) {
         palette: STEEL,
         tools: builtinTools(),
         system: systemPrompt(config),
-        history: [],
+        conversation: ConversationTree.empty(),
         usage: emptyUsage(),
     };
     if (hasScreen) {
-        await (environment.runInteractive ?? runApp)(session, transcriptRoot);
+        if (!config.ephemeral) {
+            const store = await DurableSessionStore.open(config.root, environment.sessionsRoot);
+            if (launch.kind === "resume") {
+                const candidates = await SessionPersistence.candidates(store);
+                if (candidates.length === 0)
+                    throw new Error("no resumable sessions found for this workspace");
+                const open = async (id) => {
+                    const resumed = await SessionPersistence.resume(store, id);
+                    try {
+                        applyResumedSession(session, resumed.conversation, resumed.persistence);
+                    }
+                    catch (error) {
+                        await resumed.persistence.close();
+                        throw error;
+                    }
+                };
+                if (launch.latest)
+                    await open(candidates[0].id);
+                else
+                    session.resume = { candidates, open };
+            }
+            else {
+                session.persistence = SessionPersistence.fresh(store);
+            }
+        }
+        try {
+            await (environment.runInteractive ?? runApp)(session, transcriptRoot);
+        }
+        finally {
+            await session.persistence?.close();
+        }
     }
     else {
         await (environment.runNonInteractive ?? runBatch)(session);
     }
 }
+function applyResumedSession(session, conversation, persistence) {
+    const identity = conversation.activeNode?.identity;
+    if (identity === undefined)
+        throw new Error("resumed session has no active turn");
+    const provider = selectProvider(identity.providerId);
+    const config = {
+        ...session.config,
+        providerId: identity.providerId,
+        model: identity.model,
+        effort: identity.effort,
+    };
+    const system = systemPrompt(config);
+    const usage = usageFromHistory(conversation.history);
+    session.config = config;
+    session.provider = provider;
+    session.model = identity.model;
+    session.system = system;
+    session.conversation = conversation;
+    session.usage = usage;
+    session.persistence = persistence;
+    session.resume = undefined;
+}

package/dist/transcript-types.js

@@ -0,0 +1,6 @@
+// Provider-neutral transcript vocabulary.
+//
+// The conversation domain stores these settled semantic blocks so a resumed
+// session can rebuild the same screen without persisting terminal escape
+// sequences or renderer state.
+export {};

package/dist/tui/activity.js

@@ -9,3 +9,6 @@ export function elapsed(activity, now = Date.now()) {
     const minutes = Math.floor(seconds / 60);
     return `${minutes}m ${String(seconds % 60).padStart(2, "0")}s`;
 }
+export function activityStatus(activity, label = activity.label, now = Date.now()) {
+    return `${label} · ${elapsed(activity, now)}`;
+}

package/dist/tui/app-input.js

@@ -21,6 +21,15 @@ export function appInput(options) {
         }
         if (state.feedback !== undefined)
             feedback.dismiss();
+        // Detail expansion remains available while an approval is open. A large
+        // diff may be compacted, but the user must be able to inspect it before
+        // answering the permission prompt.
+        if (key.ctrl && key.name === "o") {
+            const changed = toggleDetails(state.blocks);
+            if (changed !== undefined)
+                options.transcriptChanged(changed);
+            return;
+        }
         if (state.open !== undefined) {
             const outcome = overlay.handle(state.open, key);
             state.open = outcome.open;
@@ -95,12 +104,6 @@ export function appInput(options) {
             options.invalidate();
             return;
         }
-        if (key.ctrl && key.name === "o") {
-            const changed = toggleDetails(state.blocks);
-            if (changed !== undefined)
-                options.transcriptChanged(changed);
-            return;
-        }
         const edited = applyKey(state.editor, key);
         if (edited !== undefined) {
             state.editor = edited;

package/dist/tui/app-workflows.js

@@ -39,7 +39,8 @@ export function appWorkflows(options) {
                     state.status = said ?? activity.label;
                     options.render();
                 },
-                reset: () => {
+                reset: async () => {
+                    await session.persistence?.reset();
                     state.blocks.splice(0);
                     state.past.length = 0;
                     permissions.reset();
@@ -59,11 +60,16 @@ export function appWorkflows(options) {
                 state.closeWhenIdle = true;
         }
         catch (error) {
-            feedback.show({
-                text: activity.control.signal.aborted ? "interrupted" : error.message,
-                tone: activity.control.signal.aborted ? "warn" : "error",
-                timeoutMs: activity.control.signal.aborted ? 4_200 : 6_000,
-            });
+            // Command cancellation is already visible through the dock closing and
+            // the activity ending. Keep it silent instead of replacing the footer
+            // with a redundant warning.
+            if (!activity.control.signal.aborted) {
+                feedback.show({
+                    text: error.message,
+                    tone: "error",
+                    timeoutMs: 6_000,
+                });
+            }
         }
         finally {
             options.finishActivity(activity);
@@ -73,8 +79,14 @@ export function appWorkflows(options) {
         const activity = options.startActivity("turn", WAITING);
         if (activity === undefined)
             return;
+        const parentId = session.conversation.activeNodeId;
+        const history = session.conversation.history;
+        const historyStart = history.length;
+        const blockStart = state.blocks.length;
+        const createdAt = new Date().toISOString();
+        let nodeId;
         options.emit({ kind: "user", text });
-        session.history.push({ role: "user", content: [{ kind: "text", text }] });
+        history.push({ role: "user", content: [{ kind: "text", text }] });
         const events = transcribe({
             emit: options.emit,
             render: options.render,
@@ -90,9 +102,26 @@ export function appWorkflows(options) {
             },
             usage: (usage) => recordUsage(session.usage, usage),
         });
+        events.onCheckpoint = async (checkpoint, settlement) => {
+            const next = session.conversation.commit({
+                ...(nodeId === undefined ? {} : { nodeId }),
+                parentId,
+                createdAt,
+                identity: {
+                    providerId: session.provider.id,
+                    model: session.model,
+                    effort: session.config.effort,
+                },
+                messages: checkpoint.slice(historyStart),
+                blocks: state.blocks.slice(blockStart),
+            }, settlement);
+            await session.persistence?.checkpoint(next);
+            session.conversation = next;
+            nodeId = next.activeNodeId;
+        };
         let finishReason;
         try {
-            await runTurn(session.history, controllerOptions(session, permissions.availableTools()), events, activity.control.signal);
+            await runTurn(history, controllerOptions(session, permissions.availableTools()), events, activity.control.signal);
         }
         catch (error) {
             const interrupted = activity.control.signal.aborted;

package/dist/tui/app.js

@@ -3,7 +3,7 @@
 // Everything mutable about a session lives in `state` here. The view is a pure
 // function of it, so the only job of a key handler is to change state and ask
 // for a repaint — never to draw.
-import { begin } from "./activity.js";
+import { activityStatus, begin } from "./activity.js";
 import * as overlay from "./overlay.js";
 import { options as completionOptions } from "./complete.js";
 import { decoder } from "./keys.js";
@@ -19,6 +19,7 @@ import { appState } from "./app-state.js";
 import { appInput } from "./app-input.js";
 import { appWorkflows } from "./app-workflows.js";
 import { sessionPermissions } from "../permissions.js";
+import { resumePicker } from "./resume.js";
 const FRAME_MS = 16;
 const SPIN_MS = 80;
 /** How long a lone escape waits to prove it is not the start of a sequence. */
@@ -26,10 +27,11 @@ const ESCAPE_MS = 25;
 export async function runApp(session, transcriptRoot, environment = {}) {
     const terminal = environment.screen ?? realScreen;
     const paint = environment.paint ?? painter();
-    const keys = decoder();
+    const keys = decoder({ ctrlBackspaceIsBs: process.env["WT_SESSION"] !== undefined });
     const transcript = transcriptRenderer();
     const workspace = await workspaceLabel(session.config.root);
     const state = appState();
+    state.blocks.push(...session.conversation.transcript);
     const permissions = sessionPermissions(session.tools, session.config.autoApprove);
     let closed;
     let frameTimer;
@@ -43,23 +45,28 @@ export async function runApp(session, transcriptRoot, environment = {}) {
     const done = new Promise((resolve) => {
         closed = resolve;
     });
-    const view = () => ({
-        blocks: state.blocks,
-        editor: state.editor,
-        scroll: state.scroll,
-        unseen: state.unseen,
-        pal: session.palette,
-        footer: footerInfo(session, workspace),
-        status: state.status,
-        feedback: state.feedback,
-        readiness: turnBlocker(session),
-        spin: state.spin,
-        reducedMotion: session.config.reducedMotion,
-        now: Date.now(),
-        modal: overlay.shown(state.open),
-        menu: completionOptions(state.completing),
-        menuIndex: state.completing?.index,
-    });
+    const view = () => {
+        const now = Date.now();
+        return {
+            blocks: state.blocks,
+            editor: state.editor,
+            scroll: state.scroll,
+            unseen: state.unseen,
+            pal: session.palette,
+            footer: footerInfo(session, workspace),
+            status: state.activity === undefined
+                ? undefined
+                : activityStatus(state.activity, state.status ?? state.activity.label, now),
+            feedback: state.feedback,
+            readiness: turnBlocker(session),
+            spin: state.spin,
+            reducedMotion: session.config.reducedMotion,
+            now,
+            modal: overlay.shown(state.open),
+            menu: completionOptions(state.completing),
+            menuIndex: state.completing?.index,
+        };
+    };
     const draw = () => {
         frameTimer = undefined;
         if (!live)
@@ -201,6 +208,44 @@ export async function runApp(session, transcriptRoot, environment = {}) {
         invalidate: () => paint.invalidate(),
         transcriptChanged: (block) => transcript.invalidate(block),
     });
+    const resumeAtLaunch = session.resume === undefined
+        ? undefined
+        : openResumedSession(session.resume);
+    async function openResumedSession(launch) {
+        while (live) {
+            const index = await new Promise((resolve) => {
+                state.open = { picker: resumePicker(launch.candidates, session.palette), settle: resolve };
+                render();
+            });
+            if (index === undefined) {
+                quit();
+                return;
+            }
+            const candidate = launch.candidates[index];
+            if (candidate === undefined)
+                continue;
+            const activity = startActivity("command", "Opening session");
+            if (activity === undefined)
+                return;
+            try {
+                await launch.open(candidate.id);
+                state.blocks.splice(0, state.blocks.length, ...session.conversation.transcript);
+                state.past.length = 0;
+                state.scroll = 0;
+                state.follow = true;
+                state.unseen = 0;
+                state.lastMaxScroll = 0;
+                transcript.invalidate();
+                paint.invalidate();
+                finishActivity(activity);
+                return;
+            }
+            catch (error) {
+                feedback.show({ text: error.message, tone: "error", timeoutMs: 6_000 });
+                finishActivity(activity);
+            }
+        }
+    }
     terminal.enter(session.config.reducedMotion);
     stopResize = terminal.onResize(() => {
         paint.invalidate();
@@ -228,5 +273,12 @@ export async function runApp(session, transcriptRoot, environment = {}) {
         render();
     });
     draw();
-    await done;
+    try {
+        await resumeAtLaunch;
+        if (live)
+            await done;
+    }
+    finally {
+        await session.persistence?.close();
+    }
 }

package/dist/tui/components/composer.js

@@ -7,7 +7,7 @@ export function renderComposer(editor, width, maxInputRows, pal, right = "") {
     const first = Math.max(0, Math.min(laid.lines.length - room, laid.cursor.row));
     const shown = laid.lines.slice(first, first + room);
     return {
-        rows: shown.map((line, index) => row(width, [{ text: line, fg: pal.ink.bright }], index === 0 && right !== "" ? [{ text: right, fg: pal.ink.muted }] : [])),
+        rows: shown.map((line, index) => row(width, [{ text: line, fg: pal.ink.bright }], index === 0 && right !== "" ? [{ text: right, fg: pal.ink.dim }] : [])),
         cursor: { row: laid.cursor.row - first, col: laid.cursor.col },
     };
 }

package/dist/tui/components/footer.js

@@ -5,7 +5,7 @@ export function renderFooter(info, status, width, pal) {
     const right = fitSegs(status, rightLimit);
     const leftRoom = Math.max(0, width - plainLen(right) - (right.length === 0 ? 0 : 1));
     const left = identity(info, leftRoom);
-    return [row(width, left === "" ? [] : [{ text: left, fg: pal.ink.muted }], right)];
+    return [row(width, left === "" ? [] : [{ text: left, fg: pal.ink.dim }], right)];
 }
 function identity(info, cols) {
     if (cols <= 0)

package/dist/tui/components/menu.js

@@ -16,28 +16,40 @@ export function menuWindow(length, selected, visible) {
     return { first, last: Math.min(count, first + room) };
 }
 function renderEntry(entry, labelWidth, width, pal) {
-    // Colour terminals use one quiet selection band and keep every label on the
-    // composer's content edge. Monochrome has no band, so it alone reserves a
-    // fixed arrow column to keep selection visible without shifting peer rows.
+    // Colour terminals spend focus on the active label instead of painting a
+    // full-width band. Monochrome has no colour, so it alone reserves a fixed
+    // arrow column to keep selection visible without shifting peer rows.
     const monochrome = !hasColor();
     const selectedMark = monochrome ? (entry.selected ? "→ " : "  ") : "";
-    const fg = entry.selected ? pal.ink.bright : pal.ink.fg;
+    const fg = entry.selected ? pal.focus : pal.ink.fg;
     const primary = [
-        { text: selectedMark, fg: entry.selected ? pal.accent : fg },
-        { text: entry.label, fg },
+        { text: selectedMark, fg },
+        { text: entry.label, fg, bold: entry.selected || undefined },
     ];
     if (width > 40 && entry.description !== undefined) {
         const gap = Math.max(2, labelWidth - primaryWidth(entry));
-        primary.push({ text: `${" ".repeat(gap)}${entry.description}`, fg: entry.selected ? pal.ink.fg : pal.ink.muted });
+        primary.push({
+            text: `${" ".repeat(gap)}${entry.description}`,
+            fg: entry.selected ? pal.ink.bright : pal.ink.muted,
+        });
     }
-    const right = width > 40 && entry.hint !== undefined
-        ? [{
-                text: elide(entry.hint, Math.max(1, Math.floor(width / 4))),
-                fg: entry.selected ? pal.ink.fg : pal.ink.muted,
-            }]
-        : [];
-    const ground = entry.selected && !monochrome ? pal.surface.inset : undefined;
-    return row(width, primary, right, ground);
+    const value = entry.value === undefined
+        ? undefined
+        : entry.selected && entry.adjustable === true
+            ? `‹ ${entry.value} ›`
+            : entry.value;
+    const summary = [entry.hint, value]
+        .filter((part) => part !== undefined)
+        .join(" · ");
+    const rightColor = entry.selected ? pal.focus : pal.ink.muted;
+    const right = summary === "" || (width <= 40 && entry.value === undefined)
+        ? []
+        : [{
+                text: elide(summary, Math.max(1, Math.floor(entry.value === undefined ? width / 4 : width * 0.45))),
+                fg: rightColor,
+                bold: entry.selected || undefined,
+            }];
+    return row(width, primary, right);
 }
 function primaryWidth(entry) {
     return plainLen([{ text: entry.label }]);

package/dist/tui/components/messages.js

@@ -31,23 +31,9 @@ export function renderReasoning(block, width, pal) {
         : { text: block.text, truncated: false };
     const content = markdown(source.text, inner, pal, inner);
     const visible = expanded ? content : content.slice(-REASONING_PREVIEW_ROWS);
-    const action = expanded
-        ? "ctrl+o compact"
-        : block.live === true && block.expanded === true
-            ? "full when done"
-            : source.truncated || content.length > REASONING_PREVIEW_ROWS
-                ? "ctrl+o full"
-                : undefined;
     return [
         "",
-        row(width, [
-            {
-                text: block.live === true ? "thinking" : "thought",
-                fg: pal.ink.bright,
-                bold: true,
-            },
-        ], action === undefined ? [] : [{ text: action, fg: pal.ink.muted }], undefined, PAD),
-        ...visible.map((line) => row(width, line.segs.map((seg) => ({ ...seg, fg: pal.ink.muted, italic: true })), [], undefined, PAD)),
+        ...visible.map((line) => row(width, line.segs.map((seg) => ({ ...seg, fg: pal.ink.dim, italic: true })), [], undefined, PAD)),
     ];
 }
 export function reasoningPreviewSource(text, width) {

package/dist/tui/components/prompt.js

@@ -7,10 +7,10 @@ export const PROMPT_WIDTH = textWidth(MARK);
 export function promptLine(text, cursor, width, pal, options = {}) {
     const right = options.right === undefined || options.right === ""
         ? []
-        : [{ text: options.right, fg: pal.ink.muted }];
+        : [{ text: options.right, fg: pal.ink.dim }];
     const laid = layout(text, cursor, width, options);
     const content = laid.visible === "" && options.placeholder !== undefined
-        ? { text: options.placeholder, fg: pal.ink.muted }
+        ? { text: options.placeholder, fg: pal.ink.dim }
         : { text: laid.visible, fg: pal.ink.bright };
     return {
         row: row(width, [{ text: MARK, fg: pal.accent }, content], right),

package/dist/tui/components/status.js

@@ -6,7 +6,10 @@ export function renderStatus(info, pal) {
     if (urgent !== undefined)
         return withUnseen(feedbackSegments(urgent, pal), info.unseen, pal);
     if (info.status !== undefined) {
-        return withUnseen([{ text: "esc to interrupt", fg: pal.ink.muted }], info.unseen, pal);
+        return withUnseen([
+            { text: info.status, fg: pal.ink.muted },
+            { text: " · esc to interrupt", fg: pal.ink.dim, optional: true },
+        ], info.unseen, pal);
     }
     if (info.feedback !== undefined) {
         return withUnseen(feedbackSegments(info.feedback, pal), info.unseen, pal);
@@ -30,7 +33,7 @@ function feedbackSegments(feedback, pal) {
 function withUnseen(status, unseen, pal) {
     return unseen === 0
         ? status
-        : [...status, { text: " · ", fg: pal.ink.muted }, ...unseenSegments(unseen, pal)];
+        : [...status, { text: " · ", fg: pal.ink.dim }, ...unseenSegments(unseen, pal)];
 }
 function unseenSegments(unseen, pal) {
     return [{ text: `${unseen} new ↓`, fg: pal.accent, bold: true }];

package/dist/tui/components/tool.js

@@ -2,6 +2,7 @@
 import { hasColor, row } from "../../ui/render.js";
 const OUTPUT_ROWS = 8;
 const LIVE_OUTPUT_ROWS = 6;
+const DIFF_ROWS = 15;
 export function renderTool(block, width, pal, context = {}) {
     const shown = visibleDetails(block);
     const right = liveLabel(block, context);
@@ -11,7 +12,7 @@ export function renderTool(block, width, pal, context = {}) {
             { text: " " },
             { text: `${stateGlyph(block, context)} `, fg: statusInk(block.tone, pal), bold: true },
             { text: block.name, fg: pal.ink.bright, bold: true },
-            ...(block.target === "" ? [] : [{ text: `  ${block.target}`, fg: pal.accent }]),
+            ...(block.target === "" ? [] : [{ text: `  ${block.target}`, fg: pal.technical }]),
         ], right === "" ? [] : [{ text: right, fg: statusInk(block.tone, pal) }]),
         ...shown.map((detail) => renderDetail(detail, block.tone, width, pal)),
     ];
@@ -31,8 +32,24 @@ function visibleDetails(block) {
         return [{ kind: "gap", text: note }, ...all.slice(-limit)];
     }
     // The compact transcript is an audit of what changed, not a code excerpt.
-    // Context and gap rows remain in semantic state for the explicit full view.
-    return all.filter((detail) => detail.kind === "add" || detail.kind === "del");
+    // One shared budget applies to writes and edits. Keep both ends so a large
+    // replacement cannot show only deletions while hiding all new content.
+    // Context, omitted changes, and gap rows remain in semantic state for the
+    // explicit full view.
+    const changed = all.filter((detail) => detail.kind === "add" || detail.kind === "del");
+    if (changed.length <= DIFF_ROWS)
+        return changed;
+    const leading = Math.ceil(DIFF_ROWS / 2);
+    const trailing = DIFF_ROWS - leading;
+    const hidden = changed.length - DIFF_ROWS;
+    return [
+        ...changed.slice(0, leading),
+        {
+            kind: "gap",
+            text: `… ${hidden} more changed ${hidden === 1 ? "line" : "lines"} · ctrl+o expand`,
+        },
+        ...changed.slice(-trailing),
+    ];
 }
 function renderDetail(detail, tone, width, pal) {
     const lead = { text: " " };
@@ -42,7 +59,7 @@ function renderDetail(detail, tone, width, pal) {
         return row(width, [lead, rail, { text: detail.text === "" ? " " : detail.text, fg }]);
     }
     if (detail.kind === "gap") {
-        return row(width, [lead, rail, { text: detail.text, fg: pal.ink.muted, italic: true }]);
+        return row(width, [lead, rail, { text: detail.text, fg: pal.ink.dim, italic: true }]);
     }
     const number = detail.kind === "add" ? detail.newLine : detail.oldLine;
     const prefix = `${detail.kind === "add" ? "+" : detail.kind === "del" ? "-" : " "}${String(number ?? "").padStart(3)} `;
@@ -50,7 +67,7 @@ function renderDetail(detail, tone, width, pal) {
         ? pal.ink.added
         : detail.kind === "del"
             ? pal.ink.removed
-            : pal.ink.muted;
+            : pal.ink.dim;
     return row(width, [lead, rail, { text: prefix, fg }, ...emphasized(detail.text, detail.emphasis, fg)]);
 }
 function emphasized(text, emphasis, fg) {

package/dist/tui/editor.js

@@ -43,15 +43,25 @@ export function wordLeft(state) {
     return { ...state, cursor: startOfWordBefore(state.text, state.cursor) };
 }
 export function wordRight(state) {
-    return { ...state, cursor: endOfWordAfter(state.text, state.cursor) };
+    return { ...state, cursor: startOfWordAfter(state.text, state.cursor) };
 }
 /** ctrl+w — delete the word behind the cursor. */
 export function killWord(state) {
-    const from = startOfWordBefore(state.text, state.cursor);
+    const from = startOfDeletionBefore(state.text, state.cursor);
     if (from === state.cursor)
         return state;
     return { text: state.text.slice(0, from) + state.text.slice(state.cursor), cursor: from };
 }
+/** ctrl+delete — delete the word ahead of the cursor. */
+export function killNextWord(state) {
+    const to = endOfDeletionAfter(state.text, state.cursor);
+    if (to === state.cursor)
+        return state;
+    return {
+        text: state.text.slice(0, state.cursor) + state.text.slice(to),
+        cursor: state.cursor,
+    };
+}
 /** ctrl+u — delete everything behind the cursor. */
 export function killToStart(state) {
     return { text: state.text.slice(state.cursor), cursor: 0 };
@@ -89,17 +99,54 @@ function after(text, cursor) {
 }
 function startOfWordBefore(text, cursor) {
     let i = cursor;
-    while (i > 0 && text[i - 1] === " ")
+    while (i > 0 && whitespace(text[i - 1]))
         i--;
-    while (i > 0 && text[i - 1] !== " ")
+    while (i > 0 && !whitespace(text[i - 1]))
         i--;
     return i;
 }
-function endOfWordAfter(text, cursor) {
+function startOfWordAfter(text, cursor) {
     let i = cursor;
-    while (i < text.length && text[i] === " ")
+    while (i < text.length && !whitespace(text[i]))
         i++;
-    while (i < text.length && text[i] !== " ")
+    while (i < text.length && whitespace(text[i]))
         i++;
     return i;
 }
+function startOfDeletionBefore(text, cursor) {
+    if (text[cursor - 1] === "\n")
+        return cursor - 1;
+    let i = cursor;
+    while (i > 0 && horizontalWhitespace(text[i - 1]))
+        i--;
+    if (text[i - 1] === "\n")
+        return i;
+    while (i > 0 && !whitespace(text[i - 1]))
+        i--;
+    return i;
+}
+function endOfDeletionAfter(text, cursor) {
+    if (text[cursor] === "\n")
+        return cursor + 1;
+    let i = cursor;
+    if (horizontalWhitespace(text[i])) {
+        while (i < text.length && horizontalWhitespace(text[i]))
+            i++;
+        if (text[i] === "\n")
+            return i;
+        while (i < text.length && !whitespace(text[i]))
+            i++;
+        return i;
+    }
+    while (i < text.length && !whitespace(text[i]))
+        i++;
+    while (i < text.length && horizontalWhitespace(text[i]))
+        i++;
+    return i;
+}
+function horizontalWhitespace(value) {
+    return value !== undefined && value !== "\n" && /\s/u.test(value);
+}
+function whitespace(value) {
+    return value !== undefined && /\s/u.test(value);
+}