blots-editor 0.0.15 → 0.0.17

package/asset/language/en.json

@@ -20,7 +20,6 @@
   "toolbar.save": "Save",
   "toolbar.settings": "Settings",
   "fileTree.scanning": "Scanning...",
-  "fileTree.noDir": "No directory",
   "fileTree.fail": "Scan failed",
   "fileTree.unsaved": "Unsaved changes",
   "editor.setting.title": "Menu",

package/asset/language/zh.json

@@ -20,7 +20,6 @@
   "toolbar.save": "保存",
   "toolbar.settings": "设置",
   "fileTree.scanning": "正在扫描...",
-  "fileTree.noDir": "没有目录",
   "fileTree.fail": "扫描失败",
   "fileTree.unsaved": "未保存的更改",
   "editor.setting.title": "菜单",

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

@@ -20,6 +20,23 @@ export declare class Document {
     private _wrapWidth;
     private _viewScrollTop;
     private _scrollRemainder;
+    /**
+     * Per-line soft-wrap segment cache. Segments are derived purely from
+     * `_lines` + `_wrapWidth`, but recomputing them is expensive (binary
+     * searches + per-character tab expansion), and the render path queries
+     * them O(viewport) times per frame — so identical inputs must not be
+     * recomputed. null while invalidated; rebuilt lazily on first use.
+     */
+    private _segmentCache;
+    /**
+     * Prefix sums of segment counts: `prefix[i]` = visual lines occupied by
+     * the first `i` logical lines (so `prefix[line]` is the global visual
+     * line where logical line `line` starts). Lets `visualLineAt` /
+     * `cursorVisualLine` / `visualLineCount` answer in O(log n)/O(1)
+     * instead of scanning every line. Invalidated together with
+     * `_segmentCache`.
+     */
+    private _segPrefix;
     readonly indentWidth: number;
     constructor(text: string, options?: DocumentOptions);
     get lineCount(): number;
@@ -45,14 +62,36 @@ export declare class Document {
     get wrapWidth(): number;
     /** Set the soft-wrap width (clamped to at least 1 cell). */
     setWrapWidth(width: number): void;
-    /** The soft-wrap segments of one logical line (an empty line is one empty segment). */
+    /**
+     * The soft-wrap segments of one logical line (an empty line is one empty
+     * segment). Cached: the render path queries these O(viewport) times per
+     * frame, and every hit would otherwise re-run `segmentFrom` (binary
+     * search + per-character tab expansion) on unchanged input.
+     */
     private lineSegments;
+    /**
+     * Prefix sums of segment counts, built lazily from the segment cache.
+     * Both caches are invalidated together (see {@link invalidateIndex}), so
+     * they can never disagree once built.
+     */
+    private buildSegmentPrefix;
+    /**
+     * Drop the segment cache and the visual-line index. Every mutation entry
+     * point (`setText`, `setLine`, `insertLineAt`, `removeLineAt`, and a
+     * *changed* `setWrapWidth`) must call this, or queries would keep serving
+     * stale segments. Rebuilding is lazy — the next query pays O(total
+     * segments) once.
+     */
+    private invalidateIndex;
     /** Total number of visual (soft-wrapped) lines across the document. */
     get visualLineCount(): number;
     /**
      * Map a global visual line to its logical line and the segment's logical
      * span. `first` marks the segment that starts at the logical line start
-     * (the one that carries the line number).
+     * (the one that carries the line number). Binary search over the segment
+     * prefix sums keeps this O(log n) — the render loop calls it once per
+     * visible line, so a linear scan here would be O(viewport × lines) every
+     * frame.
      */
     visualLineAt(vline: number): {
         line: number;
@@ -92,9 +131,17 @@ export declare class Document {
     visualAtLogical(line: number, logical: number): number;
     moveLeft(): void;
     moveRight(): void;
-    /** Vertical movement aligns by visual column, so wide-character lines do not drift. */
-    moveUp(): void;
-    moveDown(): void;
+    /**
+     * Move up by `count` visual lines (default 1), aligning by visual column so
+     * wide-character lines do not drift. Overshooting the top clamps to the
+     * first visual line.
+     */
+    moveUp(count?: number): void;
+    /**
+     * Move down by `count` visual lines (default 1), aligning by visual column.
+     * Overshooting the bottom clamps to the last visual line.
+     */
+    moveDown(count?: number): void;
     moveToLineStart(): void;
     moveToLineEnd(): void;
     moveToDocumentStart(): void;

package/dist/core/document/document.js

@@ -20,6 +20,23 @@ export class Document {
     _viewScrollTop = null;
     // Fractional view-scroll remainder, so e.g. 3.5 cells/notch scrolls 3,4,3,4…
     _scrollRemainder = 0;
+    /**
+     * Per-line soft-wrap segment cache. Segments are derived purely from
+     * `_lines` + `_wrapWidth`, but recomputing them is expensive (binary
+     * searches + per-character tab expansion), and the render path queries
+     * them O(viewport) times per frame — so identical inputs must not be
+     * recomputed. null while invalidated; rebuilt lazily on first use.
+     */
+    _segmentCache = null;
+    /**
+     * Prefix sums of segment counts: `prefix[i]` = visual lines occupied by
+     * the first `i` logical lines (so `prefix[line]` is the global visual
+     * line where logical line `line` starts). Lets `visualLineAt` /
+     * `cursorVisualLine` / `visualLineCount` answer in O(log n)/O(1)
+     * instead of scanning every line. Invalidated together with
+     * `_segmentCache`.
+     */
+    _segPrefix = null;
     indentWidth;
     constructor(text, options = {}) {
         this._lines = text.split(/\r?\n/).map((t) => new TextLine(t));
@@ -56,6 +73,7 @@ export class Document {
         this._scrollTop = 0;
         this._viewScrollTop = null;
         this._scrollRemainder = 0;
+        this.invalidateIndex();
     }
     get cursor() {
         const line = this._lines[this._cursor.line];
@@ -74,68 +92,123 @@ export class Document {
     }
     /** Set the soft-wrap width (clamped to at least 1 cell). */
     setWrapWidth(width) {
-        this._wrapWidth = Math.max(1, width);
+        const w = Math.max(1, width);
+        // The view calls this on every render with the measured width; only a
+        // real change invalidates the cache, or it would be rebuilt (and
+        // discarded) every frame.
+        if (w !== this._wrapWidth) {
+            this._wrapWidth = w;
+            this.invalidateIndex();
+        }
     }
-    /** The soft-wrap segments of one logical line (an empty line is one empty segment). */
+    /**
+     * The soft-wrap segments of one logical line (an empty line is one empty
+     * segment). Cached: the render path queries these O(viewport) times per
+     * frame, and every hit would otherwise re-run `segmentFrom` (binary
+     * search + per-character tab expansion) on unchanged input.
+     */
     lineSegments(line) {
+        const cached = this._segmentCache?.[line];
+        if (cached) {
+            return cached;
+        }
         const tl = this._lines[line];
+        const segs = [];
         if (tl.text.length === 0) {
-            return [{ start: 0, end: 0, text: "" }];
+            segs.push({ start: 0, end: 0, text: "" });
         }
-        const segs = [];
-        let segVisual = 0;
-        let segStart = 0;
-        while (segStart < tl.text.length) {
-            const seg = tl.segmentFrom(segVisual, this._wrapWidth);
-            segs.push({ start: segStart, end: seg.endLogical, text: seg.text });
-            if (seg.text === "") {
-                break;
+        else {
+            let segVisual = 0;
+            let segStart = 0;
+            while (segStart < tl.text.length) {
+                const seg = tl.segmentFrom(segVisual, this._wrapWidth);
+                segs.push({ start: segStart, end: seg.endLogical, text: seg.text });
+                if (seg.text === "") {
+                    break;
+                }
+                segStart = seg.endLogical;
+                segVisual = seg.endVisual;
             }
-            segStart = seg.endLogical;
-            segVisual = seg.endVisual;
         }
+        if (!this._segmentCache) {
+            this._segmentCache = [];
+        }
+        this._segmentCache[line] = segs;
         return segs;
     }
-    /** Total number of visual (soft-wrapped) lines across the document. */
-    get visualLineCount() {
+    /**
+     * Prefix sums of segment counts, built lazily from the segment cache.
+     * Both caches are invalidated together (see {@link invalidateIndex}), so
+     * they can never disagree once built.
+     */
+    buildSegmentPrefix() {
+        if (this._segPrefix) {
+            return this._segPrefix;
+        }
+        const prefix = [0];
         let total = 0;
         for (let i = 0; i < this._lines.length; i++) {
             total += this.lineSegments(i).length;
+            prefix.push(total);
         }
-        return total;
+        this._segPrefix = prefix;
+        return prefix;
+    }
+    /**
+     * Drop the segment cache and the visual-line index. Every mutation entry
+     * point (`setText`, `setLine`, `insertLineAt`, `removeLineAt`, and a
+     * *changed* `setWrapWidth`) must call this, or queries would keep serving
+     * stale segments. Rebuilding is lazy — the next query pays O(total
+     * segments) once.
+     */
+    invalidateIndex() {
+        this._segmentCache = null;
+        this._segPrefix = null;
+    }
+    /** Total number of visual (soft-wrapped) lines across the document. */
+    get visualLineCount() {
+        return this.buildSegmentPrefix()[this._lines.length];
     }
     /**
      * Map a global visual line to its logical line and the segment's logical
      * span. `first` marks the segment that starts at the logical line start
-     * (the one that carries the line number).
+     * (the one that carries the line number). Binary search over the segment
+     * prefix sums keeps this O(log n) — the render loop calls it once per
+     * visible line, so a linear scan here would be O(viewport × lines) every
+     * frame.
      */
     visualLineAt(vline) {
         if (vline < 0) {
             return null;
         }
-        let remaining = vline;
-        for (let line = 0; line < this._lines.length; line++) {
-            const segs = this.lineSegments(line);
-            if (remaining < segs.length) {
-                return {
-                    line,
-                    start: segs[remaining].start,
-                    end: segs[remaining].end,
-                    first: remaining === 0,
-                    text: segs[remaining].text,
-                };
+        const prefix = this.buildSegmentPrefix();
+        if (vline >= prefix[this._lines.length]) {
+            return null;
+        }
+        // Largest line index whose prefix start is <= vline.
+        let lo = 0;
+        let hi = this._lines.length - 1;
+        while (lo < hi) {
+            const mid = (lo + hi + 1) >> 1;
+            if (prefix[mid] <= vline) {
+                lo = mid;
+            }
+            else {
+                hi = mid - 1;
             }
-            remaining -= segs.length;
         }
-        return null;
+        const seg = this.lineSegments(lo)[vline - prefix[lo]];
+        return {
+            line: lo,
+            start: seg.start,
+            end: seg.end,
+            first: vline === prefix[lo],
+            text: seg.text,
+        };
     }
     /** Global visual line the cursor sits on. */
     get cursorVisualLine() {
         const { line, logical } = this._cursor;
-        let v = 0;
-        for (let i = 0; i < line; i++) {
-            v += this.lineSegments(i).length;
-        }
         const segs = this.lineSegments(line);
         let idx = 0;
         // A cursor exactly on a segment boundary belongs to the segment
@@ -144,7 +217,7 @@ export class Document {
         while (idx < segs.length - 1 && logical >= segs[idx + 1].start) {
             idx++;
         }
-        return v + idx;
+        return this.buildSegmentPrefix()[line] + idx;
     }
     /** Visual offset of the cursor within its current soft-wrap segment. */
     get cursorSegmentVisual() {
@@ -175,14 +248,18 @@ export class Document {
     }
     setLine(i, text) {
         this._lines[i] = new TextLine(text);
+        this.invalidateIndex();
     }
     /** Insert a line at index `i` (0 <= i <= lineCount), shifting the rest down. */
     insertLineAt(i, text) {
         this._lines.splice(i, 0, new TextLine(text));
+        this.invalidateIndex();
     }
     /** Remove line `i` and return its text. */
     removeLineAt(i) {
-        return this._lines.splice(i, 1)[0].text;
+        const removed = this._lines.splice(i, 1)[0].text;
+        this.invalidateIndex();
+        return removed;
     }
     /** Set the cursor, clamping out-of-range values (line to `[0, lineCount-1]`, column to end of line). */
     setCursor(line, logical) {
@@ -248,10 +325,15 @@ export class Document {
             this.setCursor(line, target);
         }
     }
-    /** Vertical movement aligns by visual column, so wide-character lines do not drift. */
-    moveUp() {
+    /**
+     * Move up by `count` visual lines (default 1), aligning by visual column so
+     * wide-character lines do not drift. Overshooting the top clamps to the
+     * first visual line.
+     */
+    moveUp(count = 1) {
         const { line, logical } = this._cursor;
-        if (this.cursorVisualLine === 0) {
+        const current = this.cursorVisualLine;
+        if (current === 0) {
             // Already on the first visual line: still move to the start of the
             // current segment (like up-to-line-start in vim).
             const segs = this.lineSegments(line);
@@ -262,17 +344,25 @@ export class Document {
             this.setCursor(line, segs[idx].start);
             return;
         }
-        const prev = this.visualLineAt(this.cursorVisualLine - 1);
+        const step = Math.max(1, Math.round(count));
+        const prev = this.visualLineAt(Math.max(0, current - step));
         if (!prev) {
             return;
         }
         this.moveToSegment(prev);
     }
-    moveDown() {
-        if (this.cursorVisualLine >= this.visualLineCount - 1) {
+    /**
+     * Move down by `count` visual lines (default 1), aligning by visual column.
+     * Overshooting the bottom clamps to the last visual line.
+     */
+    moveDown(count = 1) {
+        const current = this.cursorVisualLine;
+        const last = this.visualLineCount - 1;
+        if (current >= last) {
             return;
         }
-        const next = this.visualLineAt(this.cursorVisualLine + 1);
+        const step = Math.max(1, Math.round(count));
+        const next = this.visualLineAt(Math.min(last, current + step));
         if (!next) {
             return;
         }

package/dist/core/editor-controller.js

@@ -64,8 +64,14 @@ export class EditorController {
         });
         this.defineCommand("cursor.moveLeft", (doc) => doc.moveLeft());
         this.defineCommand("cursor.moveRight", (doc) => doc.moveRight());
-        this.defineCommand("cursor.moveUp", (doc) => doc.moveUp());
-        this.defineCommand("cursor.moveDown", (doc) => doc.moveDown());
+        this.defineCommand("cursor.moveUp", (doc, args) => {
+            const count = typeof args?.count === "number" ? args.count : 1;
+            doc.moveUp(count);
+        });
+        this.defineCommand("cursor.moveDown", (doc, args) => {
+            const count = typeof args?.count === "number" ? args.count : 1;
+            doc.moveDown(count);
+        });
         this.defineCommand("cursor.lineStart", (doc) => doc.moveToLineStart());
         this.defineCommand("cursor.lineEnd", (doc) => doc.moveToLineEnd());
         this.defineCommand("cursor.wordForward", (doc) => doc.moveWordForward());

package/dist/core/io/file-tree-model.d.ts

@@ -24,8 +24,13 @@ export type FileNode = {
 };
 /** Expand a leading `~` to the user's home directory. */
 export declare function expandHome(path: string): string;
-/** Resolve the file-tree root from settings: startup dir or custom path. */
-export declare function resolveFileTreeRoot(settings: FileTreeSettings, startupDir: string): string | null;
+/**
+ * Resolve the file-tree root from settings: the custom path, or the startup
+ * directory. A custom mode with a blank path falls back to the startup
+ * directory — the picker lets you select custom before typing anything, and an
+ * empty root should not read as "no directory".
+ */
+export declare function resolveFileTreeRoot(settings: FileTreeSettings, startupDir: string): string;
 /**
  * Recursively scan a directory into a tree. Symlinks are never followed
  * (they can loop), dotfiles and known dependency/VCS dirs are skipped.

package/dist/core/io/file-tree-model.js

@@ -43,11 +43,18 @@ const isHidden = (name) => name.startsWith(".");
 export function expandHome(path) {
     return path === "~" ? homedir() : path.startsWith("~/") ? join(homedir(), path.slice(2)) : path;
 }
-/** Resolve the file-tree root from settings: startup dir or custom path. */
+/**
+ * Resolve the file-tree root from settings: the custom path, or the startup
+ * directory. A custom mode with a blank path falls back to the startup
+ * directory — the picker lets you select custom before typing anything, and an
+ * empty root should not read as "no directory".
+ */
 export function resolveFileTreeRoot(settings, startupDir) {
     if (settings.root === "custom") {
         const custom = expandHome(settings.customPath.trim());
-        return custom.length > 0 ? custom : null;
+        if (custom.length > 0) {
+            return custom;
+        }
     }
     return startupDir;
 }

package/dist/index.js

@@ -1,7 +1,8 @@
 #!/usr/bin/env node
 import { render } from "ink";
 import React from "react";
-import { CurrentScreen, KeyboardProvider, LanguageProvider, registerComponent, ScenarioManagementProvider, } from "ink-cartridge";
+import { LanguageProvider } from "@cartridge-engine/i18n";
+import { CurrentScreen, KeyboardProvider, registerComponent, ScenarioManagementProvider, } from "ink-cartridge";
 import { resources } from "./utils/view/i18n-resources.js";
 import { settingsStore } from "./core/settings/useSettings.js";
 import { MainMenu } from "./view/page/main-menu.js";

package/dist/view/editor/command-bar.js

@@ -1,5 +1,6 @@
+import { useI18n } from "@cartridge-engine/i18n";
 import { Box, Text } from "ink";
-import { back, ModalLayerElementContext, useI18n, useKeyboard, useScreenSystem, } from "ink-cartridge";
+import { back, ModalLayerElementContext, useKeyboard, useScreenSystem, } from "ink-cartridge";
 import React, { useContext, useEffect, useRef, useState } from "react";
 /**
  * Modal command bar (like Helix's `:` prompt). Rendered as a modal layer

package/dist/view/editor/editor-setting.js

@@ -1,5 +1,6 @@
+import { useI18n } from "@cartridge-engine/i18n";
 import { Box, Text } from "ink";
-import { applyElement, back, closeLayer, LayerElementContext, openLayer, useI18n, useKeyboard, useMouseRegion, } from "ink-cartridge";
+import { applyElement, back, closeLayer, LayerElementContext, openLayer, useKeyboard, useMouseRegion, } from "ink-cartridge";
 import React, { useCallback, useContext, useEffect, useState } from "react";
 import { SettingsEntries } from "../page/settings.js";
 import { ModalFrame } from "../utils/modal-frame.js";

package/dist/view/editor/file-tree.d.ts

@@ -1,13 +1,9 @@
 import React from "react";
-import type { FileTreeState } from "../../core/io/file-tree-model.js";
 import type { EditorSession } from "../../core/io/session.js";
 export type FileTreeProps = {
     /** The shared file session; clicking a file opens it here. */
     session: EditorSession;
 };
-export type FileTreeDirState = FileTreeState | {
-    noDir?: boolean;
-};
 /**
  * VSCode-style file tree pinned to the right edge of the terminal (regular
  * layer element). Recursively scans the configured root directory once per

package/dist/view/editor/file-tree.js

@@ -1,5 +1,6 @@
+import { useI18n } from "@cartridge-engine/i18n";
 import { Box, Text, useWindowSize } from "ink";
-import { applyElementToModalLayer, ModalLayerElementContext, openModalLayer, useI18n, useKeyboard, useMouseRegion, useScreenSystem, } from "ink-cartridge";
+import { applyElementToModalLayer, ModalLayerElementContext, openModalLayer, useKeyboard, useMouseRegion, useScreenSystem, } from "ink-cartridge";
 import React, { useCallback, useContext, useEffect, useMemo, useState, } from "react";
 import { basename } from "node:path";
 import stringWidth from "string-width";
@@ -36,10 +37,7 @@ export function FileTree({ session }) {
         setRoot({ scanning: true });
         (async () => {
             const resolved = resolveFileTreeRoot(settings.fileTree, process.cwd());
-            const tree = resolved
-                ? await scanDirectoryCached(resolved)
-                : { noDir: true };
-            setRoot(tree);
+            setRoot(await scanDirectoryCached(resolved));
         })();
     }, [settings.fileTree, scanTick]);
     // A new scan (root changed) starts collapsed at the top — reset during
@@ -114,8 +112,7 @@ export function FileTree({ session }) {
             React.createElement(Box, { ref: refreshRef, marginLeft: 1 },
                 React.createElement(Text, { color: refreshHovered ? "green" : "gray" }, "\u21BB"))),
         "scanning" in root ? (React.createElement(Box, { paddingLeft: 1 },
-            React.createElement(Text, { dimColor: true }, t("fileTree.scanning")))) : "noDir" in root ? (React.createElement(Box, { paddingLeft: 1 },
-            React.createElement(Text, { dimColor: true }, t("fileTree.noDir")))) : "fail" in root ? (React.createElement(Box, { paddingLeft: 1 },
+            React.createElement(Text, { dimColor: true }, t("fileTree.scanning")))) : "fail" in root ? (React.createElement(Box, { paddingLeft: 1 },
             React.createElement(Text, { dimColor: true }, t("fileTree.fail")))) : (visible.map((row) => (React.createElement(TreeRow, { key: row.node.path, node: row.node, depth: row.depth, expanded: expanded.has(row.node.path), hovered: hoveredPath === row.node.path, onEnter: () => setHoveredPath(row.node.path), onLeave: () => setHoveredPath((h) => (h === row.node.path ? null : h)), onWheel: handleWheel, onClick: () => {
                 if (row.node.isDir) {
                     toggleDir(row.node.path);

package/dist/view/editor/tool-bar.js

@@ -1,4 +1,5 @@
-import { useI18n, useKeyboard, useMouseRegion } from "ink-cartridge";
+import { useI18n } from "@cartridge-engine/i18n";
+import { useKeyboard, useMouseRegion } from "ink-cartridge";
 import React, { useCallback, useEffect, useMemo, useRef } from "react";
 import { useState } from "react";
 import { Box, measureElement, Text, useWindowSize } from "ink";
@@ -122,7 +123,7 @@ export function ToolBar({ currentMode, session, openFileTree, openSettings, file
             }),
             boundKeyboard(["return"], () => {
                 items[index].onClick();
-            }),
+            }, { mode: "normal" }),
         ];
         return () => {
             unbinds.forEach((unbind) => unbind());

package/dist/view/page/editor.js

@@ -1,5 +1,6 @@
+import { useI18n } from "@cartridge-engine/i18n";
 import { Box, Text, useBoxMetrics, useCursor } from "ink";
-import { applyElement, applyElementToModalLayer, closeLayer, eraseElement, openLayer, openModalLayer, useI18n, useKeyboard, useMouseRegion, } from "ink-cartridge";
+import { applyElement, applyElementToModalLayer, closeLayer, eraseElement, openLayer, openModalLayer, useKeyboard, useMouseRegion, } from "ink-cartridge";
 import React, { useCallback, useEffect, useRef, useState } from "react";
 import { EditorSession } from "../../core/io/session.js";
 import { useSettings } from "../../core/settings/useSettings.js";
@@ -104,7 +105,7 @@ export function Editor({ value: initialText = "", lineNumberRightSpacing = 1, cu
                     session,
                     openFileTree: () => setFileTreeOpen((open) => !open),
                     openSettings: () => setSettingsOpen((open) => !open),
-                    fileTreeOpen
+                    fileTreeOpen,
                 },
             });
         }, 0);
@@ -158,7 +159,9 @@ export function Editor({ value: initialText = "", lineNumberRightSpacing = 1, cu
             unbinds.push(boundKeyboard(keys, handler, options));
         };
         // insert mode: classic editing
-        bind(["*"], (input) => controller.execute("editor.insertText", { text: input }), { mode: "insert" });
+        bind(["*"], (input) => controller.execute("editor.insertText", { text: input }), {
+            mode: "insert",
+        });
         bind(["return"], () => controller.execute("editor.splitLine"), { mode: "insert" });
         bind(["right"], () => controller.execute("cursor.moveRight"), { mode: "insert" });
         bind(["left"], () => controller.execute("cursor.moveLeft"), { mode: "insert" });
@@ -201,7 +204,54 @@ export function Editor({ value: initialText = "", lineNumberRightSpacing = 1, cu
                 return { ...ctx, lastFlag: null };
             },
         });
+        // Vim-style count prefix: digits accumulate in the chain's `value`, then a
+        // direction key spends it (`5j`, `12k`). Composition runs ahead of the
+        // screen bindings, so a bare digit arms a chain instead of moving.
+        const countKeys = [];
+        for (const digit of "1234567890") {
+            countKeys.push(digit);
+            registryCompositionKey({
+                key: digit,
+                flags: [],
+                alternativeFlag: "number",
+                needs: ["number"],
+                // `0` cannot open a count, so a bare `0` keeps meaning line-start
+                // via its binding below; it may still extend one (`10j`).
+                optional: digit !== "0",
+                mode: "normal",
+                execute: (ctx) => ({
+                    ...ctx,
+                    value: (typeof ctx.value === "number" ? ctx.value : 0) * 10 + Number(digit),
+                    lastFlag: "number",
+                }),
+            });
+        }
+        // Counts only pay off on the vertical keys; h/l/left/right stay untouched.
+        const directions = [
+            ["k", "cursor.moveUp"],
+            ["up", "cursor.moveUp"],
+            ["j", "cursor.moveDown"],
+            ["down", "cursor.moveDown"],
+        ];
+        for (const [key, command] of directions) {
+            countKeys.push(key);
+            registryCompositionKey({
+                key,
+                flags: [],
+                alternativeFlag: "direction",
+                needs: ["number"],
+                mode: "normal",
+                // The count is spent here and the chain ends, so swallow the key —
+                // otherwise the plain binding below would move one extra line.
+                KeyReleaseWhenChainInterrupted: true,
+                execute: (ctx) => {
+                    controller.execute(command, { count: ctx.value });
+                    return null;
+                },
+            });
+        }
         unbinds.push(() => removeCompositionKey("g"));
+        unbinds.push(() => countKeys.forEach((key) => removeCompositionKey(key)));
         // Ink marks "G" as shift+g, so the normalized key name is "shift+G".
         bind(["shift+G"], () => controller.execute("cursor.documentEnd"), { mode: "normal" });
         bind(["i"], () => switchMode("insert"), { mode: "normal" });
@@ -281,7 +331,7 @@ export function Editor({ value: initialText = "", lineNumberRightSpacing = 1, cu
                     return null;
                 }
                 return (React.createElement(Box, { key: vline, flexDirection: "row" },
-                    React.createElement(Box, { width: lineNumberWidth, justifyContent: "flex-end", marginRight: lineNumberRightSpacing }, seg.first ? (React.createElement(Text, { bold: cursor.line === seg.line }, seg.line)) : null),
+                    React.createElement(Box, { width: lineNumberWidth, justifyContent: "flex-end", marginRight: lineNumberRightSpacing }, seg.first ? React.createElement(Text, { bold: cursor.line === seg.line }, seg.line) : null),
                     React.createElement(Text, null, seg.text)));
             })))));
 }

package/dist/view/page/main-menu.js

@@ -1,5 +1,6 @@
+import { useI18n } from "@cartridge-engine/i18n";
 import { Box, Text, useWindowSize } from "ink";
-import { useI18n, useKeyboard, useMouseRegion } from "ink-cartridge";
+import { useKeyboard, useMouseRegion } from "ink-cartridge";
 import React, { useEffect, useState } from "react";
 import { Editor } from "./editor.js";
 import { Settings } from "./settings.js";

package/dist/view/page/settings.js

@@ -1,5 +1,6 @@
+import { useI18n } from "@cartridge-engine/i18n";
 import { Box, Text } from "ink";
-import { back, ModalLayerElementContext, useI18n, useKeyboard, useMouseRegion, useScreenSystem, } from "ink-cartridge";
+import { back, ModalLayerElementContext, useKeyboard, useMouseRegion, useScreenSystem, } from "ink-cartridge";
 import React, { useCallback, useContext, useEffect, useMemo, useRef, useState, } from "react";
 import { useSettings } from "../../core/settings/useSettings.js";
 import { ModalFrame } from "../utils/modal-frame.js";

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

@@ -1,5 +1,6 @@
+import { useI18n } from "@cartridge-engine/i18n";
 import { Box, Text } from "ink";
-import { useI18n, useMouseRegion } from "ink-cartridge";
+import { useMouseRegion } from "ink-cartridge";
 import React from "react";
 export const SENSITIVITY_MIN = 1;
 export const SENSITIVITY_MAX = 10;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "blots-editor",
-	"version": "0.0.15",
+	"version": "0.0.17",
 	"description": "A lightweight Markdown editor for the terminal, built on ink-cartridge",
 	"type": "module",
 	"main": "./dist/index.js",
@@ -51,6 +51,7 @@
 		"react": ">=18"
 	},
 	"dependencies": {
+		"@cartridge-engine/i18n": "*",
 		"cfonts": "^3.3.1",
 		"chalk": "^4.1.2",
 		"gradient-string": "^2.0.2",