@north-light/crouter 0.3.317 → 0.3.319

package/dist/clients/attach/input/titled-editor.js

@@ -1,859 +1,4 @@
-// input/titled-editor.ts — the `crtr surface attach` input editor with two bits of chrome pi's
-// stock editor doesn't give us:
-//   1. the session name painted INTO the top border as a solid-background chip,
-//      so it stays pinned to the editor instead of scrolling off as a free badge;
-//   2. a border color that tracks the agent's thinking level (set by viewer.ts
-//      on each state update), mirroring pi's `getThinkingBorderColor`.
-// Both are pure render-layer chrome; nothing here touches the socket or session.
-import { statSync } from 'node:fs';
-import { CustomEditor } from '@earendil-works/pi-coding-agent';
-import { CURSOR_MARKER, truncateToWidth, visibleWidth, wrapTextWithAnsi, } from '@earendil-works/pi-tui';
-// Deep import: `wordWrapLine` implements pi-tui's exact word-wrap algorithm but is
-// not re-exported from the package root (only `Editor`/`EditorTheme`/`EditorOptions`
-// are). The package has no `"exports"` field, so a deep subpath import is not
-// blocked by Node's resolution. We need the EXACT wrap algorithm (not a
-// reimplementation) to recompute layout for ref-highlight decoration below —
-// see `buildRefLayoutChunks`.
-import { wordWrapLine } from '@earendil-works/pi-tui/dist/components/editor.js';
-import { findRefTokens } from '../../../core/memory/inline-ref-grammar.js';
-import { findRefCompletionContext } from './ref-autocomplete.js';
-const LOADED_COMMAND_PREVIEW_MAX_LINES = 8;
-const LOADED_COMMAND_PREVIEW_MIN_WIDTH = 24;
-const LOADED_COMMAND_PREVIEW_MAX_CHARS = 8_192;
-/** Strip terminal controls from inline chrome only. The exact, unmodified
- * prompt remains available through the inspector. */
-function sanitizeLoadedCommandPreview(content, limit) {
-    const bounded = content.slice(0, limit);
-    const truncated = content.length > limit;
-    // CSI, OSC (BEL or ST terminated), and every remaining C0/C1 control other
-    // than newline are inert in a Text component, never terminal instructions.
-    const text = bounded
-        .replace(/\x1b\](?:[^\x07\x1b]*)(?:\x07|\x1b\\)?/g, '')
-        .replace(/\x1b\[[0-?]*[ -/]*[@-~]/g, '')
-        .replace(/[\x00-\x09\x0b-\x1f\x7f-\x9f]/g, '');
-    return { text, truncated };
-}
-/** Keep inline command disclosure compact and bounded before wrapping; the
- * inspector remains the unbounded, exact-prompt surface. */
-export function compactLoadedCommandPreview(content, width) {
-    if (width < LOADED_COMMAND_PREVIEW_MIN_WIDTH)
-        return [];
-    const limit = Math.min(LOADED_COMMAND_PREVIEW_MAX_CHARS, Math.max(256, width * LOADED_COMMAND_PREVIEW_MAX_LINES * 4));
-    const safe = sanitizeLoadedCommandPreview(content, limit);
-    const wrapped = wrapTextWithAnsi(safe.text, width);
-    if (!safe.truncated && wrapped.length <= LOADED_COMMAND_PREVIEW_MAX_LINES)
-        return wrapped;
-    const visible = wrapped.slice(0, LOADED_COMMAND_PREVIEW_MAX_LINES - 1);
-    visible.push(truncateToWidth('… truncated · inspect for full prompt', width));
-    return visible;
-}
-/** The standard thinking levels form a deliberate cool→warm ramp between blue
- *  and its orange complement. `max` is a distinct, intense cyan endpoint so it
- *  never falls back to the neutral default border. `off` alone falls back to
- *  the caller's default border color. The colors double as title-chip
- *  BACKGROUNDS under bold white text, so each must remain dark enough for the
- *  label to read clearly. */
-const THINKING_START = [46, 92, 190]; // deep blue
-const THINKING_END = [166, 98, 24]; // deep amber
-const THINKING_MAX = [0, 145, 170]; // intense cyan
-function interpolateRgb(start, end, t) {
-    return [
-        Math.round(start[0] + (end[0] - start[0]) * t),
-        Math.round(start[1] + (end[1] - start[1]) * t),
-        Math.round(start[2] + (end[2] - start[2]) * t),
-    ];
-}
-const THINKING_RGB = {
-    off: undefined, // default border color
-    minimal: interpolateRgb(THINKING_START, THINKING_END, 0 / 4),
-    low: interpolateRgb(THINKING_START, THINKING_END, 1 / 4),
-    medium: interpolateRgb(THINKING_START, THINKING_END, 2 / 4),
-    high: interpolateRgb(THINKING_START, THINKING_END, 3 / 4),
-    xhigh: interpolateRgb(THINKING_START, THINKING_END, 4 / 4),
-    max: THINKING_MAX,
-};
-/** Named colours `/color` accepts, as RGB — mirrors the tmux colour-name table
- *  (so the chip and the pane border read as the same hue). */
-const NAMED_RGB = {
-    black: [0, 0, 0],
-    red: [205, 49, 49],
-    green: [13, 188, 121],
-    yellow: [229, 229, 16],
-    blue: [36, 114, 200],
-    magenta: [188, 63, 188],
-    cyan: [17, 168, 205],
-    white: [229, 229, 229],
-    orange: [228, 152, 68],
-    grey: [128, 128, 128],
-    gray: [128, 128, 128],
-    brightred: [241, 76, 76],
-    brightgreen: [35, 209, 139],
-    brightyellow: [245, 245, 67],
-    brightblue: [59, 142, 234],
-    brightmagenta: [214, 112, 214],
-    brightcyan: [41, 184, 219],
-};
-/** Build a title-chip styler for a `/color` token (a tmux colour name, `#rrggbb`,
- *  or `colourN`): the colour as the chip BACKGROUND with contrast-picked bold
- *  text, matching the thinking-chip treatment. `undefined` for an unrenderable
- *  token (e.g. `default`) — the caller keeps its fallback style. */
-export function colorChipStyle(token) {
-    const t = token.trim().toLowerCase();
-    const c256 = /^colour(\d{1,3})$/.exec(t);
-    if (c256 !== null)
-        return (s) => `\x1b[48;5;${c256[1]}m\x1b[97m\x1b[1m ${s} \x1b[0m`;
-    let rgb;
-    const hex = /^#([0-9a-f]{6})$/.exec(t);
-    if (hex !== null) {
-        const h = hex[1];
-        rgb = [parseInt(h.slice(0, 2), 16), parseInt(h.slice(2, 4), 16), parseInt(h.slice(4, 6), 16)];
-    }
-    else {
-        rgb = NAMED_RGB[t];
-    }
-    if (rgb === undefined)
-        return undefined;
-    const [r, g, b] = rgb;
-    // Pick black-on-light / white-on-dark so the name stays readable on any hue.
-    const luma = 0.299 * r + 0.587 * g + 0.114 * b;
-    const fg = luma > 160 ? '\x1b[30m' : '\x1b[97m';
-    return (s) => `\x1b[48;2;${r};${g};${b}m${fg}\x1b[1m ${s} \x1b[0m`;
-}
-/** The default (thinking `off`) title chip: reverse video + a space of padding
- *  each side, so the name reads as a label sitting on the border rule. Used as
- *  the fallback when no thinking color applies. */
-export const defaultTitleStyle = (s) => `\x1b[7m ${s} \x1b[27m`;
-/** Resolve the editor border colorizer for a thinking level. Unknown / `off` →
- *  the supplied `fallback` (the theme's default border color). */
-export function thinkingBorderColor(level, fallback) {
-    const rgb = level === undefined ? undefined : THINKING_RGB[level];
-    if (rgb === undefined)
-        return fallback;
-    const [r, g, b] = rgb;
-    return (s) => `\x1b[38;2;${r};${g};${b}m${s}\x1b[39m`;
-}
-/** Resolve the title-chip styler for a thinking level: the level's color as the
- *  chip BACKGROUND with bold white text (a space of padding each side), so the
- *  session name reads as a solid label in the same hue as the border. Unknown /
- *  `off` → the supplied `fallback` (the reverse-video default chip). */
-export function thinkingTitleStyle(level, fallback) {
-    const rgb = level === undefined ? undefined : THINKING_RGB[level];
-    if (rgb === undefined)
-        return fallback;
-    const [r, g, b] = rgb;
-    return (s) => `\x1b[48;2;${r};${g};${b}m\x1b[97m\x1b[1m ${s} \x1b[0m`;
-}
-/** Compose the replacement top-border line: solid title chip + border rule +
- *  info chip, never wider than `width` (pi-tui hard-crashes on an over-wide
- *  line). The info chip yields entirely when the chip leaves it almost no room,
- *  and truncates when it only partially fits. Exported pure for the overflow
- *  regression test. */
-export function composeTopBorder(width, title, info, titleStyle, borderColor) {
-    const chip = title ? titleStyle(truncateToWidth(title, Math.max(1, width - 4), '…')) : '';
-    const chipW = visibleWidth(chip);
-    const avail = width - chipW;
-    let infoChip = '';
-    if (info && avail > 4) {
-        infoChip = visibleWidth(info) <= avail ? info : truncateToWidth(info, avail, '…');
-    }
-    const fill = Math.max(0, width - chipW - visibleWidth(infoChip));
-    return chip + borderColor('─'.repeat(fill)) + infoChip;
-}
-/** The stock pi-tui editor paints its fake cursor as a solid reverse-video
- *  block (`\x1b[7m…\x1b[0m`) unconditionally — in a wall of attach panes every
- *  pane shows an identical solid white cursor, and nothing tells you which one
- *  keys actually go to. When the hosting pane/terminal is UNFOCUSED we rewrite
- *  that cell into a MUTED cursor, mirroring how real terminals de-emphasize
- *  the hardware cursor on blur. A pixel-true full-cell outline isn't possible
- *  in text cells, and hollow-box glyphs (▯/⍘/□) render undersized, so the
- *  muted form is a full-size block in a dim gray background — same footprint
- *  as the focused cursor, clearly not the bright active one (ruling: tried the
- *  glyphs, Silas preferred the dim block). The rewrite anchors on pi-tui's
- *  zero-width CURSOR_MARKER (emitted right before the fake cursor while the
- *  editor component has TUI focus) so it can never touch reverse video
- *  elsewhere in the line. Returns undefined when the line carries no cursor.
- *  Exported pure for tests. */
-const SOLID_CURSOR_PREFIX = '\x1b[7m';
-const SOLID_CURSOR_RESET = '\x1b[0m';
-/** Dim gray bg, default fg — the char under the cursor stays readable. */
-const MUTED_CURSOR_ON = '\x1b[48;5;240m';
-export function outlineCursorLine(line) {
-    const m = line.indexOf(CURSOR_MARKER);
-    if (m === -1)
-        return undefined;
-    const start = m + CURSOR_MARKER.length;
-    if (!line.startsWith(SOLID_CURSOR_PREFIX, start))
-        return undefined;
-    const gStart = start + SOLID_CURSOR_PREFIX.length;
-    const end = line.indexOf(SOLID_CURSOR_RESET, gStart);
-    if (end === -1)
-        return undefined;
-    const grapheme = line.slice(gStart, end);
-    const replacement = `${MUTED_CURSOR_ON}${grapheme}\x1b[0m`;
-    return line.slice(0, start) + replacement + line.slice(end + SOLID_CURSOR_RESET.length);
-}
-/** Image file extensions a dragged path is recognized by. */
-const IMAGE_PATH_RE = /\.(png|jpe?g|gif|webp|bmp)$/i;
-/** Recognize a single input chunk as a filesystem path to an image file — how a
- *  terminal delivers a file DRAGGED into the pane (the escaped path pasted in
- *  bulk, optionally wrapped in bracketed-paste markers). Returns the resolved
- *  path, or null when the chunk isn't a lone image path (normal typing, multi-
- *  line text, a non-image path, or a path that doesn't point at a real file).
- *  Conservative on purpose: it must never transform ordinary typed input. */
-export function detectDroppedImagePath(data) {
-    // Unwrap bracketed paste (\x1b[200~ … \x1b[201~) when the terminal uses it.
-    const bracketed = data.match(/\x1b\[200~([\s\S]*?)\x1b\[201~/);
-    let payload = (bracketed ? bracketed[1] : data).trim();
-    if (payload.length < 2)
-        return null; // a lone keystroke is never a drop
-    if (/[\u0000-\u0008\u000e-\u001f]/.test(payload))
-        return null; // control chars → not a path
-    // Terminals wrap a dropped path in quotes or backslash-escape its spaces.
-    if ((payload.startsWith("'") && payload.endsWith("'")) ||
-        (payload.startsWith('"') && payload.endsWith('"'))) {
-        payload = payload.slice(1, -1);
-    }
-    const path = payload.replace(/\\(.)/g, '$1');
-    if (/\n/.test(path) || !IMAGE_PATH_RE.test(path))
-        return null;
-    try {
-        if (!statSync(path).isFile())
-            return null;
-    }
-    catch {
-        return null; // not a real file → treat as ordinary pasted text
-    }
-    return path;
-}
-/** Recompute the exact layout pi-tui's `Editor.render` will produce for
- *  `lines` at `layoutWidth`, faithfully porting the private `layoutText`
- *  algorithm (empty-editor special case; per-line whole-fit vs `wordWrapLine`
- *  branch; cursor-in-chunk assignment for wrapped lines). `wordWrapLine` here
- *  is called WITHOUT the base editor's private paste-marker-aware
- *  presegmentation, so a wrapped line containing a paste marker can
- *  theoretically diverge from the real render's chunk boundaries — harmless,
- *  because `decorateRow`'s verify-before-splice check means any divergence
- *  simply drops that row's decoration rather than corrupting it. */
-export function buildRefLayoutChunks(lines, layoutWidth, cursorLine, cursorCol) {
-    const chunks = [];
-    if (lines.length === 0 || (lines.length === 1 && lines[0] === '')) {
-        chunks.push({ logicalLine: 0, startIndex: 0, endIndex: 0, text: '', hasCursor: true, cursorPos: 0 });
-        return chunks;
-    }
-    for (let i = 0; i < lines.length; i++) {
-        const line = lines[i] ?? '';
-        const isCurrentLine = i === cursorLine;
-        if (visibleWidth(line) <= layoutWidth) {
-            chunks.push({
-                logicalLine: i,
-                startIndex: 0,
-                endIndex: line.length,
-                text: line,
-                hasCursor: isCurrentLine,
-                cursorPos: isCurrentLine ? cursorCol : 0,
-            });
-            continue;
-        }
-        const wrapped = wordWrapLine(line, layoutWidth);
-        for (let chunkIndex = 0; chunkIndex < wrapped.length; chunkIndex++) {
-            const chunk = wrapped[chunkIndex];
-            if (!chunk)
-                continue;
-            const isLastChunk = chunkIndex === wrapped.length - 1;
-            let hasCursorInChunk = false;
-            let adjustedCursorPos = 0;
-            if (isCurrentLine) {
-                if (isLastChunk) {
-                    hasCursorInChunk = cursorCol >= chunk.startIndex;
-                    adjustedCursorPos = cursorCol - chunk.startIndex;
-                }
-                else {
-                    hasCursorInChunk = cursorCol >= chunk.startIndex && cursorCol < chunk.endIndex;
-                    if (hasCursorInChunk) {
-                        adjustedCursorPos = cursorCol - chunk.startIndex;
-                        if (adjustedCursorPos > chunk.text.length)
-                            adjustedCursorPos = chunk.text.length;
-                    }
-                }
-            }
-            chunks.push({
-                logicalLine: i,
-                startIndex: chunk.startIndex,
-                endIndex: chunk.endIndex,
-                text: chunk.text,
-                hasCursor: hasCursorInChunk,
-                cursorPos: adjustedCursorPos,
-            });
-        }
-    }
-    return chunks;
-}
-/** Resolved-ref candidate spans in one logical line: exact, case-sensitive
- *  membership in `names` (the broker-supplied inventory of visible canonical
- *  names) — never a fuzzy or prefix match. */
-function resolvedSpansForLine(line, names) {
-    return findRefTokens(line)
-        .filter((t) => names.has(t.candidate))
-        .map((t) => ({ start: t.start, end: t.end }));
-}
-/** Zero-width SGR for a resolved ref: underline + dim on, and ONLY those two
- *  attributes off again — never a blanket `\x1b[0m` reset, which would erase
- *  the cursor's own reverse-video/mute styling if a span ever abuts it. */
-const REF_STYLE_ON = '\x1b[4m\x1b[2m';
-const REF_STYLE_OFF = '\x1b[24m\x1b[22m';
-const refGraphemeSegmenter = new Intl.Segmenter(undefined, { granularity: 'grapheme' });
-/** Best-effort length (in UTF-16 code units) of the first grapheme of `text`.
- *  Not paste-marker aware (unlike the base editor's own segmenter) — doesn't
- *  need to be: any mismatch is caught by `decorateRow`'s verify-before-splice
- *  check, which only ever causes a span to be left undecorated. */
-function firstGraphemeLength(text) {
-    for (const seg of refGraphemeSegmenter.segment(text))
-        return seg.segment.length;
-    return 0;
-}
-/** Locate the cursor's own reverse-video cell within a single rendered content
- *  row, so ref decoration can be positioned around it without ever touching
- *  its bytes. Handles both the focused form (`SOLID_CURSOR_PREFIX`) and the
- *  blurred, muted form `outlineCursorLine` rewrites it to (`MUTED_CURSOR_ON`)
- *  — decoration always runs AFTER that rewrite, so both must be recognized.
- *  Returns null when no cursor cell can be found (e.g. the row isn't the
- *  cursor's row after all, or the base editor changed its cursor markup). */
-function locateCursorCell(row) {
-    const markerIdx = row.indexOf(CURSOR_MARKER);
-    const searchFrom = markerIdx === -1 ? 0 : markerIdx + CURSOR_MARKER.length;
-    let prefixIdx = row.indexOf(SOLID_CURSOR_PREFIX, searchFrom);
-    let prefixLen = SOLID_CURSOR_PREFIX.length;
-    if (prefixIdx === -1) {
-        prefixIdx = row.indexOf(MUTED_CURSOR_ON, searchFrom);
-        prefixLen = MUTED_CURSOR_ON.length;
-    }
-    if (prefixIdx === -1)
-        return null;
-    const resetIdx = row.indexOf(SOLID_CURSOR_RESET, prefixIdx + prefixLen);
-    if (resetIdx === -1)
-        return null;
-    return { start: markerIdx !== -1 ? markerIdx : prefixIdx, end: resetIdx + SOLID_CURSOR_RESET.length };
-}
-/** Splice underline/dim styling around every resolved-ref span that survives
- *  chrome-safety verification. `rowStr` is one already-rendered content row
- *  (plain, or carrying exactly the cursor's own cell markup); `chunk` is the
- *  layout entry it was built from; `spans` are candidate resolved-ref spans
- *  already filtered to lie within `chunk`'s logical range; `line` is the full
- *  logical line text (used only to verify a span's characters still match at
- *  the row offset we computed — never spliced in directly). Exported pure for
- *  direct testing. */
-export function decorateRow(rowStr, chunk, spans, line, paddingX) {
-    const insertions = [];
-    if (!chunk.hasCursor) {
-        for (const span of spans) {
-            const absStart = paddingX + (span.start - chunk.startIndex);
-            const absEnd = paddingX + (span.end - chunk.startIndex);
-            if (rowStr.slice(absStart, absEnd) === line.slice(span.start, span.end)) {
-                insertions.push({ absStart, absEnd });
-            }
-        }
-    }
-    else {
-        const cell = locateCursorCell(rowStr);
-        if (cell === null)
-            return rowStr; // can't safely locate the cursor -> decorate nothing on this row
-        const afterChunkText = chunk.text.slice(chunk.cursorPos);
-        const graphemeLen = afterChunkText.length === 0 ? 0 : firstGraphemeLength(afterChunkText);
-        const consumedEnd = chunk.cursorPos + graphemeLen;
-        for (const span of spans) {
-            const localStart = span.start - chunk.startIndex;
-            const localEnd = span.end - chunk.startIndex;
-            if (localEnd <= chunk.cursorPos) {
-                const absStart = paddingX + localStart;
-                const absEnd = paddingX + localEnd;
-                if (absEnd <= cell.start && rowStr.slice(absStart, absEnd) === line.slice(span.start, span.end)) {
-                    insertions.push({ absStart, absEnd });
-                }
-            }
-            else if (localStart >= consumedEnd) {
-                const absStart = cell.end + (localStart - consumedEnd);
-                const absEnd = cell.end + (localEnd - consumedEnd);
-                if (absStart >= cell.end && rowStr.slice(absStart, absEnd) === line.slice(span.start, span.end)) {
-                    insertions.push({ absStart, absEnd });
-                }
-            }
-            // else: span overlaps the cursor cell itself -> leave plain (design-sanctioned degrade)
-        }
-    }
-    if (insertions.length === 0)
-        return rowStr;
-    insertions.sort((a, b) => b.absStart - a.absStart); // rightmost first so earlier offsets stay valid
-    let out = rowStr;
-    for (const ins of insertions) {
-        out = out.slice(0, ins.absStart) + REF_STYLE_ON + out.slice(ins.absStart, ins.absEnd) + REF_STYLE_OFF + out.slice(ins.absEnd);
-    }
-    return out;
-}
-/** Mirrors `dispatchSlashCommand`'s (`slash/dispatch.ts`) own leading-name
- *  parse EXACTLY — not a looser grammar-based extraction, since dispatch's
- *  name charset (`\S+`) differs from the ref grammar's (`[A-Za-z0-9_:-]`) and
- *  a grammar-based extraction would under-suppress for a command name
- *  containing e.g. `.`. Duplicated intentionally: input/titled-editor.ts owns only
- *  render/input, and this two-line regex is the whole surface of that
- *  contract. */
-function extractLeadingCommandName(text) {
-    const m = /^\/(\S+)\s*([\s\S]*)$/.exec(text.trim());
-    return m ? m[1] : null;
-}
-/** Mirrors the broker's `isLeadingEngineCommand` (`core/runtime/broker.ts`)
- *  leading-token rule EXACTLY for classification purposes:
- *  the RAW, un-trimmed `text` must itself start with `/` — no `.trim()` — for
- *  ANY token to be a candidate, matching the broker's own untrimmed
- *  `text.startsWith('/')` checks byte-for-byte (space-based name split,
- *  `/skill:` 7-character prefix). `engineNames` is the broker's own
- *  `engineLeadingCommandNames` enumeration (`ListMemoryRefsData`, populated
- *  per `list_memory_refs` reply) — exact extension-command invocation names
- *  and prompt-template names bare, skills as `skill:<name>`, exactly what
- *  `engineLeadingCommandTokens` emits. This is viewer-side, best-effort
- *  classification for render suppression ONLY (see `decorateResolvedRefs`)
- *  — the broker remains the sole authority at actual submission time
- *  regardless of any viewer-side mismatch. */
-function matchesEngineLeadingCommand(text, engineNames) {
-    if (!text.startsWith('/'))
-        return false;
-    const spaceIndex = text.indexOf(' ');
-    const commandName = spaceIndex === -1 ? text.slice(1) : text.slice(1, spaceIndex);
-    if (engineNames.has(commandName))
-        return true;
-    if (text.startsWith('/skill:')) {
-        const skillName = spaceIndex === -1 ? text.slice(7) : text.slice(7, spaceIndex);
-        if (engineNames.has(`skill:${skillName}`))
-            return true;
-    }
-    return false;
-}
-export class TitledEditor extends CustomEditor {
-    /** crtr's OWN keybindings manager — the same one CustomEditor matches `app.*`
-     *  against. We keep a reference so `handleInput` can resolve the newline chord
-     *  here, independent of the editor's (possibly separate) pi-tui module global. */
-    km;
-    /** The raw (untrimmed) text `submitValue()` is ABOUT to trim away, captured by
-     *  the `submitValue` monkeypatch just below it runs, and consumed exactly once
-     *  by the `onSubmit` accessor wrapper. See the constructor for why. */
-    pendingRawSubmitText;
-    /** The REAL caller-supplied `onSubmit` handler (what `InputController` wires
-     *  via `this.editor.onSubmit = ...`) — stored here because `onSubmit` itself is
-     *  converted to an accessor below whose getter always returns our substitution
-     *  wrapper, not this value directly. */
-    realOnSubmit;
-    /** A line ending held back to learn whether more input follows it within
-     *  `PASTE_BURST_MS` — see `handleInput`'s unbracketed-paste rescue. More input
-     *  means it was a line break inside a paste (insert a newline); silence means
-     *  a human pressed Enter (submit). */
-    pendingReturn;
-    /** How long a line ending is held before it counts as a real Enter. An
-     *  unbracketed paste floods `handleInput` within one event-loop tick, so its
-     *  next character always lands far inside this window; a human's next
-     *  keystroke after Enter is ~30ms+ away at the very fastest. Short enough that
-     *  the added submit latency is imperceptible. */
-    static PASTE_BURST_MS = 10;
-    // CustomEditor's ctor signature; captured so we own the newline chord (see
-    // handleInput). The keybindings param is typed as pi's app-subclass manager,
-    // but the attach viewer feeds it pi-tui's base manager — hence the cast.
-    constructor(tui, theme, keybindings, options) {
-        super(tui, theme, keybindings, options);
-        this.km = keybindings;
-        // Preserve raw (untrimmed) submit text end-to-end. The base
-        // `Editor.submitValue()` — private in the `.d.ts` (blocking a normal TS
-        // `override`), hence the structural cast, same pattern as the other private-
-        // internals casts throughout this file (`scrollOffset`, `historyIndex`,
-        // `tryTriggerAutocomplete`) — computes `expandPasteMarkers(lines.join('\n'))`,
-        // `.trim()`s it, THEN calls `this.onSubmit(trimmed)`: the trimmed text is all
-        // any caller-supplied `onSubmit` handler ever sees today. `getExpandedText()`
-        // IS public and its implementation is byte-for-byte the same pre-`.trim()`
-        // computation, so calling it here — immediately before delegating to the real
-        // `submitValue` — captures the exact untrimmed text about to be lost, and
-        // must happen INSIDE this wrapper (not earlier in `handleInput`): a Tab/
-        // Enter-confirm command completion can mutate `state.lines` in the SAME
-        // `handleInput` call, in statements that run before `submitValue()` fires
-        // (pi-tui's `tui.select.confirm` leading-command fallthrough), so anything
-        // captured earlier could be stale pre-completion text.
-        const inheritedSubmitValue = this.submitValue.bind(this);
-        this.submitValue = () => {
-            const withExpanded = this;
-            this.pendingRawSubmitText = withExpanded.getExpandedText();
-            inheritedSubmitValue();
-        };
-        // `onSubmit` is a plain PUBLIC optional class field on the base `Editor`
-        // (`onSubmit?: (text: string) => void;`) — an own, configurable instance
-        // property installed during base field initialization, before this
-        // constructor body runs — so converting it to an accessor here is safe.
-        // `InputController` does `this.editor.onSubmit = (text) => ...`, which now
-        // goes through the setter below (stored as `realOnSubmit`); the value the
-        // base class actually reads and calls from inside `submitValue()` is ALWAYS
-        // this wrapper closure, which substitutes the captured raw text for
-        // whatever (trimmed) argument pi-tui passes.
-        Object.defineProperty(this, 'onSubmit', {
-            configurable: true,
-            get: () => {
-                return (text) => {
-                    const raw = this.pendingRawSubmitText ?? text;
-                    this.pendingRawSubmitText = undefined;
-                    this.realOnSubmit?.(raw);
-                };
-            },
-            set: (handler) => {
-                this.realOnSubmit = handler;
-            },
-        });
-    }
-    /** Insert a newline on the newLine chord (Alt+Enter / Shift+Enter) using crtr's
-     *  OWN keybindings manager, then defer everything else to the stock editor.
-     *
-     *  The base `Editor` resolves newLine against `getKeybindings()` on ITS pi-tui
-     *  instance, which in a non-deduped install is a DIFFERENT module than the one
-     *  carrying crtr's `alt+enter` override — so the override can silently never
-     *  reach it and Alt+Enter falls through to submit. crtr's `km` (the
-     *  same manager CustomEditor matches `app.*` against) always carries the
-     *  override, so matching the chord here makes the newline behavior independent
-     *  of cross-instance keybinding mirroring. Skipped while the autocomplete popup
-     *  is open so Enter-to-confirm keeps working. */
-    /** Set by the input controller: called when a bulk input chunk is recognized
-     *  as a filesystem path to an image file (a file DRAGGED into the pane, which
-     *  the terminal delivers as bracketed-paste TEXT, not an image event). Returns
-     *  true when it consumed the drop, so the raw path is never inserted as text. */
-    onPasteImagePath;
-    /** Settle a line ending held by the unbracketed-paste rescue. `'newline'` (more
-     *  input arrived, so it was a paste's own line break) inserts it in place;
-     *  `'submit'` (the hold window expired in silence, so a human pressed Enter)
-     *  replays it through the stock editor and repaints, because this runs outside
-     *  the TUI's own post-`handleInput` render request. No-op when nothing is
-     *  held. */
-    settleHeldReturn(as) {
-        const held = this.pendingReturn;
-        if (held === undefined)
-            return;
-        clearTimeout(held.timer);
-        this.pendingReturn = undefined;
-        if (as === 'newline') {
-            this.insertTextAtCursor('\n');
-            return;
-        }
-        super.handleInput(held.data);
-        this.tui.requestRender();
-    }
-    /** Width of an `[Image #N]` token sitting immediately before the cursor on the
-     *  current line, or 0 when the cursor isn't at the end of such a token — used to
-     *  delete/skip the token atomically. The token's separating space is a normal,
-     *  reachable character, deliberately NOT part of the atom. */
-    imageTokenWidthBeforeCursor() {
-        const { line, col } = this.getCursor();
-        const text = this.getLines()[line];
-        if (text === undefined)
-            return 0;
-        const match = text.slice(0, col).match(/\[Image #\d+\]$/);
-        return match ? match[0].length : 0;
-    }
-    /** Width of an `[Image #N]` token sitting immediately after the cursor on the
-     *  current line, or 0 when the cursor isn't at the start of such a token — used
-     *  to skip the token with the right arrow. */
-    imageTokenWidthAfterCursor() {
-        const { line, col } = this.getCursor();
-        const text = this.getLines()[line];
-        if (text === undefined)
-            return 0;
-        const match = text.slice(col).match(/^\[Image #\d+\]/);
-        return match ? match[0].length : 0;
-    }
-    handleInput(data) {
-        // Any input arriving while a line ending is held settles it as a paste's own
-        // line break: insert it FIRST so this key lands after it, in typed order.
-        this.settleHeldReturn('newline');
-        // Keep ↓ on the editor's native focused-input path. Only when its own
-        // wrap-aware cursor and prompt-history navigation make no change does the
-        // adjacent roster get a chance to take over.
-        if (!this.isShowingAutocomplete() && this.km.matches(data, 'tui.editor.cursorDown')) {
-            const internals = this;
-            const beforeCursor = this.getCursor();
-            const beforeHistory = internals.historyIndex;
-            super.handleInput(data);
-            const afterCursor = this.getCursor();
-            if (internals.historyIndex === beforeHistory
-                && afterCursor.line === beforeCursor.line
-                && afterCursor.col === beforeCursor.col) {
-                this.onCursorDownAtBottom?.();
-            }
-            return;
-        }
-        if (!this.isShowingAutocomplete() && this.km.matches(data, 'tui.input.newLine')) {
-            this.insertTextAtCursor('\n');
-            return;
-        }
-        // Backspace over an `[Image #N]` token deletes the WHOLE token (and its
-        // trailing space) in one keypress, not one character at a time — the token is
-        // a single atom to the user. We replay the backspace across the token's full
-        // width so the base editor's cursor/undo bookkeeping stays correct.
-        if (!this.isShowingAutocomplete() && this.km.matches(data, 'tui.editor.deleteCharBackward')) {
-            const width = this.imageTokenWidthBeforeCursor();
-            if (width > 1) {
-                for (let i = 0; i < width; i++)
-                    super.handleInput(data);
-                return;
-            }
-        }
-        // Left/right arrow steps OVER an `[Image #N]` token in one keypress — the
-        // token reads as a single character, so the caret never lands inside it. We
-        // replay the arrow across the token's full width so cursor bookkeeping stays
-        // correct.
-        if (!this.isShowingAutocomplete() && this.km.matches(data, 'tui.editor.cursorLeft')) {
-            const width = this.imageTokenWidthBeforeCursor();
-            if (width > 1) {
-                for (let i = 0; i < width; i++)
-                    super.handleInput(data);
-                return;
-            }
-        }
-        if (!this.isShowingAutocomplete() && this.km.matches(data, 'tui.editor.cursorRight')) {
-            const width = this.imageTokenWidthAfterCursor();
-            if (width > 1) {
-                for (let i = 0; i < width; i++)
-                    super.handleInput(data);
-                return;
-            }
-        }
-        // A file dragged into the pane arrives as a bulk paste of its (shell-escaped)
-        // path, NOT as an image on the clipboard, so onPasteImage never fires. Detect
-        // an image-file path here and hand it to the controller so it becomes an
-        // `[Image #N]` token like a clipboard paste, instead of the raw temp path.
-        const droppedPath = detectDroppedImagePath(data);
-        if (droppedPath && this.onPasteImagePath?.(droppedPath))
-            return;
-        // Unbracketed multi-line paste rescue. When the terminal delivers a paste
-        // WITHOUT bracketed-paste markers (\x1b[200~ … \x1b[201~) — the outer
-        // terminal may not support them, or tmux attached its client with a terminfo
-        // entry lacking the Enbp/Dsbp caps — pi-tui's StdinBuffer never enters paste
-        // mode and instead splits the paste into single sequences. Each embedded
-        // line ending then reaches us as a bare Enter, and the stock editor SUBMITS
-        // on it: line one becomes a prompt and every following line becomes its own
-        // turn, is queued as steering, or is lost to pi's "Agent is already
-        // processing" rejection when it lands inside prompt()'s async preflight. The
-        // bracketed path (when markers DO arrive) is a single `\x1b[200~…` sequence
-        // that never trips this branch, so it stays fully intact.
-        //
-        // A pasted line break is told from a pressed Enter by what FOLLOWS it, not
-        // by what precedes it: a paste floods handleInput with its next character
-        // microseconds later, while an Enter is followed by human-scale silence.
-        // Deciding on the following input (rather than the preceding gap) is what
-        // keeps `tmux send-keys <text> Enter` — one write, so its Enter arrives
-        // microseconds after the text — submitting as intended, since nothing
-        // follows it. A paste that ends in a trailing newline likewise submits, by
-        // then carrying its WHOLE text, so no line is ever split off or lost.
-        // Skipped while the autocomplete popup is open, where Enter confirms a
-        // completion and must stay immediate.
-        if ((data === '\r' || data === '\n') && !this.isShowingAutocomplete()) {
-            this.pendingReturn = {
-                data,
-                timer: setTimeout(() => this.settleHeldReturn('submit'), TitledEditor.PASTE_BURST_MS),
-            };
-            return;
-        }
-        const { line: beforeLine, col: beforeCol } = this.getCursor();
-        const beforeText = this.getLines()[beforeLine] ?? '';
-        super.handleInput(data);
-        this.maybeTriggerNonLeadingRefAutocomplete(beforeLine, beforeCol, beforeText);
-    }
-    /** The base editor auto-triggers autocomplete for a LEADING slash context
-     *  (`isInSlashCommandContext`, `insertCharacter`) whenever the text before
-     *  the cursor — from the very start of the line — begins with `/`. A
-     *  non-leading ref elsewhere in ordinary text (`hey check /dev`) never
-     *  satisfies that check, so it would otherwise require an explicit Tab.
-     *  This bridges exactly that gap: after an ordinary single-character
-     *  insertion, if the caret now sits in a non-leading ref token
-     *  (`findRefCompletionContext` — T1's shared caret classifier, not
-     *  reimplemented here), nudge the same private trigger the base editor uses
-     *  for its own leading case. Detected purely by before/after cursor and
-     *  text-length diffing, so it's mechanism-agnostic (typed key or decoded
-     *  printable key alike) and naturally excludes multi-character paste
-     *  (`handlePaste` already suppresses autocomplete itself, and the exact +1
-     *  length-delta check here would reject it anyway). Leading context is
-     *  deliberately left untouched — triggering it again here would double the
-     *  base editor's own native trigger for that case. */
-    maybeTriggerNonLeadingRefAutocomplete(beforeLine, beforeCol, beforeText) {
-        if (this.isShowingAutocomplete())
-            return;
-        const cursor = this.getCursor();
-        if (cursor.line !== beforeLine || cursor.col !== beforeCol + 1)
-            return;
-        const afterText = this.getLines()[cursor.line] ?? '';
-        if (afterText.length !== beforeText.length + 1)
-            return;
-        const inserted = afterText[beforeCol];
-        if (inserted === undefined || (inserted !== '/' && !/[A-Za-z0-9_:-]/.test(inserted)))
-            return;
-        const context = findRefCompletionContext(this.getLines(), cursor.line, cursor.col);
-        if (!context || context.kind !== 'ref')
-            return;
-        this.tryTriggerAutocomplete();
-    }
-    /** Called after native ↓ navigation proves the editor and prompt history are
-     * both exhausted. Attach uses this boundary handoff to enter its node roster. */
-    onCursorDownAtBottom;
-    /** Fully-expanded prompt template currently loaded by the editor's leading
-     * slash token. It renders inside the editor outline before submission, so the
-     * user can inspect the exact payload while arguments are still editable. */
-    loadedCommand;
-    /** Session-name chip painted into the LEFT of the top border. Empty → plain. */
-    title = '';
-    /** Pre-styled context string painted into the RIGHT of the top border (cwd /
-     *  branch / git status). Already colorized by the caller; empty → omitted. */
-    info = '';
-    /** Node and workspace badge painted at the far bottom-right of the outline. */
-    contextBadge = '';
-    /** Paint the chip solid so the name reads as a label sitting on the border
-     *  rule. Defaults to the reverse-video chip; viewer.ts swaps in a
-     *  thinking-colored background (bold white text) on each state update. */
-    titleStyle = defaultTitleStyle;
-    /** Node and workspace badge colorizer, matched to the editor frame. */
-    contextBadgeStyle = defaultTitleStyle;
-    /** Whether the hosting tmux pane / terminal window has FOCUS (terminal focus
-     *  reporting, DECSET 1004 — viewer.ts flips this on `\x1b[I` / `\x1b[O`).
-     *  Distinct from TUI component focus: the editor keeps component focus while
-     *  its pane is blurred. False → the fake cursor renders as an outline. */
-    paneFocused = true;
-    /** Canonical names the broker currently resolves — the exact-membership set
-     *  a candidate ref token must be in to render as a resolved highlight.
-     *  Empty by default (no decoration) until the caller supplies the
-     *  broker-supplied inventory. */
-    resolvedRefNames = new Set();
-    /** Command names the VIEWER dispatches ENTIRELY locally (never reach the
-     *  engine as prose) — checked against the TRIMMED leading-name rule
-     *  (`extractLeadingCommandName`, which mirrors `slash/dispatch.ts`'s own
-     *  `text.trim()`-based dispatch parse). Exactly
-     *  `locallyConsumedCommandNames()` from `slash/dispatch.ts` — independent
-     *  of `remote` and of the broker's `get_commands` reply (see that
-     *  function's doc comment). Deliberately NEVER the merged display/
-     *  completion list (`slashCommandList` is a different, remote-filtered,
-     *  broker-augmented list, not a dispatch predicate). */
-    localCommandNames = new Set();
-    /** Leading tokens the ENGINE (broker) independently consumes as a leading
-     *  command/skill/template dispatch — the broker's own
-     *  `engineLeadingCommandNames`, checked against the UNTRIMMED leading-name
-     *  rule (`matchesEngineLeadingCommand`, mirroring the broker's own
-     *  `isLeadingEngineCommand`). Populated from each
-     *  `list_memory_refs` reply, alongside `resolvedRefNames`. */
-    engineCommandNames = new Set();
-    setResolvedRefNames(names) {
-        this.resolvedRefNames = new Set(names);
-    }
-    /** The canonical names of memory refs currently resolvable in this session —
-     *  used to record ref usage on submit without counting non-ref slash tokens. */
-    getResolvedRefNames() {
-        return this.resolvedRefNames;
-    }
-    setLocalCommandNames(names) {
-        this.localCommandNames = new Set(names);
-    }
-    setEngineCommandNames(names) {
-        this.engineCommandNames = new Set(names);
-    }
-    /** Render-only decoration pass: underlines every resolved-ref span visible
-     *  in the already-rendered content rows, using a from-scratch layout
-     *  recompute (`buildRefLayoutChunks`) that mirrors the base editor's own
-     *  private `layoutText`/`scrollOffset`/`maxVisibleLines` math so row/column
-     *  offsets line up. Never mutates stored text; a span whose recomputed
-     *  offset doesn't verify against the real rendered row (see `decorateRow`)
-     *  is simply left undecorated. Suppressed entirely (command-wide) whenever
-     *  the composer's own leading token dispatches — as a LOCAL viewer command
-     *  (`localCommandNames`, TRIMMED rule) or as an ENGINE-consumed leading
-     *  command/skill/template (`engineCommandNames`, UNTRIMMED rule) — the ref
-     *  grammar and slash-dispatch's name charset differ, so
-     *  highlighting a ref inside a command that's about to dispatch would be
-     *  misleading chrome for text the command, not memory resolution, is about
-     *  to consume. The two rules are kept deliberately SEPARATE rather than
-     *  collapsed into one set/predicate: they classify against
-     *  different text (trimmed vs. raw) and different authorities (this
-     *  viewer's own dispatch vs. the broker's). */
-    decorateResolvedRefs(lines, width) {
-        if (this.resolvedRefNames.size === 0)
-            return;
-        const text = this.getText();
-        const trimmedLeadingName = extractLeadingCommandName(text);
-        if (trimmedLeadingName !== null && this.localCommandNames.has(trimmedLeadingName))
-            return;
-        if (matchesEngineLeadingCommand(text, this.engineCommandNames))
-            return;
-        const maxPadding = Math.max(0, Math.floor((width - 1) / 2));
-        const paddingX = Math.min(this.getPaddingX(), maxPadding);
-        const contentWidth = Math.max(1, width - paddingX * 2);
-        const layoutWidth = Math.max(1, contentWidth - (paddingX ? 0 : 1));
-        const logicalLines = this.getLines();
-        const cursor = this.getCursor();
-        const chunks = buildRefLayoutChunks(logicalLines, layoutWidth, cursor.line, cursor.col);
-        // Private on the base `Editor`; render() above has already called
-        // `super.render(width)`, so this reflects the scrollOffset THIS render
-        // settled on — the same structural-cast pattern used elsewhere in this
-        // file (e.g. the `historyIndex` cast in titled-editor-preview.test.ts).
-        const scrollOffset = this.scrollOffset;
-        const maxVisibleLines = Math.max(5, Math.floor(this.tui.terminal.rows * 0.3));
-        const visibleCount = Math.min(Math.max(0, chunks.length - scrollOffset), maxVisibleLines);
-        if (visibleCount <= 0 || lines.length < 1 + visibleCount)
-            return; // mismatch -> skip entirely
-        const spansByLine = new Map();
-        for (let r = 0; r < visibleCount; r++) {
-            const chunk = chunks[scrollOffset + r];
-            if (!chunk)
-                continue;
-            let spans = spansByLine.get(chunk.logicalLine);
-            if (spans === undefined) {
-                spans = resolvedSpansForLine(logicalLines[chunk.logicalLine] ?? '', this.resolvedRefNames);
-                spansByLine.set(chunk.logicalLine, spans);
-            }
-            const contained = spans.filter((s) => s.start >= chunk.startIndex && s.end <= chunk.endIndex);
-            if (contained.length === 0)
-                continue;
-            const rowStr = lines[1 + r];
-            if (rowStr === undefined)
-                continue;
-            lines[1 + r] = decorateRow(rowStr, chunk, contained, logicalLines[chunk.logicalLine] ?? '', paddingX);
-        }
-    }
-    render(width) {
-        const lines = super.render(width);
-        if (!this.paneFocused) {
-            for (let i = 0; i < lines.length; i++) {
-                const hollowed = outlineCursorLine(lines[i]);
-                if (hollowed !== undefined) {
-                    lines[i] = hollowed;
-                    break;
-                }
-            }
-        }
-        this.decorateResolvedRefs(lines, width);
-        if (this.loadedCommand !== undefined && lines.length >= 2 && width >= 8) {
-            const innerWidth = width - 4;
-            const body = compactLoadedCommandPreview(this.loadedCommand.content, innerWidth);
-            // At narrow widths the disclosure is suppressed rather than clipping away
-            // its inspect affordance. Put that affordance first when it does render.
-            if (body.length === 0)
-                return lines;
-            const label = ` ${this.loadedCommand.inspectHint} · /${this.loadedCommand.name} loaded `;
-            const framed = body.map((line) => {
-                const clipped = truncateToWidth(line, innerWidth);
-                return `${this.borderColor('│')} ${clipped}${' '.repeat(Math.max(0, innerWidth - visibleWidth(clipped)))} ${this.borderColor('│')}`;
-            });
-            const dividerText = truncateToWidth(label, width - 2);
-            const remaining = Math.max(0, width - 2 - visibleWidth(dividerText));
-            const divider = this.borderColor(`├${dividerText}${'─'.repeat(remaining)}┤`);
-            lines.splice(1, 0, divider, ...framed, this.borderColor(`├${'─'.repeat(width - 2)}┤`));
-        }
-        if ((this.title || this.info) && lines.length > 0) {
-            // Replace the stock top border; dashes in the current (thinking-aware)
-            // border color.
-            lines[0] = composeTopBorder(width, this.title, this.info, this.titleStyle, (s) => this.borderColor(s));
-        }
-        if (this.contextBadge && lines.length > 0) {
-            const badge = this.contextBadgeStyle(this.contextBadge);
-            const badgeWidth = visibleWidth(badge);
-            if (badgeWidth + 2 < width) {
-                const last = lines.length - 1;
-                lines[last] = truncateToWidth(lines[last], width - badgeWidth, '') + badge;
-            }
-        }
-        return lines;
-    }
-}
+var w=Object.defineProperty;var d=(s,e)=>w(s,"name",{value:e,configurable:!0});import{statSync as D}from"node:fs";import{CustomEditor as B}from"@earendil-works/pi-coding-agent";import{CURSOR_MARKER as E,truncateToWidth as C,visibleWidth as b,wrapTextWithAnsi as v}from"@earendil-works/pi-tui";import{wordWrapLine as H}from"@earendil-works/pi-tui/dist/components/editor.js";import{findRefTokens as F}from"../../../core/memory/inline-ref-grammar.js";import{findRefCompletionContext as G}from"./ref-autocomplete.js";const M=8,U=24,V=8192;function K(s,e){const t=s.slice(0,e),n=s.length>e;return{text:t.replace(/\x1b\](?:[^\x07\x1b]*)(?:\x07|\x1b\\)?/g,"").replace(/\x1b\[[0-?]*[ -/]*[@-~]/g,"").replace(/[\x00-\x09\x0b-\x1f\x7f-\x9f]/g,""),truncated:n}}d(K,"sanitizeLoadedCommandPreview");function j(s,e){if(e<U)return[];const t=Math.min(V,Math.max(256,e*M*4)),n=K(s,t),r=v(n.text,e);if(!n.truncated&&r.length<=M)return r;const c=r.slice(0,M-1);return c.push(C("\u2026 truncated \xB7 inspect for full prompt",e)),c}d(j,"compactLoadedCommandPreview");const S=[46,92,190],R=[166,98,24],z=[0,145,170];function L(s,e,t){return[Math.round(s[0]+(e[0]-s[0])*t),Math.round(s[1]+(e[1]-s[1])*t),Math.round(s[2]+(e[2]-s[2])*t)]}d(L,"interpolateRgb");const P={off:void 0,minimal:L(S,R,0/4),low:L(S,R,1/4),medium:L(S,R,2/4),high:L(S,R,3/4),xhigh:L(S,R,4/4),max:z},X={black:[0,0,0],red:[205,49,49],green:[13,188,121],yellow:[229,229,16],blue:[36,114,200],magenta:[188,63,188],cyan:[17,168,205],white:[229,229,229],orange:[228,152,68],grey:[128,128,128],gray:[128,128,128],brightred:[241,76,76],brightgreen:[35,209,139],brightyellow:[245,245,67],brightblue:[59,142,234],brightmagenta:[214,112,214],brightcyan:[41,184,219]};function xe(s){const e=s.trim().toLowerCase(),t=/^colour(\d{1,3})$/.exec(e);if(t!==null)return a=>`\x1B[48;5;${t[1]}m\x1B[97m\x1B[1m ${a} \x1B[0m`;let n;const r=/^#([0-9a-f]{6})$/.exec(e);if(r!==null){const a=r[1];n=[parseInt(a.slice(0,2),16),parseInt(a.slice(2,4),16),parseInt(a.slice(4,6),16)]}else n=X[e];if(n===void 0)return;const[c,i,o]=n,u=.299*c+.587*i+.114*o>160?"\x1B[30m":"\x1B[97m";return a=>`\x1B[48;2;${c};${i};${o}m${u}\x1B[1m ${a} \x1B[0m`}d(xe,"colorChipStyle");const k=d(s=>`\x1B[7m ${s} \x1B[27m`,"defaultTitleStyle");function pe(s,e){const t=s===void 0?void 0:P[s];if(t===void 0)return e;const[n,r,c]=t;return i=>`\x1B[38;2;${n};${r};${c}m${i}\x1B[39m`}d(pe,"thinkingBorderColor");function be(s,e){const t=s===void 0?void 0:P[s];if(t===void 0)return e;const[n,r,c]=t;return i=>`\x1B[48;2;${n};${r};${c}m\x1B[97m\x1B[1m ${i} \x1B[0m`}d(be,"thinkingTitleStyle");function Y(s,e,t,n,r){const c=e?n(C(e,Math.max(1,s-4),"\u2026")):"",i=b(c),o=s-i;let l="";t&&o>4&&(l=b(t)<=o?t:C(t,o,"\u2026"));const u=Math.max(0,s-i-b(l));return c+r("\u2500".repeat(u))+l}d(Y,"composeTopBorder");const N="\x1B[7m",A="\x1B[0m",_="\x1B[48;5;240m";function q(s){const e=s.indexOf(E);if(e===-1)return;const t=e+E.length;if(!s.startsWith(N,t))return;const n=t+N.length,r=s.indexOf(A,n);if(r===-1)return;const c=s.slice(n,r),i=`${_}${c}\x1B[0m`;return s.slice(0,t)+i+s.slice(r+A.length)}d(q,"outlineCursorLine");const Z=/\.(png|jpe?g|gif|webp|bmp)$/i;function J(s){const e=s.match(/\x1b\[200~([\s\S]*?)\x1b\[201~/);let t=(e?e[1]:s).trim();if(t.length<2||/[\u0000-\u0008\u000e-\u001f]/.test(t))return null;(t.startsWith("'")&&t.endsWith("'")||t.startsWith('"')&&t.endsWith('"'))&&(t=t.slice(1,-1));const n=t.replace(/\\(.)/g,"$1");if(/\n/.test(n)||!Z.test(n))return null;try{if(!D(n).isFile())return null}catch{return null}return n}d(J,"detectDroppedImagePath");function Q(s,e,t,n){const r=[];if(s.length===0||s.length===1&&s[0]==="")return r.push({logicalLine:0,startIndex:0,endIndex:0,text:"",hasCursor:!0,cursorPos:0}),r;for(let c=0;c<s.length;c++){const i=s[c]??"",o=c===t;if(b(i)<=e){r.push({logicalLine:c,startIndex:0,endIndex:i.length,text:i,hasCursor:o,cursorPos:o?n:0});continue}const l=H(i,e);for(let u=0;u<l.length;u++){const a=l[u];if(!a)continue;const h=u===l.length-1;let m=!1,f=0;o&&(h?(m=n>=a.startIndex,f=n-a.startIndex):(m=n>=a.startIndex&&n<a.endIndex,m&&(f=n-a.startIndex,f>a.text.length&&(f=a.text.length)))),r.push({logicalLine:c,startIndex:a.startIndex,endIndex:a.endIndex,text:a.text,hasCursor:m,cursorPos:f})}}return r}d(Q,"buildRefLayoutChunks");function ee(s,e){return F(s).filter(t=>e.has(t.candidate)).map(t=>({start:t.start,end:t.end}))}d(ee,"resolvedSpansForLine");const te="\x1B[4m\x1B[2m",ne="\x1B[24m\x1B[22m",se=new Intl.Segmenter(void 0,{granularity:"grapheme"});function re(s){for(const e of se.segment(s))return e.segment.length;return 0}d(re,"firstGraphemeLength");function ie(s){const e=s.indexOf(E),t=e===-1?0:e+E.length;let n=s.indexOf(N,t),r=N.length;if(n===-1&&(n=s.indexOf(_,t),r=_.length),n===-1)return null;const c=s.indexOf(A,n+r);return c===-1?null:{start:e!==-1?e:n,end:c+A.length}}d(ie,"locateCursorCell");function oe(s,e,t,n,r){const c=[];if(e.hasCursor){const o=ie(s);if(o===null)return s;const l=e.text.slice(e.cursorPos),u=l.length===0?0:re(l),a=e.cursorPos+u;for(const h of t){const m=h.start-e.startIndex,f=h.end-e.startIndex;if(f<=e.cursorPos){const g=r+m,x=r+f;x<=o.start&&s.slice(g,x)===n.slice(h.start,h.end)&&c.push({absStart:g,absEnd:x})}else if(m>=a){const g=o.end+(m-a),x=o.end+(f-a);g>=o.end&&s.slice(g,x)===n.slice(h.start,h.end)&&c.push({absStart:g,absEnd:x})}}}else for(const o of t){const l=r+(o.start-e.startIndex),u=r+(o.end-e.startIndex);s.slice(l,u)===n.slice(o.start,o.end)&&c.push({absStart:l,absEnd:u})}if(c.length===0)return s;c.sort((o,l)=>l.absStart-o.absStart);let i=s;for(const o of c)i=i.slice(0,o.absStart)+te+i.slice(o.absStart,o.absEnd)+ne+i.slice(o.absEnd);return i}d(oe,"decorateRow");function ce(s){const e=/^\/(\S+)\s*([\s\S]*)$/.exec(s.trim());return e?e[1]:null}d(ce,"extractLeadingCommandName");function ae(s,e){if(!s.startsWith("/"))return!1;const t=s.indexOf(" "),n=t===-1?s.slice(1):s.slice(1,t);if(e.has(n))return!0;if(s.startsWith("/skill:")){const r=t===-1?s.slice(7):s.slice(7,t);if(e.has(`skill:${r}`))return!0}return!1}d(ae,"matchesEngineLeadingCommand");class W extends B{static{d(this,"TitledEditor")}km;pendingRawSubmitText;realOnSubmit;pendingReturn;static PASTE_BURST_MS=10;constructor(e,t,n,r){super(e,t,n,r),this.km=n;const c=this.submitValue.bind(this);this.submitValue=()=>{const i=this;this.pendingRawSubmitText=i.getExpandedText(),c()},Object.defineProperty(this,"onSubmit",{configurable:!0,get:d(()=>i=>{const o=this.pendingRawSubmitText??i;this.pendingRawSubmitText=void 0,this.realOnSubmit?.(o)},"get"),set:d(i=>{this.realOnSubmit=i},"set")})}onPasteImagePath;settleHeldReturn(e){const t=this.pendingReturn;if(t!==void 0){if(clearTimeout(t.timer),this.pendingReturn=void 0,e==="newline"){this.insertTextAtCursor(`
+`);return}super.handleInput(t.data),this.tui.requestRender()}}imageTokenWidthBeforeCursor(){const{line:e,col:t}=this.getCursor(),n=this.getLines()[e];if(n===void 0)return 0;const r=n.slice(0,t).match(/\[Image #\d+\]$/);return r?r[0].length:0}imageTokenWidthAfterCursor(){const{line:e,col:t}=this.getCursor(),n=this.getLines()[e];if(n===void 0)return 0;const r=n.slice(t).match(/^\[Image #\d+\]/);return r?r[0].length:0}handleInput(e){if(this.settleHeldReturn("newline"),!this.isShowingAutocomplete()&&this.km.matches(e,"tui.editor.cursorDown")){const i=this,o=this.getCursor(),l=i.historyIndex;super.handleInput(e);const u=this.getCursor();i.historyIndex===l&&u.line===o.line&&u.col===o.col&&this.onCursorDownAtBottom?.();return}if(!this.isShowingAutocomplete()&&this.km.matches(e,"tui.input.newLine")){this.insertTextAtCursor(`
+`);return}if(!this.isShowingAutocomplete()&&this.km.matches(e,"tui.editor.deleteCharBackward")){const i=this.imageTokenWidthBeforeCursor();if(i>1){for(let o=0;o<i;o++)super.handleInput(e);return}}if(!this.isShowingAutocomplete()&&this.km.matches(e,"tui.editor.cursorLeft")){const i=this.imageTokenWidthBeforeCursor();if(i>1){for(let o=0;o<i;o++)super.handleInput(e);return}}if(!this.isShowingAutocomplete()&&this.km.matches(e,"tui.editor.cursorRight")){const i=this.imageTokenWidthAfterCursor();if(i>1){for(let o=0;o<i;o++)super.handleInput(e);return}}const t=J(e);if(t&&this.onPasteImagePath?.(t))return;if((e==="\r"||e===`
+`)&&!this.isShowingAutocomplete()){this.pendingReturn={data:e,timer:setTimeout(()=>this.settleHeldReturn("submit"),W.PASTE_BURST_MS)};return}const{line:n,col:r}=this.getCursor(),c=this.getLines()[n]??"";super.handleInput(e),this.maybeTriggerNonLeadingRefAutocomplete(n,r,c)}maybeTriggerNonLeadingRefAutocomplete(e,t,n){if(this.isShowingAutocomplete())return;const r=this.getCursor();if(r.line!==e||r.col!==t+1)return;const c=this.getLines()[r.line]??"";if(c.length!==n.length+1)return;const i=c[t];if(i===void 0||i!=="/"&&!/[A-Za-z0-9_:-]/.test(i))return;const o=G(this.getLines(),r.line,r.col);!o||o.kind!=="ref"||this.tryTriggerAutocomplete()}onCursorDownAtBottom;loadedCommand;title="";info="";contextBadge="";titleStyle=k;contextBadgeStyle=k;paneFocused=!0;resolvedRefNames=new Set;localCommandNames=new Set;engineCommandNames=new Set;setResolvedRefNames(e){this.resolvedRefNames=new Set(e)}getResolvedRefNames(){return this.resolvedRefNames}setLocalCommandNames(e){this.localCommandNames=new Set(e)}setEngineCommandNames(e){this.engineCommandNames=new Set(e)}decorateResolvedRefs(e,t){if(this.resolvedRefNames.size===0)return;const n=this.getText(),r=ce(n);if(r!==null&&this.localCommandNames.has(r)||ae(n,this.engineCommandNames))return;const c=Math.max(0,Math.floor((t-1)/2)),i=Math.min(this.getPaddingX(),c),o=Math.max(1,t-i*2),l=Math.max(1,o-(i?0:1)),u=this.getLines(),a=this.getCursor(),h=Q(u,l,a.line,a.col),m=this.scrollOffset,f=Math.max(5,Math.floor(this.tui.terminal.rows*.3)),g=Math.min(Math.max(0,h.length-m),f);if(g<=0||e.length<1+g)return;const x=new Map;for(let I=0;I<g;I++){const p=h[m+I];if(!p)continue;let T=x.get(p.logicalLine);T===void 0&&(T=ee(u[p.logicalLine]??"",this.resolvedRefNames),x.set(p.logicalLine,T));const $=T.filter(y=>y.start>=p.startIndex&&y.end<=p.endIndex);if($.length===0)continue;const O=e[1+I];O!==void 0&&(e[1+I]=oe(O,p,$,u[p.logicalLine]??"",i))}}render(e){const t=super.render(e);if(!this.paneFocused)for(let n=0;n<t.length;n++){const r=q(t[n]);if(r!==void 0){t[n]=r;break}}if(this.decorateResolvedRefs(t,e),this.loadedCommand!==void 0&&t.length>=2&&e>=8){const n=e-4,r=j(this.loadedCommand.content,n);if(r.length===0)return t;const c=` ${this.loadedCommand.inspectHint} \xB7 /${this.loadedCommand.name} loaded `,i=r.map(a=>{const h=C(a,n);return`${this.borderColor("\u2502")} ${h}${" ".repeat(Math.max(0,n-b(h)))} ${this.borderColor("\u2502")}`}),o=C(c,e-2),l=Math.max(0,e-2-b(o)),u=this.borderColor(`\u251C${o}${"\u2500".repeat(l)}\u2524`);t.splice(1,0,u,...i,this.borderColor(`\u251C${"\u2500".repeat(e-2)}\u2524`))}if((this.title||this.info)&&t.length>0&&(t[0]=Y(e,this.title,this.info,this.titleStyle,n=>this.borderColor(n))),this.contextBadge&&t.length>0){const n=this.contextBadgeStyle(this.contextBadge),r=b(n);if(r+2<e){const c=t.length-1;t[c]=C(t[c],e-r,"")+n}}return t}}export{W as TitledEditor,Q as buildRefLayoutChunks,xe as colorChipStyle,j as compactLoadedCommandPreview,Y as composeTopBorder,oe as decorateRow,k as defaultTitleStyle,J as detectDroppedImagePath,q as outlineCursorLine,pe as thinkingBorderColor,be as thinkingTitleStyle};