amness 0.0.0-stage → 0.1.2

package/dist/cli/tui/complete.d.ts

@@ -0,0 +1,39 @@
+export type Suggestion = {
+    label: string;
+    insert: string;
+    detail?: string;
+};
+export type Token = {
+    kind: "slash" | "file";
+    query: string;
+    start: number;
+    end: number;
+};
+/** What is the user completing right now? A slash command (first word of the input) or an @file mention. */
+export declare function tokenAtCursor(text: string, cursor: number): Token | null;
+export declare function rankCommands(query: string, cmds: {
+    name: string;
+    help: string;
+    alias?: string;
+}[], limit?: number): Suggestion[];
+/** Subsequence fuzzy match. Tries the greedy alignment and the exact-substring alignments and keeps the best. null = no match. */
+export declare function fuzzyScore(query: string, path: string): number | null;
+export declare function rankFiles(query: string, files: string[], limit?: number): Suggestion[];
+export declare function applySuggestion(text: string, t: Token, s: Suggestion): {
+    text: string;
+    cursor: number;
+};
+/** Project file list: `git ls-files` when available (respects .gitignore), else a bounded directory walk. Refreshes at most every few seconds. */
+export declare class FileIndex {
+    files: string[];
+    private at;
+    private loading;
+    cwd: string;
+    maxFiles: number;
+    constructor(cwd: string, maxFiles?: number);
+    /** Has the list been (re)built recently enough to trust? */
+    fresh(maxAgeMs?: number): boolean;
+    ensure(maxAgeMs?: number): Promise<void>;
+    private load;
+    private walk;
+}

package/dist/cli/tui/complete.js

@@ -0,0 +1,113 @@
+// Autocomplete for the input box: "/commands" and "@file" mentions. Pure ranking + a lazily built file index.
+import { execFile } from "node:child_process";
+import { readdirSync, statSync } from "node:fs";
+import { join } from "node:path";
+/** What is the user completing right now? A slash command (first word of the input) or an @file mention. */
+export function tokenAtCursor(text, cursor) {
+    const before = text.slice(0, cursor);
+    const slash = before.match(/^\/(\S*)$/);
+    if (slash)
+        return { kind: "slash", query: slash[1], start: 0, end: cursor };
+    const file = before.match(/(?:^|\s)@([^\s@]*)$/);
+    if (file)
+        return { kind: "file", query: file[1], start: cursor - file[1].length - 1, end: cursor };
+    return null;
+}
+export function rankCommands(query, cmds, limit = 8) {
+    const q = query.toLowerCase();
+    const score = (c) => (c.name.startsWith(q) ? 3 : c.alias?.startsWith(q) ? 2 : c.name.includes(q) || c.alias?.includes(q) ? 1 : 0);
+    return cmds.map((c) => ({ c, score: score(c) }))
+        .filter((x) => x.score > 0 || !q).sort((a, b) => b.score - a.score || a.c.name.localeCompare(b.c.name)).slice(0, limit)
+        .map(({ c }) => ({ label: "/" + c.name, insert: "/" + c.name + " ", detail: c.help + (c.alias && !c.name.includes(query.toLowerCase()) && c.alias.includes(query.toLowerCase()) ? ` (also /${c.alias})` : "") }));
+}
+/** Subsequence fuzzy match. Tries the greedy alignment and the exact-substring alignments and keeps the best. null = no match. */
+export function fuzzyScore(query, path) {
+    const q = query.toLowerCase(), p = path.toLowerCase(), base = p.lastIndexOf("/") + 1;
+    if (!q)
+        return -path.length;
+    const score = (pos) => {
+        let s = 0, run = 0, prev = -2;
+        for (const i of pos) {
+            run = prev === i - 1 ? run + 1 : 1;
+            s += 1 + run * 2 + (i === 0 || "/._-".includes(p[i - 1]) ? 6 : 0) + (i >= base ? 4 : 0);
+            prev = i;
+        }
+        return s;
+    };
+    const greedy = [];
+    for (let i = 0, qi = 0; i < p.length && qi < q.length; i++)
+        if (p[i] === q[qi]) {
+            greedy.push(i);
+            qi++;
+        }
+    if (greedy.length < q.length)
+        return null;
+    const run = (at) => Array.from({ length: q.length }, (_, k) => at + k);
+    const inBase = p.indexOf(q, base), anywhere = p.indexOf(q);
+    let best = score(greedy);
+    if (anywhere >= 0)
+        best = Math.max(best, score(run(anywhere)) + 15);
+    if (inBase >= 0)
+        best = Math.max(best, score(run(inBase)) + 15 + (inBase === base ? 25 : 0));
+    return best - path.length * 0.05;
+}
+export function rankFiles(query, files, limit = 8) {
+    return files.map((f) => ({ f, s: fuzzyScore(query, f) })).filter((x) => x.s !== null)
+        .sort((a, b) => b.s - a.s || a.f.localeCompare(b.f)).slice(0, limit)
+        .map(({ f }) => ({ label: f, insert: "@" + f + " ", detail: undefined }));
+}
+export function applySuggestion(text, t, s) {
+    const next = text.slice(0, t.start) + s.insert + text.slice(t.end);
+    return { text: next, cursor: t.start + s.insert.length };
+}
+const SKIP = new Set(["node_modules", ".git", "dist", "build", ".next", "__pycache__", ".venv", "target", ".amness", ".cache", "coverage"]);
+/** Project file list: `git ls-files` when available (respects .gitignore), else a bounded directory walk. Refreshes at most every few seconds. */
+export class FileIndex {
+    files = [];
+    at = 0;
+    loading = null;
+    cwd;
+    maxFiles;
+    constructor(cwd, maxFiles = 8000) { this.cwd = cwd; this.maxFiles = maxFiles; }
+    /** Has the list been (re)built recently enough to trust? */
+    fresh(maxAgeMs = 5000) { return Date.now() - this.at < maxAgeMs; }
+    ensure(maxAgeMs = 5000) {
+        if (Date.now() - this.at < maxAgeMs)
+            return Promise.resolve();
+        return (this.loading ??= this.load().finally(() => { this.loading = null; }));
+    }
+    load() {
+        return new Promise((done) => {
+            execFile("git", ["ls-files", "-co", "--exclude-standard"], { cwd: this.cwd, maxBuffer: 32 << 20 }, (err, out) => {
+                this.files = !err && out.trim() ? out.split("\n").filter(Boolean).slice(0, this.maxFiles) : this.walk();
+                this.at = Date.now();
+                done();
+            });
+        });
+    }
+    walk() {
+        const out = [];
+        const rec = (dir, rel) => {
+            let names = [];
+            try {
+                names = readdirSync(dir).sort();
+            }
+            catch {
+                return;
+            }
+            for (const n of names) {
+                if (out.length >= this.maxFiles)
+                    return;
+                if (SKIP.has(n) || (n.startsWith(".") && n !== ".github"))
+                    continue;
+                const p = join(dir, n), r = rel ? rel + "/" + n : n;
+                try {
+                    statSync(p).isDirectory() ? rec(p, r) : out.push(r);
+                }
+                catch { /* unreadable */ }
+            }
+        };
+        rec(this.cwd, "");
+        return out;
+    }
+}

package/dist/cli/tui/custom.d.ts

@@ -0,0 +1,9 @@
+import type { Cmd } from "./commands.ts";
+export declare function parseCommandFile(raw: string, fallback: string): {
+    description: string;
+    body: string;
+};
+export declare function loadCustomCommands(dirs: {
+    dir: string;
+    scope: "project" | "user";
+}[]): Cmd[];

package/dist/cli/tui/custom.js

@@ -0,0 +1,34 @@
+// User-defined slash commands: every <name>.md in .amness/commands (project) or ~/.amness/commands (user) becomes /<name>.
+import { existsSync, readFileSync, readdirSync } from "node:fs";
+import { basename, join } from "node:path";
+export function parseCommandFile(raw, fallback) {
+    const fm = raw.match(/^---\n([\s\S]*?)\n---\n?([\s\S]*)$/);
+    const body = (fm ? fm[2] : raw).trim();
+    const desc = fm?.[1].match(/^description:\s*(.+)$/m)?.[1].trim() ?? body.split("\n").find((l) => l.trim())?.replace(/^#+\s*/, "").slice(0, 70) ?? fallback;
+    return { description: desc, body };
+}
+export function loadCustomCommands(dirs) {
+    const out = new Map();
+    for (const { dir, scope } of dirs) {
+        if (!existsSync(dir))
+            continue;
+        for (const f of readdirSync(dir).sort()) {
+            if (!f.endsWith(".md"))
+                continue;
+            const name = basename(f, ".md").toLowerCase().replace(/[^a-z0-9_-]+/g, "-");
+            if (!name || (out.has(name) && scope === "user"))
+                continue; // a project command overrides a user command of the same name
+            let parsed;
+            try {
+                parsed = parseCommandFile(readFileSync(join(dir, f), "utf8"), name);
+            }
+            catch {
+                continue;
+            }
+            const { description, body } = parsed;
+            out.set(name, { name, help: `${description} (${scope})`, args: "[args]",
+                run: (app, args) => app.turn(body.includes("$ARGUMENTS") ? body.split("$ARGUMENTS").join(args) : args ? `${body}\n\n${args}` : body) });
+        }
+    }
+    return [...out.values()];
+}

package/dist/cli/tui/diffview.d.ts

@@ -0,0 +1,25 @@
+import type { Theme } from "./themes.ts";
+export type DiffLine = {
+    t: " " | "+" | "-" | "gap";
+    text: string;
+    a: number;
+    b: number;
+};
+export declare const langOf: (path: string) => string;
+/** Parse the unified diff text produced by `unifiedDiff` into rows with old/new line numbers; hunks are separated by `gap` rows. */
+export declare function parseDiff(diff: string): DiffLine[];
+/** For each - line directly followed by an equal number of + lines, the differing middle of each pair (common prefix/suffix trimmed). */
+export declare function wordDiffs(rows: DiffLine[]): Map<number, [number, number]>;
+export type DiffOpts = {
+    width: number;
+    theme: Theme;
+    lang: string;
+    mode?: "stacked" | "split";
+    maxRows?: number;
+};
+/** Rows (ANSI strings, exactly `width` wide) for a diff body. `hidden` = rows not shown because of maxRows. */
+export declare function renderDiffRows(diff: string, o: DiffOpts): {
+    rows: string[];
+    hidden: number;
+    total: number;
+};

package/dist/cli/tui/diffview.js

@@ -0,0 +1,130 @@
+// Diff viewer: line numbers, +/- background tints, syntax highlighting, word-level change marks, and a split (side-by-side) layout.
+import { highlightWith } from "./markdown.js";
+import { B, F, fit } from "./rich.js";
+const EXT = { ts: "ts", tsx: "tsx", js: "js", jsx: "jsx", mjs: "js", cjs: "js", py: "py", rb: "rb", go: "go", rs: "rs", java: "java", c: "c", h: "c", cpp: "cpp", cs: "cs", sh: "sh", bash: "sh", zsh: "sh", json: "json", yml: "yaml", yaml: "yaml", toml: "toml", md: "md", css: "css", html: "html", kt: "kt", swift: "swift" };
+export const langOf = (path) => EXT[path.split(".").pop()?.toLowerCase() ?? ""] ?? "";
+/** Parse the unified diff text produced by `unifiedDiff` into rows with old/new line numbers; hunks are separated by `gap` rows. */
+export function parseDiff(diff) {
+    const out = [];
+    let a = 0, b = 0;
+    for (const l of diff.split("\n")) {
+        if (/^(---|\+\+\+)/.test(l))
+            continue;
+        const h = l.match(/^@@ -(\d+),?\d* \+(\d+)/);
+        if (h) {
+            if (out.length)
+                out.push({ t: "gap", text: "", a: +h[1], b: +h[2] });
+            a = +h[1];
+            b = +h[2];
+            continue;
+        }
+        if (!l)
+            continue;
+        const t = l[0], text = l.slice(1);
+        if (t === "+")
+            out.push({ t, text, a: 0, b: b++ });
+        else if (t === "-")
+            out.push({ t, text, a: a++, b: 0 });
+        else
+            out.push({ t: " ", text, a: a++, b: b++ });
+    }
+    return out;
+}
+/** For each - line directly followed by an equal number of + lines, the differing middle of each pair (common prefix/suffix trimmed). */
+export function wordDiffs(rows) {
+    const marks = new Map();
+    for (let i = 0; i < rows.length;) {
+        if (rows[i].t !== "-") {
+            i++;
+            continue;
+        }
+        let d = i;
+        while (d < rows.length && rows[d].t === "-")
+            d++;
+        let p = d;
+        while (p < rows.length && rows[p].t === "+")
+            p++;
+        const nd = d - i, np = p - d;
+        if (nd === np && nd > 0)
+            for (let k = 0; k < nd; k++) {
+                const x = rows[i + k].text, y = rows[d + k].text;
+                let pre = 0;
+                while (pre < x.length && pre < y.length && x[pre] === y[pre])
+                    pre++;
+                let suf = 0;
+                while (suf < x.length - pre && suf < y.length - pre && x[x.length - 1 - suf] === y[y.length - 1 - suf])
+                    suf++;
+                if (pre + suf < Math.min(x.length, y.length) || x.length !== y.length) {
+                    marks.set(i + k, [pre, x.length - suf]);
+                    marks.set(d + k, [pre, y.length - suf]);
+                }
+            }
+        i = Math.max(p, i + 1);
+    }
+    return marks;
+}
+function paintCode(text, lang, t, bg, strong, mark) {
+    const hl = (k, s) => F(k === "plain" ? t.syn.plain : t.syn[k], s);
+    const seg = (s, bgc) => B(bgc, highlightWith(s, lang, hl));
+    if (!mark || mark[0] >= mark[1])
+        return seg(text, bg);
+    return seg(text.slice(0, mark[0]), bg) + seg(text.slice(mark[0], mark[1]), strong) + seg(text.slice(mark[1]), bg);
+}
+/** Rows (ANSI strings, exactly `width` wide) for a diff body. `hidden` = rows not shown because of maxRows. */
+export function renderDiffRows(diff, o) {
+    const t = o.theme, rows = parseDiff(diff), marks = wordDiffs(rows), numW = Math.max(3, String(Math.max(0, ...rows.map((r) => Math.max(r.a, r.b)))).length);
+    const out = [];
+    const num = (n, fgc, bg) => B(bg, F(fgc, (n ? String(n) : "").padStart(numW) + " "));
+    if (o.mode === "split" && o.width >= 100) {
+        const lw = Math.floor((o.width - 1) / 2), rw = o.width - 1 - lw, sep = B(t.surface, F(t.border, "│"));
+        const pairs = [];
+        for (let i = 0; i < rows.length;) {
+            const r = rows[i];
+            if (r.t === "gap") {
+                pairs.push({ l: r, r });
+                i++;
+                continue;
+            }
+            if (r.t === " ") {
+                pairs.push({ l: r, r, li: i, ri: i });
+                i++;
+                continue;
+            }
+            let d = i;
+            const ds = [], as = [];
+            while (d < rows.length && rows[d].t === "-")
+                ds.push(d++);
+            while (d < rows.length && rows[d].t === "+")
+                as.push(d++);
+            for (let k = 0; k < Math.max(ds.length, as.length); k++)
+                pairs.push({ l: ds[k] !== undefined ? rows[ds[k]] : undefined, r: as[k] !== undefined ? rows[as[k]] : undefined, li: ds[k], ri: as[k] });
+            i = d;
+        }
+        const side = (line, idx, isLeft) => {
+            const half = isLeft ? lw : rw;
+            if (!line)
+                return fit("", half, t.surface);
+            if (line.t === "gap")
+                return fit(" " + F(t.faint, "⋯"), half, t.surface2);
+            const kind = line.t, bg = kind === "-" ? t.delBg : kind === "+" ? t.addBg : t.surface, strong = kind === "-" ? t.delStrong : t.addStrong;
+            const n = isLeft ? line.a : line.b, signFg = kind === "-" ? t.delFg : kind === "+" ? t.addFg : t.faint;
+            return fit(num(n, kind === " " ? t.faint : signFg, bg) + F(signFg, kind === " " ? "  " : kind + " ") + paintCode(line.text, o.lang, t, bg, strong, idx !== undefined ? marks.get(idx) : undefined), half, bg);
+        };
+        for (const p of pairs)
+            out.push(side(p.l, p.li, true) + sep + side(p.r, p.ri, false));
+    }
+    else {
+        rows.forEach((r, i) => {
+            if (r.t === "gap") {
+                out.push(fit(F(t.faint, " ".repeat(numW * 2 + 2) + "⋯"), o.width, t.surface2));
+                return;
+            }
+            const bg = r.t === "-" ? t.delBg : r.t === "+" ? t.addBg : t.surface, strong = r.t === "-" ? t.delStrong : t.addStrong;
+            const gutter = num(r.a, r.t === "-" ? t.delFg : t.faint, bg) + num(r.b, r.t === "+" ? t.addFg : t.faint, bg);
+            const sign = F(r.t === "-" ? t.delFg : r.t === "+" ? t.addFg : t.faint, r.t === " " ? "  " : r.t + " ");
+            out.push(fit(gutter + sign + paintCode(r.text, o.lang, t, bg, strong, marks.get(i)), o.width, bg));
+        });
+    }
+    const max = o.maxRows ?? Infinity;
+    return { rows: out.slice(0, max), hidden: Math.max(0, out.length - max), total: out.length };
+}

package/dist/cli/tui/editor.d.ts

@@ -0,0 +1,60 @@
+export type Layout = {
+    rows: {
+        line: number;
+        start: number;
+        end: number;
+    }[];
+    cursorRow: number;
+    cursorCol: number;
+};
+export declare class Editor {
+    lines: string[];
+    row: number;
+    col: number;
+    width: number;
+    history: string[];
+    private hIdx;
+    private draft;
+    private goal;
+    private pastes;
+    private pasteN;
+    get text(): string;
+    get empty(): boolean;
+    get cursorIndex(): number;
+    setText(t: string, cursor?: "end" | number): void;
+    clear(): void;
+    insert(s: string): void;
+    /** Large pastes become a short placeholder (like Claude Code); `submit()` expands it back. */
+    paste(s: string): void;
+    newline(): void;
+    private prevIdx;
+    private nextIdx;
+    backspace(): void;
+    del(): void;
+    left(): void;
+    right(): void;
+    home(): void;
+    end(): void;
+    wordLeft(): void;
+    wordRight(): void;
+    deleteWordBack(): void;
+    killToEnd(): void;
+    killToStart(): void;
+    /** Soft-wrapped visual rows for a given content width, plus where the cursor lands. */
+    layout(width: number): Layout;
+    /** Move the cursor one visual row up/down. Returns false at the top/bottom edge (caller can then browse history). */
+    vertical(dir: -1 | 1): boolean;
+    /** ↑ at the top row recalls older input, ↓ at the bottom row newer input. Returns whether anything changed. */
+    historyPrev(): boolean;
+    historyNext(): boolean;
+    /** Final text with paste placeholders expanded. Records history and clears the buffer. */
+    submit(): string;
+    /** Lines to draw (prompt gutter included) and the cursor position inside them. */
+    render(width: number, prompt?: string, cont?: string): {
+        lines: string[];
+        cursor: {
+            row: number;
+            col: number;
+        };
+    };
+}

package/dist/cli/tui/editor.js

@@ -0,0 +1,230 @@
+// Multi-line input editor as a pure state machine (no terminal I/O), so every behaviour is unit-testable.
+import { cellWidth, cpWidth } from "./text.js";
+const PH = /\[Pasted text #(\d+) \+\d+ lines?\]/g;
+const isWord = (ch) => /[\p{L}\p{N}_]/u.test(ch);
+export class Editor {
+    lines = [""];
+    row = 0;
+    col = 0; // UTF-16 index into lines[row]
+    width = 80; // content width used for visual-line movement (set by render)
+    history = [];
+    hIdx = -1;
+    draft = "";
+    goal = null; // desired display column for vertical moves
+    pastes = new Map();
+    pasteN = 0;
+    get text() { return this.lines.join("\n"); }
+    get empty() { return this.text.length === 0; }
+    get cursorIndex() { return this.lines.slice(0, this.row).reduce((n, l) => n + l.length + 1, 0) + this.col; }
+    setText(t, cursor = "end") {
+        this.lines = t.split("\n");
+        this.goal = null;
+        if (cursor === "end") {
+            this.row = this.lines.length - 1;
+            this.col = this.lines[this.row].length;
+        }
+        else {
+            let i = cursor;
+            this.row = 0;
+            while (this.row < this.lines.length - 1 && i > this.lines[this.row].length) {
+                i -= this.lines[this.row].length + 1;
+                this.row++;
+            }
+            this.col = i;
+        }
+    }
+    clear() { this.setText(""); this.pastes.clear(); this.hIdx = -1; }
+    insert(s) {
+        s = s.replace(/\r\n?/g, "\n");
+        this.goal = null;
+        const parts = s.split("\n"), cur = this.lines[this.row], tail = cur.slice(this.col);
+        this.lines[this.row] = cur.slice(0, this.col) + parts[0];
+        if (parts.length === 1) {
+            this.lines[this.row] += tail;
+            this.col += parts[0].length;
+            return;
+        }
+        const mid = parts.slice(1, -1), last = parts.at(-1);
+        this.lines.splice(this.row + 1, 0, ...mid, last + tail);
+        this.row += parts.length - 1;
+        this.col = last.length;
+    }
+    /** Large pastes become a short placeholder (like Claude Code); `submit()` expands it back. */
+    paste(s) {
+        s = s.replace(/\r\n?/g, "\n");
+        const n = s.split("\n").length;
+        if (s.length > 600 || n > 8) {
+            const id = ++this.pasteN;
+            this.pastes.set(id, s);
+            this.insert(`[Pasted text #${id} +${n} line${n > 1 ? "s" : ""}]`);
+        }
+        else
+            this.insert(s);
+    }
+    newline() { this.insert("\n"); }
+    prevIdx(s, i) { if (i <= 0)
+        return 0; i--; if (i > 0 && s.charCodeAt(i) >= 0xdc00 && s.charCodeAt(i) <= 0xdfff)
+        i--; return i; }
+    nextIdx(s, i) { if (i >= s.length)
+        return s.length; const c = s.charCodeAt(i); return i + (c >= 0xd800 && c <= 0xdbff ? 2 : 1); }
+    backspace() {
+        this.goal = null;
+        if (this.col > 0) {
+            const before = this.lines[this.row].slice(0, this.col), m = before.match(/\[Pasted text #\d+ \+\d+ lines?\]$/); // delete a placeholder as one unit
+            const from = m ? this.col - m[0].length : this.prevIdx(before, this.col);
+            this.lines[this.row] = this.lines[this.row].slice(0, from) + this.lines[this.row].slice(this.col);
+            this.col = from;
+        }
+        else if (this.row > 0) {
+            const prev = this.lines[this.row - 1];
+            this.lines[this.row - 1] = prev + this.lines[this.row];
+            this.lines.splice(this.row, 1);
+            this.row--;
+            this.col = prev.length;
+        }
+    }
+    del() {
+        this.goal = null;
+        const l = this.lines[this.row];
+        if (this.col < l.length)
+            this.lines[this.row] = l.slice(0, this.col) + l.slice(this.nextIdx(l, this.col));
+        else if (this.row < this.lines.length - 1) {
+            this.lines[this.row] = l + this.lines[this.row + 1];
+            this.lines.splice(this.row + 1, 1);
+        }
+    }
+    left() { this.goal = null; if (this.col > 0)
+        this.col = this.prevIdx(this.lines[this.row], this.col);
+    else if (this.row > 0) {
+        this.row--;
+        this.col = this.lines[this.row].length;
+    } }
+    right() { this.goal = null; const l = this.lines[this.row]; if (this.col < l.length)
+        this.col = this.nextIdx(l, this.col);
+    else if (this.row < this.lines.length - 1) {
+        this.row++;
+        this.col = 0;
+    } }
+    home() { this.goal = null; this.col = 0; }
+    end() { this.goal = null; this.col = this.lines[this.row].length; }
+    wordLeft() {
+        this.goal = null;
+        if (this.col === 0)
+            return this.left();
+        const l = this.lines[this.row];
+        let i = this.col;
+        while (i > 0 && !isWord(l[i - 1]))
+            i--;
+        while (i > 0 && isWord(l[i - 1]))
+            i--;
+        this.col = i;
+    }
+    wordRight() {
+        this.goal = null;
+        const l = this.lines[this.row];
+        if (this.col >= l.length)
+            return this.right();
+        let i = this.col;
+        while (i < l.length && !isWord(l[i]))
+            i++;
+        while (i < l.length && isWord(l[i]))
+            i++;
+        this.col = i;
+    }
+    deleteWordBack() { const to = this.col; this.wordLeft(); this.lines[this.row] = this.lines[this.row].slice(0, this.col) + this.lines[this.row].slice(to); }
+    killToEnd() { this.goal = null; const l = this.lines[this.row]; if (this.col < l.length)
+        this.lines[this.row] = l.slice(0, this.col);
+    else
+        this.del(); }
+    killToStart() { this.goal = null; this.lines[this.row] = this.lines[this.row].slice(this.col); this.col = 0; }
+    /** Soft-wrapped visual rows for a given content width, plus where the cursor lands. */
+    layout(width) {
+        const w = Math.max(4, width), rows = [];
+        let cursorRow = 0, cursorCol = 0;
+        this.lines.forEach((line, li) => {
+            let start = 0, i = 0, vis = 0, lastSpace = -1;
+            const push = (end) => { rows.push({ line: li, start, end }); };
+            while (i < line.length) {
+                const cp = line.codePointAt(i), ch = String.fromCodePoint(cp), cw = cpWidth(cp);
+                if (vis + cw > w) {
+                    const brk = lastSpace > start ? lastSpace + 1 : i;
+                    push(brk);
+                    start = brk;
+                    i = brk;
+                    vis = cellWidth(line.slice(start, i));
+                    lastSpace = -1;
+                    continue;
+                }
+                if (ch === " ")
+                    lastSpace = i;
+                vis += cw;
+                i += ch.length;
+            }
+            push(line.length);
+        });
+        rows.forEach((r, idx) => {
+            if (r.line !== this.row)
+                return;
+            const last = idx === rows.length - 1 || rows[idx + 1].line !== r.line;
+            if (this.col >= r.start && (this.col < r.end || (last && this.col <= r.end))) {
+                cursorRow = idx;
+                cursorCol = cellWidth(this.lines[r.line].slice(r.start, this.col));
+            }
+        });
+        return { rows, cursorRow, cursorCol };
+    }
+    /** Move the cursor one visual row up/down. Returns false at the top/bottom edge (caller can then browse history). */
+    vertical(dir) {
+        const lay = this.layout(this.width), target = lay.cursorRow + dir;
+        if (target < 0 || target >= lay.rows.length)
+            return false;
+        this.goal ??= lay.cursorCol;
+        const r = lay.rows[target], text = this.lines[r.line];
+        let col = r.start, w = 0;
+        while (col < r.end) {
+            const cw = cpWidth(text.codePointAt(col));
+            if (w + cw > this.goal)
+                break;
+            w += cw;
+            col += text.codePointAt(col) > 0xffff ? 2 : 1;
+        }
+        const lastRowOfLine = target === lay.rows.length - 1 || lay.rows[target + 1].line !== r.line; // the cursor may sit after the final character only
+        this.row = r.line;
+        this.col = Math.min(col, lastRowOfLine ? r.end : Math.max(r.start, r.end - 1));
+        return true;
+    }
+    /** ↑ at the top row recalls older input, ↓ at the bottom row newer input. Returns whether anything changed. */
+    historyPrev() {
+        if (!this.history.length || this.hIdx + 1 >= this.history.length)
+            return false;
+        if (this.hIdx === -1)
+            this.draft = this.text;
+        this.hIdx++;
+        this.setText(this.history[this.hIdx]);
+        return true;
+    }
+    historyNext() {
+        if (this.hIdx < 0)
+            return false;
+        this.hIdx--;
+        this.setText(this.hIdx < 0 ? this.draft : this.history[this.hIdx]);
+        return true;
+    }
+    /** Final text with paste placeholders expanded. Records history and clears the buffer. */
+    submit() {
+        const out = this.text.replace(PH, (m, id) => this.pastes.get(Number(id)) ?? m).trim();
+        if (out && this.history[0] !== out)
+            this.history.unshift(out);
+        this.history = this.history.slice(0, 200);
+        this.clear();
+        return out;
+    }
+    /** Lines to draw (prompt gutter included) and the cursor position inside them. */
+    render(width, prompt = "❯ ", cont = "  ") {
+        const gw = cellWidth(prompt), cw = Math.max(8, width - gw);
+        this.width = cw;
+        const lay = this.layout(cw);
+        const lines = lay.rows.map((r, i) => (i === 0 ? prompt : cont) + this.lines[r.line].slice(r.start, r.end).replace(/ $/, (m) => (r.end === this.lines[r.line].length ? m : m)));
+        return { lines, cursor: { row: lay.cursorRow, col: gw + lay.cursorCol } };
+    }
+}