blots-editor 0.0.17 → 0.0.18

package/asset/language/en.json

@@ -9,7 +9,7 @@
   "settings.language.zh": "中文",
   "settings.sensitivity.cursor": "Cursor Wheel Sensitivity",
   "settings.sensitivity.view": "View Scroll Sensitivity",
-  "settings.sensitivity.hint": "Click or drag to adjust",
+  "settings.slider.hint": "Click or drag to adjust",
   "settings.back": "Back",
   "editor.mode.insert": "INSERT",
   "editor.mode.normal": "NORMAL",
@@ -31,6 +31,8 @@
   "settings.fileTreeRoot": "FileTree Root",
   "settings.fileTreeRoot.startup": "Startup directory",
   "settings.fileTreeRoot.custom": "Custom path",
+  "settings.mergeWindow": "Undo Merge Window",
+  "settings.mergeWindow.off": "Off",
   "settings.ok": "OK",
   "settings.cancel": "Cancel"
 }

package/asset/language/zh.json

@@ -9,7 +9,7 @@
   "settings.language.zh": "中文",
   "settings.sensitivity.cursor": "光标滚动灵敏度",
   "settings.sensitivity.view": "视图滚动灵敏度",
-  "settings.sensitivity.hint": "点击或拖动调整",
+  "settings.slider.hint": "点击或拖动调整",
   "settings.back": "返回",
   "editor.mode.insert": "插入",
   "editor.mode.normal": "普通",
@@ -31,6 +31,8 @@
   "settings.fileTreeRoot": "文件树根目录",
   "settings.fileTreeRoot.startup": "启动目录",
   "settings.fileTreeRoot.custom": "自定义路径",
+  "settings.mergeWindow": "撤销合并时间",
+  "settings.mergeWindow.off": "关闭",
   "settings.ok": "确定",
   "settings.cancel": "取消"
 }

package/dist/core/document/history.d.ts

@@ -0,0 +1,74 @@
+import type { Document } from "./document.js";
+import type { EditOperation } from "./operations.js";
+import type { Position } from "./position.js";
+/** One undoable edit: the operation plus the cursor before and after it ran. */
+export type HistoryEntry = {
+    op: EditOperation;
+    /** Cursor before `apply`; undo leaves the cursor here. */
+    cursorBefore: Position;
+    /** Cursor after `apply`; redo leaves the cursor here, and undo starts here. */
+    cursorAfter: Position;
+    /** When the edit ran, used to group consecutive edits into one undo step. */
+    time: number;
+};
+/**
+ * Linear undo/redo stack over {@link EditOperation}s.
+ *
+ * Stores each operation together with the cursor positions around it. The
+ * cursor is part of the record — not reconstructed from the operation —
+ * because editing and cursor movement are independent: the user may move the
+ * cursor (an action that is not itself undoable) before pressing undo, so the
+ * position `invert` expects cannot be assumed to still hold.
+ *
+ * A burst of mergeable edits (see {@link EditOperation.merge}) that land next
+ * to each other within the merge window collapses into one entry, so typing a
+ * word undoes as a word rather than a character. Any other edit, a cursor
+ * move, or a pause longer than the window starts a new entry. The window is a
+ * user setting (see `setMergeWindow`); `0` disables merging.
+ */
+export declare class History {
+    private readonly _undo;
+    private readonly _redo;
+    private readonly _limit;
+    private readonly _now;
+    private _mergeWindow;
+    constructor(limit?: number, now?: () => number);
+    /**
+     * Set the coalescing window in ms. Edits closer together than this share an
+     * undo step; `0` disables merging, so every edit stands alone.
+     */
+    setMergeWindow(ms: number): void;
+    canUndo(): boolean;
+    canRedo(): boolean;
+    /**
+     * Apply `op` and record it. Capturing the cursor here (rather than in the
+     * caller) keeps the entry and the operation's effects in sync by
+     * construction. A new edit discards the redo branch, since the document
+     * has diverged from the state those entries would replay onto.
+     *
+     * A no-op edit (e.g. backspace at the document start) is not recorded: its
+     * inverse would do nothing, so an entry for it would only make the user
+     * press undo twice to skip past it and would evict real history at the
+     * limit. Leaving the redo branch intact is correct too — the document did
+     * not diverge from the state those entries replay onto.
+     */
+    run(op: EditOperation, doc: Document): void;
+    /**
+     * Fold `entry` into `top` when it continues the same edit: the newer
+     * cursor picks up where the older left off, the operation agrees to merge,
+     * and the gap is within the time window. Returns false when `entry` must
+     * start its own step. Mutating `top.op` only happens on success, since
+     * {@link EditOperation.merge} is a no-op when it returns false.
+     */
+    private _merge;
+    /** Undo the last edit; returns false when the undo stack is empty. */
+    undo(doc: Document): boolean;
+    /** Redo the last undone edit; returns false when the redo stack is empty. */
+    redo(doc: Document): boolean;
+    /**
+     * Drop all history. Required after replacing the document wholesale
+     * (`Document.setText`), since the recorded positions then refer to a
+     * different text.
+     */
+    clear(): void;
+}

package/dist/core/document/history.js

@@ -0,0 +1,136 @@
+import { MERGE_WINDOW_DEFAULT } from "../settings/schema.js";
+/**
+ * Linear undo/redo stack over {@link EditOperation}s.
+ *
+ * Stores each operation together with the cursor positions around it. The
+ * cursor is part of the record — not reconstructed from the operation —
+ * because editing and cursor movement are independent: the user may move the
+ * cursor (an action that is not itself undoable) before pressing undo, so the
+ * position `invert` expects cannot be assumed to still hold.
+ *
+ * A burst of mergeable edits (see {@link EditOperation.merge}) that land next
+ * to each other within the merge window collapses into one entry, so typing a
+ * word undoes as a word rather than a character. Any other edit, a cursor
+ * move, or a pause longer than the window starts a new entry. The window is a
+ * user setting (see `setMergeWindow`); `0` disables merging.
+ */
+export class History {
+    _undo = [];
+    _redo = [];
+    _limit;
+    _now;
+    _mergeWindow = MERGE_WINDOW_DEFAULT;
+    constructor(limit = 200, now = Date.now) {
+        this._limit = limit;
+        this._now = now;
+    }
+    /**
+     * Set the coalescing window in ms. Edits closer together than this share an
+     * undo step; `0` disables merging, so every edit stands alone.
+     */
+    setMergeWindow(ms) {
+        this._mergeWindow = ms;
+    }
+    canUndo() {
+        return this._undo.length > 0;
+    }
+    canRedo() {
+        return this._redo.length > 0;
+    }
+    /**
+     * Apply `op` and record it. Capturing the cursor here (rather than in the
+     * caller) keeps the entry and the operation's effects in sync by
+     * construction. A new edit discards the redo branch, since the document
+     * has diverged from the state those entries would replay onto.
+     *
+     * A no-op edit (e.g. backspace at the document start) is not recorded: its
+     * inverse would do nothing, so an entry for it would only make the user
+     * press undo twice to skip past it and would evict real history at the
+     * limit. Leaving the redo branch intact is correct too — the document did
+     * not diverge from the state those entries replay onto.
+     */
+    run(op, doc) {
+        const before = doc.cursor;
+        if (!op.apply(doc)) {
+            return;
+        }
+        const after = doc.cursor;
+        const entry = {
+            op,
+            cursorBefore: { line: before.line, logical: before.logical },
+            cursorAfter: { line: after.line, logical: after.logical },
+            time: this._now(),
+        };
+        const top = this._undo[this._undo.length - 1];
+        if (!(top && this._merge(top, entry))) {
+            this._undo.push(entry);
+            if (this._undo.length > this._limit) {
+                this._undo.shift();
+            }
+        }
+        this._redo.length = 0;
+    }
+    /**
+     * Fold `entry` into `top` when it continues the same edit: the newer
+     * cursor picks up where the older left off, the operation agrees to merge,
+     * and the gap is within the time window. Returns false when `entry` must
+     * start its own step. Mutating `top.op` only happens on success, since
+     * {@link EditOperation.merge} is a no-op when it returns false.
+     */
+    _merge(top, entry) {
+        if (entry.time - top.time >= this._mergeWindow) {
+            return false;
+        }
+        if (entry.cursorBefore.line !== top.cursorAfter.line ||
+            entry.cursorBefore.logical !== top.cursorAfter.logical) {
+            return false;
+        }
+        if (!top.op.merge?.(entry.op)) {
+            return false;
+        }
+        // The merged operation now spans both edits: its end cursor moves to
+        // the newer entry's, and the timestamp advances so a pause after this
+        // edit still ends the group.
+        top.cursorAfter = entry.cursorAfter;
+        top.time = entry.time;
+        return true;
+    }
+    /** Undo the last edit; returns false when the undo stack is empty. */
+    undo(doc) {
+        const entry = this._undo.pop();
+        if (!entry) {
+            return false;
+        }
+        // invert() assumes the cursor sits where apply() left it — restore
+        // cursorAfter first, or a since-moved cursor makes it delete the wrong
+        // span. cursorBefore after the invert is the position the user expects.
+        doc.setCursor(entry.cursorAfter.line, entry.cursorAfter.logical);
+        entry.op.invert(doc);
+        doc.setCursor(entry.cursorBefore.line, entry.cursorBefore.logical);
+        this._redo.push(entry);
+        return true;
+    }
+    /** Redo the last undone edit; returns false when the redo stack is empty. */
+    redo(doc) {
+        const entry = this._redo.pop();
+        if (!entry) {
+            return false;
+        }
+        // apply() runs against the pre-edit document, so restore cursorBefore
+        // first; apply() then reproduces cursorAfter on its own.
+        doc.setCursor(entry.cursorBefore.line, entry.cursorBefore.logical);
+        entry.op.apply(doc);
+        doc.setCursor(entry.cursorAfter.line, entry.cursorAfter.logical);
+        this._undo.push(entry);
+        return true;
+    }
+    /**
+     * Drop all history. Required after replacing the document wholesale
+     * (`Document.setText`), since the recorded positions then refer to a
+     * different text.
+     */
+    clear() {
+        this._undo.length = 0;
+        this._redo.length = 0;
+    }
+}

package/dist/core/document/operations.d.ts

@@ -9,33 +9,47 @@ import type { Document } from "./document.js";
  * cursor before inverting.
  */
 export type EditOperation = {
-    apply(doc: Document): void;
+    /**
+     * Apply the edit in place. Returns false when the edit was a no-op (the
+     * document is unchanged), so history can skip recording a dead step.
+     */
+    apply(doc: Document): boolean;
     invert(doc: Document): void;
+    /**
+     * Absorb a following edit into this one so the two share a single undo
+     * step (e.g. two adjacent insertions form one typed run). Returns true
+     * after folding `next` in, or false when the edit kind differs and they
+     * must stay separate. History calls this only for edits whose cursors are
+     * adjacent and within its merge window, so contiguity can be assumed.
+     */
+    merge?(next: EditOperation): boolean;
 };
 /** Insert a string at the cursor; invert deletes exactly the inserted text. */
 export declare class InsertTextOp implements EditOperation {
-    private readonly text;
+    private text;
     constructor(text: string);
-    apply(doc: Document): void;
+    apply(doc: Document): boolean;
     invert(doc: Document): void;
+    /** Merge only with another insertion; anything else ends the typed run. */
+    merge(next: EditOperation): boolean;
 }
 /** Backspace: delete the char before the cursor, or join with the previous line at column 0. */
 export declare class DeleteBeforeOp implements EditOperation {
     private _deletedChar;
     private _joined;
-    apply(doc: Document): void;
+    apply(doc: Document): boolean;
     invert(doc: Document): void;
 }
 /** Delete key: remove the char after the cursor, or join with the next line at end of line. */
 export declare class DeleteAfterOp implements EditOperation {
     private _deletedChar;
     private _joined;
-    apply(doc: Document): void;
+    apply(doc: Document): boolean;
     invert(doc: Document): void;
 }
 /** Enter: split the current line at the cursor; invert rejoins the two lines. */
 export declare class SplitLineOp implements EditOperation {
-    apply(doc: Document): void;
+    apply(doc: Document): boolean;
     invert(doc: Document): void;
 }
 /**
@@ -45,17 +59,18 @@ export declare class SplitLineOp implements EditOperation {
  */
 export declare class JoinLineOp implements EditOperation {
     private _joinAt;
-    apply(doc: Document): void;
+    private _joined;
+    apply(doc: Document): boolean;
     invert(doc: Document): void;
 }
 /** Indent the current line by `indentWidth` spaces, moving the cursor along. */
 export declare class IndentOp implements EditOperation {
-    apply(doc: Document): void;
+    apply(doc: Document): boolean;
     invert(doc: Document): void;
 }
 /** Outdent up to `indentWidth` leading spaces; invert re-adds exactly what was removed. */
 export declare class OutdentOp implements EditOperation {
     private _removed;
-    apply(doc: Document): void;
+    apply(doc: Document): boolean;
     invert(doc: Document): void;
 }

package/dist/core/document/operations.js

@@ -9,6 +9,7 @@ export class InsertTextOp {
         const cur = doc.getLine(line);
         doc.setLine(line, cur.slice(0, logical) + this.text + cur.slice(logical));
         doc.setCursor(line, logical + this.text.length);
+        return true;
     }
     invert(doc) {
         const { line, logical } = doc.cursor;
@@ -17,6 +18,14 @@ export class InsertTextOp {
         doc.setLine(line, cur.slice(0, start) + cur.slice(logical));
         doc.setCursor(line, start);
     }
+    /** Merge only with another insertion; anything else ends the typed run. */
+    merge(next) {
+        if (!(next instanceof InsertTextOp)) {
+            return false;
+        }
+        this.text += next.text;
+        return true;
+    }
 }
 /** Backspace: delete the char before the cursor, or join with the previous line at column 0. */
 export class DeleteBeforeOp {
@@ -35,6 +44,7 @@ export class DeleteBeforeOp {
             this._joined = false;
             doc.setLine(line, cur.slice(0, logical - units) + cur.slice(logical));
             doc.setCursor(line, logical - units);
+            return true;
         }
         else if (line > 0) {
             const prev = doc.getLine(line - 1);
@@ -43,7 +53,9 @@ export class DeleteBeforeOp {
             doc.removeLineAt(line);
             doc.setCursor(line - 1, prev.length);
             this._joined = true;
+            return true;
         }
+        return false;
     }
     invert(doc) {
         if (!this._joined) {
@@ -78,13 +90,16 @@ export class DeleteAfterOp {
             this._deletedChar = cur.slice(logical, logical + units);
             this._joined = false;
             doc.setLine(line, cur.slice(0, logical) + cur.slice(logical + units));
+            return true;
         }
         else if (line < doc.lineCount - 1) {
             const next = doc.getLine(line + 1);
             doc.setLine(line, cur + next);
             doc.removeLineAt(line + 1);
             this._joined = true;
+            return true;
         }
+        return false;
     }
     invert(doc) {
         if (!this._joined) {
@@ -108,6 +123,7 @@ export class SplitLineOp {
         doc.setLine(line, cur.slice(0, logical));
         doc.insertLineAt(line + 1, cur.slice(logical));
         doc.setCursor(line + 1, 0);
+        return true;
     }
     invert(doc) {
         // Cursor is on the newly created line; the split point is its own start.
@@ -126,18 +142,27 @@ export class SplitLineOp {
  */
 export class JoinLineOp {
     _joinAt = 0;
+    _joined = false;
     apply(doc) {
+        this._joined = false;
         const { line } = doc.cursor;
         if (line >= doc.lineCount - 1) {
-            return;
+            return false;
         }
         const cur = doc.getLine(line);
         const next = doc.getLine(line + 1);
         this._joinAt = cur.length;
+        this._joined = true;
         doc.setLine(line, cur + next);
         doc.removeLineAt(line + 1);
+        return true;
     }
     invert(doc) {
+        // apply() no-ops on the last line; inverting that split would corrupt
+        // the document, so mirror the no-op.
+        if (!this._joined) {
+            return;
+        }
         const { line } = doc.cursor;
         const cur = doc.getLine(line);
         doc.setLine(line, cur.slice(0, this._joinAt));
@@ -152,6 +177,7 @@ export class IndentOp {
         const spaces = " ".repeat(doc.indentWidth);
         doc.setLine(line, spaces + cur);
         doc.setCursor(line, logical + doc.indentWidth);
+        return true;
     }
     invert(doc) {
         const { line, logical } = doc.cursor;
@@ -172,7 +198,9 @@ export class OutdentOp {
         if (remove > 0) {
             doc.setLine(line, cur.slice(remove));
             doc.setCursor(line, Math.max(0, logical - remove));
+            return true;
         }
+        return false;
     }
     invert(doc) {
         if (this._removed === 0) {

package/dist/core/editor-controller.d.ts

@@ -1,24 +1,36 @@
 import { Document } from "./document/document.js";
+import { History } from "./document/history.js";
+import { type EditOperation } from "./document/operations.js";
 export type EditorOptions = {
     indentWidth?: number;
 };
 export type EditorCommandArgs = Record<string, unknown> | undefined;
-export type EditorCommandHandler = (doc: Document, args: EditorCommandArgs) => void;
+/**
+ * A command handler. Returning an {@link EditOperation} makes the command
+ * undoable — `execute` routes the operation through the {@link History},
+ * which applies it and records the cursor positions around it. Returning
+ * nothing marks a command that mutates the document directly or only moves
+ * the cursor; neither is recorded.
+ */
+export type EditorCommandHandler = (doc: Document, args: EditorCommandArgs) => EditOperation | void;
 type ChangeListener = () => void;
 /**
  * Coordinator between the pure core and the keymap/render layers.
  *
  * Owns the document, a command registry (so P2 vim mode only swaps key
- * bindings, never touching the core), and the change-notification channel
- * the view subscribes to. Editing commands run operations that carry their
- * own `invert`; the history stack (P1) will collect them.
+ * bindings, never touching the core), the change-notification channel the
+ * view subscribes to, and the undo/redo {@link History}. Editing commands
+ * return an atomic operation carrying its own `invert`, which `execute`
+ * routes through the history; movement commands return nothing.
  */
 export declare class EditorController {
     private readonly _document;
     private readonly _commands;
     private readonly _listeners;
+    private readonly _history;
     constructor(text: string, options?: EditorOptions);
     get document(): Document;
+    get history(): History;
     onChange(listener: ChangeListener): () => void;
     defineCommand(id: string, handler: EditorCommandHandler): this;
     execute(id: string, args?: EditorCommandArgs): void;

package/dist/core/editor-controller.js

@@ -1,17 +1,20 @@
 import { Document } from "./document/document.js";
+import { History } from "./document/history.js";
 import { DeleteAfterOp, DeleteBeforeOp, IndentOp, InsertTextOp, JoinLineOp, OutdentOp, SplitLineOp, } from "./document/operations.js";
 /**
  * Coordinator between the pure core and the keymap/render layers.
  *
  * Owns the document, a command registry (so P2 vim mode only swaps key
- * bindings, never touching the core), and the change-notification channel
- * the view subscribes to. Editing commands run operations that carry their
- * own `invert`; the history stack (P1) will collect them.
+ * bindings, never touching the core), the change-notification channel the
+ * view subscribes to, and the undo/redo {@link History}. Editing commands
+ * return an atomic operation carrying its own `invert`, which `execute`
+ * routes through the history; movement commands return nothing.
  */
 export class EditorController {
     _document;
     _commands = new Map();
     _listeners = new Set();
+    _history = new History();
     constructor(text, options = {}) {
         this._document = new Document(text, { indentWidth: options.indentWidth });
         this._registerBuiltins();
@@ -19,6 +22,9 @@ export class EditorController {
     get document() {
         return this._document;
     }
+    get history() {
+        return this._history;
+    }
     onChange(listener) {
         this._listeners.add(listener);
         return () => {
@@ -34,33 +40,33 @@ export class EditorController {
         if (!handler) {
             throw new Error(`[ink-cartridge] Unknown editor command: ${id}`);
         }
-        handler(this._document, args);
+        const op = handler(this._document, args);
+        if (op) {
+            this._history.run(op, this._document);
+        }
         this._listeners.forEach((fn) => fn());
     }
     _registerBuiltins() {
-        this.defineCommand("editor.insertText", (doc, args) => {
+        // Editing commands return their operation instead of applying it:
+        // `execute` hands it to the history, which applies it and records the
+        // cursor positions around it (see History.run).
+        this.defineCommand("editor.insertText", (_doc, args) => {
             const text = typeof args?.text === "string" ? args.text : "";
-            if (text) {
-                new InsertTextOp(text).apply(doc);
-            }
-        });
-        this.defineCommand("editor.deleteBefore", (doc) => {
-            new DeleteBeforeOp().apply(doc);
-        });
-        this.defineCommand("editor.deleteAfter", (doc) => {
-            new DeleteAfterOp().apply(doc);
-        });
-        this.defineCommand("editor.splitLine", (doc) => {
-            new SplitLineOp().apply(doc);
-        });
-        this.defineCommand("editor.joinLine", (doc) => {
-            new JoinLineOp().apply(doc);
+            return text ? new InsertTextOp(text) : undefined;
         });
-        this.defineCommand("editor.indent", (doc) => {
-            new IndentOp().apply(doc);
+        this.defineCommand("editor.deleteBefore", () => new DeleteBeforeOp());
+        this.defineCommand("editor.deleteAfter", () => new DeleteAfterOp());
+        this.defineCommand("editor.splitLine", () => new SplitLineOp());
+        this.defineCommand("editor.joinLine", () => new JoinLineOp());
+        this.defineCommand("editor.indent", () => new IndentOp());
+        this.defineCommand("editor.outdent", () => new OutdentOp());
+        // Undo/redo drive the history directly; they are not edits themselves,
+        // so they return nothing and are never recorded.
+        this.defineCommand("history.undo", () => {
+            this._history.undo(this._document);
         });
-        this.defineCommand("editor.outdent", (doc) => {
-            new OutdentOp().apply(doc);
+        this.defineCommand("history.redo", () => {
+            this._history.redo(this._document);
         });
         this.defineCommand("cursor.moveLeft", (doc) => doc.moveLeft());
         this.defineCommand("cursor.moveRight", (doc) => doc.moveRight());

package/dist/core/io/session.js

@@ -73,6 +73,9 @@ export class EditorSession {
             return { ok: false, error: "Binary file" };
         }
         this._controller.document.setText(text);
+        // Recorded positions refer to the previous text, so the history is
+        // meaningless once the document is replaced.
+        this._controller.history.clear();
         this._filePath = filePath;
         // Hash the NORMALIZED document text, not the raw disk bytes: the
         // document normalizes CRLF to LF, so hashing the raw text would

package/dist/core/settings/schema.d.ts

@@ -9,6 +9,16 @@ import { z } from "zod";
  */
 /** Wheel sensitivity in visual lines per notch, 1.0–10.0, 0.5 steps. */
 export declare const sensitivitySchema: z.ZodDefault<z.ZodNumber>;
+/** Undo coalescing range in ms; `0` disables merging. */
+export declare const MERGE_WINDOW_MIN = 0;
+export declare const MERGE_WINDOW_MAX = 2000;
+export declare const MERGE_WINDOW_STEP = 100;
+export declare const MERGE_WINDOW_DEFAULT = 500;
+/**
+ * Consecutive mergeable edits closer than this (ms) collapse into one undo
+ * step. `0` turns merging off, so every edit is its own step.
+ */
+export declare const mergeWindowSchema: z.ZodDefault<z.ZodNumber>;
 /** File-tree root source: the process startup directory or a custom path. */
 export declare const fileTreeRootSchema: z.ZodDefault<z.ZodEnum<{
     startup: "startup";
@@ -27,10 +37,14 @@ export declare const settingsSchema: z.ZodObject<{
         }>>;
         customPath: z.ZodDefault<z.ZodString>;
     }, z.core.$strip>>;
+    history: z.ZodDefault<z.ZodObject<{
+        mergeWindow: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>>;
 }, z.core.$strip>;
 export type EditorSettings = z.infer<typeof settingsSchema>;
 export type WheelSensitivity = EditorSettings["wheel"];
 export type FileTreeSettings = EditorSettings["fileTree"];
+export type HistorySettings = EditorSettings["history"];
 export declare const DEFAULT_SETTINGS: EditorSettings;
 /** Parse an unknown persisted value, falling back to defaults on any failure. */
 export declare function parseSettings(raw: unknown): EditorSettings;

package/dist/core/settings/schema.js

@@ -14,6 +14,22 @@ export const sensitivitySchema = z
     .max(10)
     .step(0.5)
     .default(1);
+/** Undo coalescing range in ms; `0` disables merging. */
+export const MERGE_WINDOW_MIN = 0;
+export const MERGE_WINDOW_MAX = 2000;
+export const MERGE_WINDOW_STEP = 100;
+export const MERGE_WINDOW_DEFAULT = 500;
+/**
+ * Consecutive mergeable edits closer than this (ms) collapse into one undo
+ * step. `0` turns merging off, so every edit is its own step.
+ */
+export const mergeWindowSchema = z
+    .number()
+    .int()
+    .min(MERGE_WINDOW_MIN)
+    .max(MERGE_WINDOW_MAX)
+    .multipleOf(MERGE_WINDOW_STEP)
+    .default(MERGE_WINDOW_DEFAULT);
 const DEFAULT_WHEEL = { cursor: 1, view: 3 };
 /** File-tree root source: the process startup directory or a custom path. */
 export const fileTreeRootSchema = z.enum(["startup", "custom"]).default("startup");
@@ -36,11 +52,18 @@ export const settingsSchema = z.object({
         customPath: z.string().default(""),
     })
         .default({ root: "startup", customPath: "" }),
+    history: z
+        .object({
+        /** Undo coalescing window in ms; see {@link mergeWindowSchema}. */
+        mergeWindow: mergeWindowSchema,
+    })
+        .default({ mergeWindow: MERGE_WINDOW_DEFAULT }),
 });
 export const DEFAULT_SETTINGS = {
     language: "en",
     wheel: DEFAULT_WHEEL,
     fileTree: { root: "startup", customPath: "" },
+    history: { mergeWindow: MERGE_WINDOW_DEFAULT },
 };
 /** Parse an unknown persisted value, falling back to defaults on any failure. */
 export function parseSettings(raw) {

package/dist/core/settings/useSettings.d.ts

@@ -18,6 +18,10 @@ export type SettingsApi = {
     setLanguage: (code: string) => void;
     /** Persist the file-tree root settings. */
     setFileTree: (fileTree: EditorSettings["fileTree"]) => void;
+    /** Set the undo merge window (ms) and persist it immediately. */
+    setMergeWindow: (ms: number) => void;
+    /** Update the merge window in memory only (while dragging); commit on release. */
+    setMergeWindowDraft: (ms: number) => void;
 };
 /**
  * React binding for the shared {@link settingsStore}. Re-renders subscribers

package/dist/core/settings/useSettings.js

@@ -27,6 +27,14 @@ export function useSettings() {
             commit: () => settingsStore.commit(),
             setLanguage: (code) => settingsStore.persist({ ...settings, language: code }),
             setFileTree: (fileTree) => settingsStore.persist({ ...settings, fileTree }),
+            setMergeWindow: (ms) => settingsStore.persist({
+                ...settings,
+                history: { ...settings.history, mergeWindow: ms },
+            }),
+            setMergeWindowDraft: (ms) => settingsStore.update({
+                ...settings,
+                history: { ...settings.history, mergeWindow: ms },
+            }),
         };
     }, [settings]);
 }

package/dist/view/page/editor.js

@@ -152,6 +152,11 @@ export function Editor({ value: initialText = "", lineNumberRightSpacing = 1, cu
     useEffect(() => {
         return boundKeyboard(["ctrl+tab"], () => setToolbarOpen((open) => !open));
     }, [boundKeyboard]);
+    // Keep the coalescing window in step with the persisted setting; edits
+    // closer together than it share one undo step (0 disables merging).
+    useEffect(() => {
+        controller.history.setMergeWindow(settings.history.mergeWindow);
+    }, [controller, settings.history.mergeWindow]);
     useEffect(() => {
         const removeWildcard = enableWildcardPriority();
         const unbinds = [];
@@ -258,6 +263,9 @@ export function Editor({ value: initialText = "", lineNumberRightSpacing = 1, cu
         bind([":"], () => openCommandBar(), { mode: "normal" });
         // Ctrl+S saves in normal mode (Vim-style; insert stays untouched).
         bind(["ctrl+s"], () => session.save(), { mode: "normal" });
+        // Undo/redo also live in normal mode; insert stays untouched.
+        bind(["u"], () => controller.execute("history.undo"), { mode: "normal" });
+        bind(["ctrl+r"], () => controller.execute("history.redo"), { mode: "normal" });
         return () => {
             removeWildcard();
             unbinds.forEach((fn) => fn());

package/dist/view/page/settings.js

@@ -2,9 +2,10 @@ import { useI18n } from "@cartridge-engine/i18n";
 import { Box, Text } from "ink";
 import { back, ModalLayerElementContext, useKeyboard, useMouseRegion, useScreenSystem, } from "ink-cartridge";
 import React, { useCallback, useContext, useEffect, useMemo, useRef, useState, } from "react";
+import { MERGE_WINDOW_MAX, MERGE_WINDOW_MIN, MERGE_WINDOW_STEP, } from "../../core/settings/schema.js";
 import { useSettings } from "../../core/settings/useSettings.js";
 import { ModalFrame } from "../utils/modal-frame.js";
-import { SensitivityBar, snapSensitivity } from "../utils/sensitivity-bar.js";
+import { SensitivityBar, Slider, snapSensitivity, snapValue, } from "../utils/sensitivity-bar.js";
 const LANGUAGES = [
     { code: "en", labelKey: "settings.language.en" },
     { code: "zh", labelKey: "settings.language.zh" },
@@ -96,6 +97,42 @@ function SensitivityPicker({ sensitivityKey }) {
             value.toFixed(1),
             "\u00D7")));
 }
+/**
+ * Modal slider for the undo merge window. The bar is drag/click driven;
+ * dragging updates in memory only, release/click persists. `0` disables
+ * merging, so the label reads "off" instead of the bare number.
+ */
+function MergeWindowPicker() {
+    const ctx = useContext(ModalLayerElementContext);
+    const { t } = useI18n();
+    const { boundKeyboard } = useKeyboard();
+    const { closeModalLayer } = useScreenSystem();
+    const { settings, setMergeWindow, setMergeWindowDraft, commit } = useSettings();
+    const value = settings.history.mergeWindow;
+    useEffect(() => {
+        if (!ctx) {
+            return;
+        }
+        const snap = (dir) => snapValue(value, dir, MERGE_WINDOW_MIN, MERGE_WINDOW_MAX, MERGE_WINDOW_STEP);
+        const unbinds = [
+            boundKeyboard(["left"], () => setMergeWindow(snap(-1)), {
+                elementId: ctx.id,
+            }),
+            boundKeyboard(["right"], () => setMergeWindow(snap(1)), {
+                elementId: ctx.id,
+            }),
+            boundKeyboard(["escape"], () => closeModalLayer(ctx.modalLayer.layerId), { elementId: ctx.id }),
+        ];
+        return () => unbinds.forEach((fn) => fn());
+    }, [boundKeyboard, closeModalLayer, ctx, setMergeWindow, value]);
+    return (React.createElement(ModalFrame, { title: t("settings.mergeWindow"), footer: React.createElement(Text, { dimColor: true },
+            t("settings.back"),
+            " (Esc)") },
+        React.createElement(Slider, { value: value, min: MERGE_WINDOW_MIN, max: MERGE_WINDOW_MAX, step: MERGE_WINDOW_STEP, onChange: setMergeWindowDraft, onCommit: commit, hint: t("settings.slider.hint") }),
+        React.createElement(Text, null, value === MERGE_WINDOW_MIN
+            ? t("settings.mergeWindow.off")
+            : `${value} ms`)));
+}
 /** Small clickable button used inside the file-tree-root picker. */
 function PickerButton({ label, active, onEnter, onLeave, onClick }) {
     const ref = useMouseRegion({ onEnter, onLeave, onClick }, { priority: 1 });
@@ -221,6 +258,13 @@ export function SettingsEntries({ onExit }) {
             element: FileTreePicker,
         });
     }, [applyElementToModalLayer, openModalLayer]);
+    const openMergeWindowPicker = useCallback(() => {
+        openModalLayer("merge-window", 50);
+        applyElementToModalLayer("merge-window", {
+            elementId: "merge-window-picker",
+            element: MergeWindowPicker,
+        });
+    }, [applyElementToModalLayer, openModalLayer]);
     const currentLabel = LANGUAGES.find((lang) => lang.code === currentLanguage)?.labelKey ??
         "settings.language.en";
     const entries = useMemo(() => [
@@ -250,6 +294,14 @@ export function SettingsEntries({ onExit }) {
                 : t("settings.fileTreeRoot.startup"),
             open: openFileTreePicker,
         },
+        {
+            id: "merge-window",
+            label: t("settings.mergeWindow"),
+            value: settings.history.mergeWindow === MERGE_WINDOW_MIN
+                ? t("settings.mergeWindow.off")
+                : `${settings.history.mergeWindow} ms`,
+            open: openMergeWindowPicker,
+        },
     ], [
         t,
         currentLabel,
@@ -257,9 +309,11 @@ export function SettingsEntries({ onExit }) {
         settings.wheel.view,
         settings.fileTree.root,
         settings.fileTree.customPath,
+        settings.history.mergeWindow,
         openLanguagePicker,
         openSensitivityPicker,
         openFileTreePicker,
+        openMergeWindowPicker,
     ]);
     useEffect(() => {
         const unbinds = [

package/dist/view/utils/sensitivity-bar.d.ts

@@ -2,23 +2,57 @@ import React from "react";
 export declare const SENSITIVITY_MIN = 1;
 export declare const SENSITIVITY_MAX = 10;
 export declare const SENSITIVITY_STEP = 0.5;
-/** Bar cells: (10 - 1) / 0.5 steps, so every cell maps to exactly one step. */
-export declare const BAR_WIDTH: number;
-/** Map a 0..1 ratio to a sensitivity value in 0.5 steps. */
-export declare function valueFromRatio(ratio: number): number;
+/** Number of steps a `min..max` range of `step` size spans. */
+export declare function stepsFor(min: number, max: number, step: number): number;
+/** Map a 0..1 ratio to a value snapped to `step`, clamped to `min..max`. */
+export declare function valueFromRatio(ratio: number, min?: number, max?: number, step?: number): number;
 /** Clamp value + dir*step to the valid 1..10 range (0.5 steps). */
 export declare function snapSensitivity(value: number, dir: 1 | -1): number;
-type SensitivityBarProps = {
+/** Clamp value + dir*step to an arbitrary `min..max` range. */
+export declare function snapValue(value: number, dir: 1 | -1, min: number, max: number, step: number): number;
+/**
+ * Value for a click on cell `localX` (0-based) of a bar that renders exactly
+ * `steps + 1` cells — one per value from `min` to `max` inclusive. The ratio
+ * therefore runs `localX / steps`, which is exactly one value per cell; using
+ * `steps` cells instead would have to skip an interior value to still reach
+ * `max` (e.g. 1000 ms, or 5.5×, would be unreachable by mouse).
+ */
+export declare function valueFromBarX(localX: number, min: number, max: number, step: number): number;
+/**
+ * Filled-cell count for `value` on the `min..max` bar, matching
+ * {@link valueFromBarX}: cell `i` selects `min + i*step`, so the value's own
+ * cell is filled and everything left of it too — one cell at `min`, the whole
+ * bar at `max`. Deriving the count from that integer cell index — rather than
+ * from the value's fraction of the range — keeps the fill aligned with the
+ * click mapping: a proportional `fraction * (steps + 1)` rounds unevenly and
+ * skips a cell at the midpoint.
+ */
+export declare function filledCells(value: number, min: number, max: number, step: number): number;
+type SliderProps = {
     value: number;
+    min: number;
+    max: number;
+    step: number;
     /** Called on click/drag with the new value (in-memory draft). */
     onChange: (value: number) => void;
     /** Called when the interaction ends — persist the draft. */
     onCommit: () => void;
+    /** Localized hint rendered under the bar. */
+    hint: string;
 };
 /**
- * Mouse-driven sensitivity slider. Clicking or dragging anywhere on the bar
- * sets the value proportionally (0.5 steps); the fuller the bar, the higher
- * the sensitivity, and the 1..10 range caps it by construction.
+ * Mouse-driven slider over an arbitrary `min..max`/`step` range. Clicking or
+ * dragging anywhere on the bar sets the value proportionally, snapped to
+ * `step`; the fuller the bar, the higher the value.
  */
+export declare function Slider({ value, min, max, step, onChange, onCommit, hint }: SliderProps): React.JSX.Element;
+type SensitivityBarProps = {
+    value: number;
+    /** Called on click/drag with the new value (in-memory draft). */
+    onChange: (value: number) => void;
+    /** Called when the interaction ends — persist the draft. */
+    onCommit: () => void;
+};
+/** Slider preset for the 1..10 wheel sensitivity range. */
 export declare function SensitivityBar({ value, onChange, onCommit }: SensitivityBarProps): React.JSX.Element;
 export {};

package/dist/view/utils/sensitivity-bar.js

@@ -5,25 +5,57 @@ import React from "react";
 export const SENSITIVITY_MIN = 1;
 export const SENSITIVITY_MAX = 10;
 export const SENSITIVITY_STEP = 0.5;
-/** Bar cells: (10 - 1) / 0.5 steps, so every cell maps to exactly one step. */
-export const BAR_WIDTH = (SENSITIVITY_MAX - SENSITIVITY_MIN) / SENSITIVITY_STEP;
-/** Map a 0..1 ratio to a sensitivity value in 0.5 steps. */
-export function valueFromRatio(ratio) {
+/** Number of steps a `min..max` range of `step` size spans. */
+export function stepsFor(min, max, step) {
+    return Math.round((max - min) / step);
+}
+/** Map a 0..1 ratio to a value snapped to `step`, clamped to `min..max`. */
+export function valueFromRatio(ratio, min = SENSITIVITY_MIN, max = SENSITIVITY_MAX, step = SENSITIVITY_STEP) {
     const r = Math.max(0, Math.min(1, ratio));
-    // BAR_WIDTH cells span exactly the 1..10 range (18 steps of 0.5).
-    return SENSITIVITY_MIN + Math.round(r * BAR_WIDTH) * SENSITIVITY_STEP;
+    return min + Math.round(r * stepsFor(min, max, step)) * step;
 }
 /** Clamp value + dir*step to the valid 1..10 range (0.5 steps). */
 export function snapSensitivity(value, dir) {
-    return Math.min(SENSITIVITY_MAX, Math.max(SENSITIVITY_MIN, value + dir * SENSITIVITY_STEP));
+    return snapValue(value, dir, SENSITIVITY_MIN, SENSITIVITY_MAX, SENSITIVITY_STEP);
+}
+/** Clamp value + dir*step to an arbitrary `min..max` range. */
+export function snapValue(value, dir, min, max, step) {
+    return Math.min(max, Math.max(min, value + dir * step));
 }
 /**
- * Mouse-driven sensitivity slider. Clicking or dragging anywhere on the bar
- * sets the value proportionally (0.5 steps); the fuller the bar, the higher
- * the sensitivity, and the 1..10 range caps it by construction.
+ * Value for a click on cell `localX` (0-based) of a bar that renders exactly
+ * `steps + 1` cells — one per value from `min` to `max` inclusive. The ratio
+ * therefore runs `localX / steps`, which is exactly one value per cell; using
+ * `steps` cells instead would have to skip an interior value to still reach
+ * `max` (e.g. 1000 ms, or 5.5×, would be unreachable by mouse).
  */
-export function SensitivityBar({ value, onChange, onCommit }) {
-    const { t } = useI18n();
+export function valueFromBarX(localX, min, max, step) {
+    const steps = stepsFor(min, max, step);
+    // A zero-width bar (single value) can only mean `min`; avoid /0.
+    return steps <= 0 ? min : valueFromRatio(localX / steps, min, max, step);
+}
+/**
+ * Filled-cell count for `value` on the `min..max` bar, matching
+ * {@link valueFromBarX}: cell `i` selects `min + i*step`, so the value's own
+ * cell is filled and everything left of it too — one cell at `min`, the whole
+ * bar at `max`. Deriving the count from that integer cell index — rather than
+ * from the value's fraction of the range — keeps the fill aligned with the
+ * click mapping: a proportional `fraction * (steps + 1)` rounds unevenly and
+ * skips a cell at the midpoint.
+ */
+export function filledCells(value, min, max, step) {
+    const total = stepsFor(min, max, step) + 1;
+    const index = Math.round((value - min) / step);
+    return Math.min(total, Math.max(1, index + 1));
+}
+/**
+ * Mouse-driven slider over an arbitrary `min..max`/`step` range. Clicking or
+ * dragging anywhere on the bar sets the value proportionally, snapped to
+ * `step`; the fuller the bar, the higher the value.
+ */
+export function Slider({ value, min, max, step, onChange, onCommit, hint }) {
+    const steps = stepsFor(min, max, step);
+    const valueFromX = (localX) => valueFromBarX(localX, min, max, step);
     // priority 1: the bar sits inside the draggable ModalFrame, whose region
     // overlaps it — the child control must always win the hit test, no matter
     // the registration order after frame drags.
@@ -36,14 +68,18 @@ export function SensitivityBar({ value, onChange, onCommit }) {
         onDragMove: (event, rect) => onChange(valueFromX(event.x - rect.x)),
         onDragEnd: () => onCommit(),
     }, { priority: 1 });
-    const filled = Math.round((value - SENSITIVITY_MIN) / SENSITIVITY_STEP);
+    // One cell per value (min..max inclusive); the fill is derived from the
+    // value's own cell, so it matches what a click on that cell would select.
+    const total = steps + 1;
+    const filled = filledCells(value, min, max, step);
     return (React.createElement(Box, { flexDirection: "column", alignItems: "center", gap: 1 },
         React.createElement(Box, { ref: ref, flexDirection: "row" },
             React.createElement(Text, null, filled > 0 ? "█".repeat(filled) : ""),
-            React.createElement(Text, { dimColor: true }, "░".repeat(BAR_WIDTH - filled))),
-        React.createElement(Text, { dimColor: true }, t("settings.sensitivity.hint"))));
+            React.createElement(Text, { dimColor: true }, "░".repeat(total - filled))),
+        React.createElement(Text, { dimColor: true }, hint)));
 }
-/** Value for a click at `localX` cells inside the bar (0-based). */
-function valueFromX(localX) {
-    return valueFromRatio(localX / BAR_WIDTH);
+/** Slider preset for the 1..10 wheel sensitivity range. */
+export function SensitivityBar({ value, onChange, onCommit }) {
+    const { t } = useI18n();
+    return (React.createElement(Slider, { value: value, min: SENSITIVITY_MIN, max: SENSITIVITY_MAX, step: SENSITIVITY_STEP, onChange: onChange, onCommit: onCommit, hint: t("settings.slider.hint") }));
 }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "blots-editor",
-	"version": "0.0.17",
+	"version": "0.0.18",
 	"description": "A lightweight Markdown editor for the terminal, built on ink-cartridge",
 	"type": "module",
 	"main": "./dist/index.js",