agent-sh 0.2.0 → 0.3.1

package/dist/utils/line-editor.d.ts

@@ -16,6 +16,8 @@ export type LineEditAction = {
     action: "delete-empty";
 } | {
     action: "tab";
+} | {
+    action: "shift+tab";
 } | {
     action: "arrow-up";
 } | {
@@ -24,12 +26,30 @@ export type LineEditAction = {
 export declare class LineEditor {
     buffer: string;
     cursor: number;
+    private pendingSeq;
     /** Process raw terminal input, return actions for the consumer. */
     feed(data: string): LineEditAction[];
+    /** Check if there's a pending incomplete escape sequence. */
+    hasPendingEscape(): boolean;
+    /** Flush a pending sequence — treat bare \x1b as cancel, discard incomplete CSI. */
+    flushPendingEscape(): LineEditAction[];
     clear(): void;
+    private readonly bindings;
+    /** Resolve a key name from the bindings table and execute it. */
+    private dispatch;
+    /** Map a legacy control character to a key name. */
+    private static readonly CTRL_MAP;
+    private handleControl;
+    /** Handle a kitty protocol CSI u sequence. Params format: "keycode;modifier". */
+    private handleKittyKey;
+    private insertAt;
+    private moveTo;
+    private deleteBackward;
+    private deleteForward;
+    private deleteRange;
     /**
      * Parse and handle a CSI sequence (\x1b[...) starting at `start`.
-     * Returns the number of bytes consumed.
+     * Returns the number of bytes consumed and whether the sequence was incomplete.
      */
     private handleCSI;
     private wordBackward;

package/dist/utils/line-editor.js

@@ -5,12 +5,22 @@
  * terminal input bytes and receive high-level actions back. Buffer and
  * cursor state are public for rendering.
  */
+// ── Kitty protocol keycode → readable name ──────────────────────
+const KITTY_KEY_NAMES = {
+    9: "tab", 13: "enter", 27: "escape", 127: "backspace",
+};
 // ── Line editor ─────────────────────────────────────────────────
 export class LineEditor {
     buffer = "";
     cursor = 0;
+    pendingSeq = ""; // buffered incomplete escape sequence
     /** Process raw terminal input, return actions for the consumer. */
     feed(data) {
+        // If we had a pending incomplete escape sequence, prepend it
+        if (this.pendingSeq) {
+            data = this.pendingSeq + data;
+            this.pendingSeq = "";
+        }
         const actions = [];
         let i = 0;
         while (i < data.length) {
@@ -18,16 +28,66 @@ export class LineEditor {
             // ── Escape sequences ────────────────────────────────
             if (ch === "\x1b") {
                 const next = data[i + 1];
-                // Bare Escape (nothing follows in this chunk)
+                // Incomplete escape — buffer and wait for next feed()
                 if (next == null) {
-                    actions.push({ action: "cancel" });
+                    this.pendingSeq = "\x1b";
                     i++;
                     continue;
                 }
                 // CSI sequence: \x1b[...
                 if (next === "[") {
-                    const { consumed } = this.handleCSI(data, i, actions);
-                    i += consumed;
+                    const { consumed, incomplete } = this.handleCSI(data, i, actions);
+                    if (incomplete) {
+                        this.pendingSeq = data.slice(i, i + consumed);
+                        i += consumed;
+                    }
+                    else {
+                        i += consumed;
+                    }
+                    continue;
+                }
+                // SS3 sequence: \x1bO... (application cursor mode — arrow keys, Home, End)
+                if (next === "O") {
+                    const ss3Final = data[i + 2];
+                    if (ss3Final == null) {
+                        // Incomplete — buffer for next feed()
+                        this.pendingSeq = data.slice(i, i + 2);
+                        i += 2;
+                        continue;
+                    }
+                    i += 3; // consume \x1b O <final>
+                    switch (ss3Final) {
+                        case "A":
+                            actions.push({ action: "arrow-up" });
+                            break;
+                        case "B":
+                            actions.push({ action: "arrow-down" });
+                            break;
+                        case "C":
+                            if (this.cursor < this.buffer.length) {
+                                this.cursor++;
+                                actions.push({ action: "changed" });
+                            }
+                            break;
+                        case "D":
+                            if (this.cursor > 0) {
+                                this.cursor--;
+                                actions.push({ action: "changed" });
+                            }
+                            break;
+                        case "H": // Home
+                            if (this.cursor > 0) {
+                                this.cursor = 0;
+                                actions.push({ action: "changed" });
+                            }
+                            break;
+                        case "F": // End
+                            if (this.cursor < this.buffer.length) {
+                                this.cursor = this.buffer.length;
+                                actions.push({ action: "changed" });
+                            }
+                            break;
+                    }
                     continue;
                 }
                 // Alt/Option + key: \x1b followed by char
@@ -56,98 +116,10 @@ export class LineEditor {
                 continue;
             }
             // ── Control characters ──────────────────────────────
-            if (ch === "\r") {
-                actions.push({ action: "submit", buffer: this.buffer });
-                i++;
-                continue;
-            }
-            if (ch === "\x03") {
-                actions.push({ action: "cancel" });
-                i++;
-                continue;
-            }
-            if (ch === "\t") {
-                actions.push({ action: "tab" });
-                i++;
-                continue;
-            }
-            if (ch === "\x7f" || ch === "\b") {
-                // Backspace
-                if (this.buffer.length === 0) {
-                    actions.push({ action: "delete-empty" });
-                }
-                else if (this.cursor > 0) {
-                    this.buffer = this.buffer.slice(0, this.cursor - 1) + this.buffer.slice(this.cursor);
-                    this.cursor--;
-                    actions.push({ action: "changed" });
-                }
-                i++;
-                continue;
-            }
-            // Ctrl-A: home
-            if (ch === "\x01") {
-                if (this.cursor > 0) {
-                    this.cursor = 0;
-                    actions.push({ action: "changed" });
-                }
-                i++;
-                continue;
-            }
-            // Ctrl-E: end
-            if (ch === "\x05") {
-                if (this.cursor < this.buffer.length) {
-                    this.cursor = this.buffer.length;
-                    actions.push({ action: "changed" });
-                }
-                i++;
-                continue;
-            }
-            // Ctrl-B: back one char
-            if (ch === "\x02") {
-                if (this.cursor > 0) {
-                    this.cursor--;
-                    actions.push({ action: "changed" });
-                }
-                i++;
-                continue;
-            }
-            // Ctrl-F: forward one char
-            if (ch === "\x06") {
-                if (this.cursor < this.buffer.length) {
-                    this.cursor++;
-                    actions.push({ action: "changed" });
-                }
-                i++;
-                continue;
-            }
-            // Ctrl-U: delete to start of line
-            if (ch === "\x15") {
-                if (this.cursor > 0) {
-                    this.buffer = this.buffer.slice(this.cursor);
-                    this.cursor = 0;
-                    actions.push({ action: "changed" });
-                }
-                i++;
-                continue;
-            }
-            // Ctrl-K: delete to end of line
-            if (ch === "\x0b") {
-                if (this.cursor < this.buffer.length) {
-                    this.buffer = this.buffer.slice(0, this.cursor);
-                    actions.push({ action: "changed" });
-                }
-                i++;
-                continue;
-            }
-            // Ctrl-W: delete word backward
-            if (ch === "\x17") {
-                if (this.deleteWordBackward())
-                    actions.push({ action: "changed" });
-                i++;
-                continue;
-            }
-            // Other control chars — ignore
-            if (ch.charCodeAt(0) < 0x20) {
+            if (ch.charCodeAt(0) < 0x20 || ch === "\x7f") {
+                const action = this.handleControl(ch);
+                if (action)
+                    actions.push(action);
                 i++;
                 continue;
             }
@@ -159,14 +131,123 @@ export class LineEditor {
         }
         return actions;
     }
+    /** Check if there's a pending incomplete escape sequence. */
+    hasPendingEscape() {
+        return this.pendingSeq.length > 0;
+    }
+    /** Flush a pending sequence — treat bare \x1b as cancel, discard incomplete CSI. */
+    flushPendingEscape() {
+        if (!this.pendingSeq)
+            return [];
+        const wasBarEscape = this.pendingSeq === "\x1b";
+        this.pendingSeq = "";
+        return wasBarEscape ? [{ action: "cancel" }] : [];
+    }
     clear() {
         this.buffer = "";
         this.cursor = 0;
+        this.pendingSeq = "";
+    }
+    // ── Key bindings ────────────────────────────────────────────
+    //
+    // Single source of truth for all keybindings. Both legacy control
+    // characters and kitty protocol sequences resolve to a key name
+    // and look it up here. To add a binding, add one entry.
+    bindings = {
+        "enter": () => ({ action: "submit", buffer: this.buffer }),
+        "ctrl+c": () => ({ action: "cancel" }),
+        "tab": () => ({ action: "tab" }),
+        "backspace": () => this.deleteBackward(),
+        "ctrl+d": () => this.buffer.length === 0 ? { action: "delete-empty" } : this.deleteForward(),
+        "ctrl+a": () => this.moveTo(0),
+        "ctrl+e": () => this.moveTo(this.buffer.length),
+        "ctrl+b": () => this.moveTo(this.cursor - 1),
+        "ctrl+f": () => this.moveTo(this.cursor + 1),
+        "ctrl+u": () => this.deleteRange(0, this.cursor),
+        "ctrl+k": () => this.deleteRange(this.cursor, this.buffer.length),
+        "ctrl+w": () => this.deleteWordBackward() ? { action: "changed" } : null,
+        "shift+enter": () => this.insertAt("\n"),
+        "shift+tab": () => ({ action: "shift+tab" }),
+    };
+    /** Resolve a key name from the bindings table and execute it. */
+    dispatch(key) {
+        return this.bindings[key]?.() ?? null;
+    }
+    // ── Legacy control character mapping ───────────────────────
+    /** Map a legacy control character to a key name. */
+    static CTRL_MAP = {
+        "\r": "enter", "\x03": "ctrl+c", "\t": "tab",
+        "\x7f": "backspace", "\b": "backspace",
+        "\x01": "ctrl+a", "\x02": "ctrl+b", "\x04": "ctrl+d",
+        "\x05": "ctrl+e", "\x06": "ctrl+f", "\x0b": "ctrl+k",
+        "\x15": "ctrl+u", "\x17": "ctrl+w",
+    };
+    handleControl(ch) {
+        const key = LineEditor.CTRL_MAP[ch];
+        return key ? this.dispatch(key) : null;
+    }
+    // ── Kitty keyboard protocol ────────────────────────────────
+    /** Handle a kitty protocol CSI u sequence. Params format: "keycode;modifier". */
+    handleKittyKey(params) {
+        const [kc, mod] = params.split(";").map(Number);
+        const keycode = kc;
+        const mods = (mod ?? 1) - 1; // kitty modifier bits
+        // Build key name from modifier + keycode
+        const modNames = [];
+        if (mods & 4)
+            modNames.push("ctrl");
+        if (mods & 1)
+            modNames.push("shift");
+        if (mods & 2)
+            modNames.push("alt");
+        const keyName = KITTY_KEY_NAMES[keycode] ?? String.fromCharCode(keycode);
+        const fullName = [...modNames, keyName].join("+");
+        // Try exact binding first, then fall back to ctrl char mapping
+        return this.dispatch(fullName)
+            ?? ((mods & 4) && keycode >= 97 && keycode <= 122
+                ? this.dispatch(`ctrl+${String.fromCharCode(keycode)}`)
+                : null)
+            ?? (mods === 0 ? this.handleControl(String.fromCharCode(keycode)) : null);
+    }
+    // ── Editing primitives ─────────────────────────────────────
+    insertAt(ch) {
+        this.buffer = this.buffer.slice(0, this.cursor) + ch + this.buffer.slice(this.cursor);
+        this.cursor++;
+        return { action: "changed" };
+    }
+    moveTo(pos) {
+        const clamped = Math.max(0, Math.min(pos, this.buffer.length));
+        if (clamped === this.cursor)
+            return null;
+        this.cursor = clamped;
+        return { action: "changed" };
+    }
+    deleteBackward() {
+        if (this.buffer.length === 0)
+            return { action: "delete-empty" };
+        if (this.cursor <= 0)
+            return null;
+        this.buffer = this.buffer.slice(0, this.cursor - 1) + this.buffer.slice(this.cursor);
+        this.cursor--;
+        return { action: "changed" };
+    }
+    deleteForward() {
+        if (this.cursor >= this.buffer.length)
+            return null;
+        this.buffer = this.buffer.slice(0, this.cursor) + this.buffer.slice(this.cursor + 1);
+        return { action: "changed" };
+    }
+    deleteRange(start, end) {
+        if (start >= end)
+            return null;
+        this.buffer = this.buffer.slice(0, start) + this.buffer.slice(end);
+        this.cursor = start;
+        return { action: "changed" };
     }
     // ── CSI sequence handling ───────────────────────────────────
     /**
      * Parse and handle a CSI sequence (\x1b[...) starting at `start`.
-     * Returns the number of bytes consumed.
+     * Returns the number of bytes consumed and whether the sequence was incomplete.
      */
     handleCSI(data, start, actions) {
         // Skip \x1b[
@@ -177,8 +258,12 @@ export class LineEditor {
             params += data[j];
             j++;
         }
-        const final = j < data.length ? data[j] : "";
-        const consumed = j - start + (final ? 1 : 0);
+        // If we ran out of data before the final byte, sequence is incomplete
+        if (j >= data.length) {
+            return { consumed: j - start, incomplete: true };
+        }
+        const final = data[j];
+        const consumed = j - start + 1;
         // Dispatch on final byte
         switch (final) {
             case "A": // Up arrow
@@ -223,6 +308,15 @@ export class LineEditor {
                     actions.push({ action: "changed" });
                 }
                 break;
+            case "Z": // Shift+Tab (legacy CSI sequence)
+                actions.push({ action: "shift+tab" });
+                break;
+            case "u": { // Kitty keyboard protocol: \x1b[<keycode>;<modifier>u
+                const action = this.handleKittyKey(params);
+                if (action)
+                    actions.push(action);
+                break;
+            }
             case "~": // Extended keys: Delete (3~), etc.
                 if (params === "3") {
                     // Delete key: delete char under cursor

package/dist/utils/markdown.d.ts

@@ -7,15 +7,18 @@ export declare function wrapLine(text: string, maxWidth: number): string[];
  * Streaming markdown renderer that processes chunks of text,
  * renders complete lines with ANSI formatting, and wraps output
  * in a bordered box.
+ *
+ * The renderer accumulates lines internally. Call `drainLines()` to
+ * extract them — this is the only way output leaves the renderer.
  */
 export declare class MarkdownRenderer {
     private buffer;
-    private inCodeBlock;
-    private codeLanguage;
-    private codeLines;
     private contentWidth;
     private firstLine;
-    constructor(terminalWidth?: number);
+    private pendingLines;
+    private width;
+    private tableRows;
+    constructor(width: number);
     /**
      * Push a streaming chunk. Complete lines are rendered immediately;
      * incomplete trailing text stays in the buffer.
@@ -27,13 +30,19 @@ export declare class MarkdownRenderer {
     flush(): void;
     printTopBorder(): void;
     printBottomBorder(): void;
+    /**
+     * Extract and clear all accumulated lines.
+     * This is the only way output leaves the renderer.
+     */
+    drainLines(): string[];
     private processBuffer;
     private processLine;
+    private flushTable;
     private renderLine;
     private renderInline;
-    private renderCodeBlock;
     /**
-     * Write a single line with a subtle left indent.
+     * Add a single line with a subtle left indent.
+     * The line is accumulated internally — call drainLines() to extract.
      */
     writeLine(text: string): void;
 }

package/dist/utils/markdown.js

@@ -1,4 +1,3 @@
-import { highlight } from "cli-highlight";
 import { visibleLen } from "./ansi.js";
 import { palette as p } from "./palette.js";
 const MAX_CONTENT_WIDTH = 90;
@@ -7,6 +6,8 @@ const MAX_CONTENT_WIDTH = 90;
  * Returns an array of lines, each fitting within `maxWidth` visible characters.
  */
 export function wrapLine(text, maxWidth) {
+    if (!(maxWidth > 0))
+        return [text]; // catches NaN, <=0, undefined
     if (visibleLen(text) <= maxWidth)
         return [text];
     const result = [];
@@ -74,18 +75,20 @@ export function wrapLine(text, maxWidth) {
  * Streaming markdown renderer that processes chunks of text,
  * renders complete lines with ANSI formatting, and wraps output
  * in a bordered box.
+ *
+ * The renderer accumulates lines internally. Call `drainLines()` to
+ * extract them — this is the only way output leaves the renderer.
  */
 export class MarkdownRenderer {
     buffer = "";
-    inCodeBlock = false;
-    codeLanguage = "";
-    codeLines = [];
     contentWidth;
     firstLine = true;
-    constructor(terminalWidth) {
-        const termW = terminalWidth ?? (process.stdout.columns || 100);
-        // 2-char left indent for content
-        this.contentWidth = Math.min(MAX_CONTENT_WIDTH, termW - 2);
+    pendingLines = [];
+    width;
+    tableRows = [];
+    constructor(width) {
+        this.width = Math.max(10, width);
+        this.contentWidth = Math.min(MAX_CONTENT_WIDTH, this.width - 2);
     }
     /**
      * Push a streaming chunk. Complete lines are rendered immediately;
@@ -99,22 +102,27 @@ export class MarkdownRenderer {
      * Flush any remaining text in the buffer (called when the response ends).
      */
     flush() {
-        if (this.inCodeBlock) {
-            this.renderCodeBlock();
-        }
         if (this.buffer.length > 0) {
             this.processLine(this.buffer);
             this.buffer = "";
         }
+        this.flushTable();
     }
     printTopBorder() {
-        const w = Math.min(this.contentWidth, 40);
-        process.stdout.write(`${p.dim}${p.accent}${"─".repeat(w)}${p.reset}\n`);
+        this.pendingLines.push(`${p.dim}${p.accent}${"─".repeat(this.width)}${p.reset}`);
         this.firstLine = true;
     }
     printBottomBorder() {
-        const w = Math.min(this.contentWidth, 40);
-        process.stdout.write(`${p.dim}${p.accent}${"─".repeat(w)}${p.reset}\n`);
+        this.pendingLines.push(`${p.dim}${p.accent}${"─".repeat(this.width)}${p.reset}`);
+    }
+    /**
+     * Extract and clear all accumulated lines.
+     * This is the only way output leaves the renderer.
+     */
+    drainLines() {
+        const lines = this.pendingLines;
+        this.pendingLines = [];
+        return lines;
     }
     processBuffer() {
         const lines = this.buffer.split("\n");
@@ -124,32 +132,82 @@ export class MarkdownRenderer {
         }
     }
     processLine(line) {
-        // Code fence detection
-        const fenceMatch = line.match(/^(\s*)```(\w*)/);
-        if (fenceMatch) {
-            if (!this.inCodeBlock) {
-                this.inCodeBlock = true;
-                this.codeLanguage = fenceMatch[2] || "";
-                this.codeLines = [];
+        // Table row detection: lines with | separators
+        if (/^\s*\|/.test(line)) {
+            const cells = parseTableRow(line);
+            if (cells) {
+                this.tableRows.push(cells);
                 return;
             }
-            else {
-                this.inCodeBlock = false;
-                this.renderCodeBlock();
-                return;
-            }
-        }
-        if (this.inCodeBlock) {
-            this.codeLines.push(line);
-            return;
         }
+        // Non-table line — flush any buffered table first
+        this.flushTable();
         const rendered = this.renderLine(line);
-        // Word-wrap and output each wrapped line
         const wrapped = wrapLine(rendered, this.contentWidth);
         for (const wl of wrapped) {
             this.writeLine(wl);
         }
     }
+    flushTable() {
+        if (this.tableRows.length === 0)
+            return;
+        const rows = this.tableRows;
+        this.tableRows = [];
+        // Filter out separator rows (|---|---|)
+        const sepIdx = [];
+        const dataRows = [];
+        for (let i = 0; i < rows.length; i++) {
+            if (rows[i].every((c) => /^[-:]+$/.test(c.trim()) || c.trim() === "")) {
+                sepIdx.push(i);
+            }
+            else {
+                dataRows.push(rows[i]);
+            }
+        }
+        if (dataRows.length === 0)
+            return;
+        // Normalize column count
+        const numCols = Math.max(...dataRows.map((r) => r.length));
+        for (const row of dataRows) {
+            while (row.length < numCols)
+                row.push("");
+        }
+        // Calculate column widths from content
+        const colWidths = new Array(numCols).fill(0);
+        for (const row of dataRows) {
+            for (let c = 0; c < numCols; c++) {
+                colWidths[c] = Math.max(colWidths[c], row[c].length);
+            }
+        }
+        // Shrink columns proportionally if total exceeds content width
+        // Account for separators: " │ " between cols (3 chars each) + 2 outer padding
+        const separatorWidth = (numCols - 1) * 3;
+        const availableWidth = this.contentWidth - separatorWidth;
+        const totalWidth = colWidths.reduce((a, b) => a + b, 0);
+        if (totalWidth > availableWidth && availableWidth > numCols) {
+            const scale = availableWidth / totalWidth;
+            for (let c = 0; c < numCols; c++) {
+                colWidths[c] = Math.max(1, Math.floor(colWidths[c] * scale));
+            }
+        }
+        // Render rows
+        const hasHeader = sepIdx.includes(1) && dataRows.length > 1;
+        for (let i = 0; i < dataRows.length; i++) {
+            const row = dataRows[i];
+            const isHeader = hasHeader && i === 0;
+            const cells = row.map((cell, c) => {
+                const w = colWidths[c];
+                const text = cell.length > w ? cell.slice(0, w - 1) + "…" : cell.padEnd(w);
+                return isHeader ? `${p.bold}${text}${p.reset}` : text;
+            });
+            this.writeLine(`${p.dim}│${p.reset} ${cells.join(` ${p.dim}│${p.reset} `)} ${p.dim}│${p.reset}`);
+            // Separator after header
+            if (isHeader) {
+                const sep = colWidths.map((w) => "─".repeat(w)).join(`─┼─`);
+                this.writeLine(`${p.dim}├─${sep}─┤${p.reset}`);
+            }
+        }
+    }
     renderLine(line) {
         if (line.trim() === "")
             return "";
@@ -195,54 +253,35 @@ export class MarkdownRenderer {
         text = text.replace(/\*\*\*(.+?)\*\*\*/g, `${p.bold}${p.italic}$1${p.reset}`);
         // Bold
         text = text.replace(/\*\*(.+?)\*\*/g, `${p.bold}$1${p.reset}`);
-        text = text.replace(/__(.+?)__/g, `${p.bold}$1${p.reset}`);
+        text = text.replace(/(?<!\w)__(.+?)__(?!\w)/g, `${p.bold}$1${p.reset}`);
         // Italic
         text = text.replace(/\*(.+?)\*/g, `${p.italic}$1${p.reset}`);
-        text = text.replace(/_(.+?)_/g, `${p.italic}$1${p.reset}`);
+        text = text.replace(/(?<!\w)_(.+?)_(?!\w)/g, `${p.italic}$1${p.reset}`);
         // Strikethrough
         text = text.replace(/~~(.+?)~~/g, `${p.dim}$1${p.reset}`);
         // Links
         text = text.replace(/\[([^\]]+)\]\(([^)]+)\)/g, `$1 ${p.muted}${p.underline}($2)${p.reset}`);
         return text;
     }
-    renderCodeBlock() {
-        const code = this.codeLines.join("\n");
-        const lang = this.codeLanguage;
-        if (lang) {
-            this.writeLine(`${p.dim}${lang}${p.reset}`);
-        }
-        let highlighted;
-        try {
-            highlighted = highlight(code, { language: lang || undefined });
-        }
-        catch {
-            highlighted = `${p.success}${code}${p.reset}`;
-        }
-        // Code blocks get indented, and each line is individually wrapped
-        for (const line of highlighted.split("\n")) {
-            const indented = `  ${line}`;
-            const wrapped = wrapLine(indented, this.contentWidth);
-            for (const wl of wrapped) {
-                this.writeLine(wl);
-            }
-        }
-        this.codeLanguage = "";
-        this.codeLines = [];
-    }
     /**
-     * Write a single line with a subtle left indent.
+     * Add a single line with a subtle left indent.
+     * The line is accumulated internally — call drainLines() to extract.
      */
     writeLine(text) {
         if (this.firstLine && visibleLen(text) === 0)
             return;
         this.firstLine = false;
-        process.stdout.write(`  ${text}\n`);
-        if (process.stdout.writable) {
-            try {
-                process.stdout.write('');
-            }
-            catch (e) {
-            }
-        }
+        this.pendingLines.push(`  ${text}`);
     }
 }
+/** Parse a markdown table row into trimmed cell strings, or null if not a table row. */
+function parseTableRow(line) {
+    const trimmed = line.trim();
+    if (!trimmed.startsWith("|") || !trimmed.endsWith("|"))
+        return null;
+    // Split on |, drop first and last empty entries
+    const parts = trimmed.split("|");
+    if (parts.length < 3)
+        return null; // need at least |cell|
+    return parts.slice(1, -1).map((c) => c.trim());
+}