@askdkc/dsh-cli 0.11.3

package/lib/types/ink/termio.js

@@ -0,0 +1,24 @@
+/**
+ * ANSI Parser Module
+ *
+ * A semantic ANSI escape sequence parser inspired by ghostty, tmux, and iTerm2.
+ *
+ * Key features:
+ * - Semantic output: produces structured actions, not string tokens
+ * - Streaming: can parse input incrementally via Parser class
+ * - Style tracking: maintains text style state across parse calls
+ * - Comprehensive: supports SGR, CSI, OSC, ESC sequences
+ *
+ * Usage:
+ *
+ * ```typescript
+ * import { Parser } from './termio.js'
+ *
+ * const parser = new Parser()
+ * const actions = parser.feed('\x1b[31mred\x1b[0m')
+ * // => [{ type: 'text', graphemes: [...], style: { fg: { type: 'named', name: 'red' }, ... } }]
+ * ```
+ */
+// Parser
+export { Parser } from './termio/parser.js';
+export { colorsEqual, defaultStyle, stylesEqual } from './termio/types.js';

package/lib/types/ink/timeline-rail.d.ts

@@ -0,0 +1,134 @@
+/**
+ * Timeline rail — the pure geometry model behind the fullscreen
+ * transcript's turn navigator.
+ *
+ * The rail is a 2-column gutter REPLACING the classic scrollbar: one tick
+ * per user turn, where tick position encodes CONVERSATION ORDER, not
+ * scroll proportion. Geometry is computed into a single frozen structure
+ * consumed by both the renderer and mouse hit-testing, so what you see is
+ * always what you can click ("看得到但点不中" impossible by construction).
+ *
+ * Viewport semantics, derived from one shared turn-top list:
+ *
+ *  - active: the LAST turn whose prompt top is at-or-above the viewport
+ *    top (the turn whose content owns the top row — "the turn being
+ *    read"). When pre-turn content (logo / loaded-context panel) owns the
+ *    top, the FIRST turn stands in. Never the newest-turn clamp: its
+ *    one-step-off-bottom highlight leap is exactly what this rule avoids.
+ *  - up target: the last turn STRICTLY above the viewport top. From
+ *    mid-turn it first aligns the current turn's own prompt, and it can
+ *    never name a trailing turn no scroll could bring to the top
+ *    (the stuck-▲ bug).
+ *  - down target: the FIRST turn whose prompt top is strictly below the
+ *    viewport top AND reachable (top ≤ maxScroll — the renderer clamps
+ *    scrollTop to maxScroll, so a turn below it could never own the top
+ *    row; naming it would make ▼ repeat itself forever).
+ *
+ */
+/** Columns the rail reserves (widest tick glyph). */
+export declare const RAIL_WIDTH = 2;
+/** Terminals narrower than this hide the rail (transcript needs the cols). */
+export declare const RAIL_MIN_TERMINAL_WIDTH = 60;
+/** Fewer turns than this and the rail is noise. */
+export declare const RAIL_MIN_TURNS = 2;
+/** Stored preview cap (chars). Render paths re-truncate to card width. */
+export declare const PREVIEW_MAX_CHARS = 120;
+/** One user turn, as the rail sees it. Identity is the row id — never an
+ *  array index (deletion / rewind / loadOlder would mis-target it). */
+export interface TimelineTurn {
+    /** ChatRow id of the user message (jump/preview target). */
+    id: number;
+    /** Content-space top of the prompt TEXT (scrollTo(target) pins it to
+     *  the viewport top). */
+    top: number;
+    /** First non-empty prompt line, char-capped (see clipPreview). */
+    preview: string;
+    /**
+     * True while the row sits BEFORE the fold window (older than the most
+     * recent RENDERED_ROW_CAP rows): its top is unknown (unmounted since
+     * before the fold; `top` carries −1) and clicking the tick must first
+     * reveal the folded history (Chat: showAll + force-mount + seek) rather
+     * than scrollTo(−1). Rendering a tick for it is still correct — the
+     * turn EXISTS and is navigable, it is just folded away right now
+     * (drawing only window turns read as "the rail covers just 2-3 nodes"
+     * on tool-heavy sessions where 300 rows ≈ a handful of turns).
+     */
+    folded?: boolean;
+}
+/** The per-commit snapshot MessageList reports and the rail + sticky
+ *  header consume — one source so the two can never disagree. */
+export interface TimelineSnapshot {
+    /** Turns in conversation order. */
+    turns: ReadonlyArray<TimelineTurn>;
+    /** Turn owning the viewport top row; first turn while pre-turn content
+     *  owns the top; null only when there are no turns. */
+    activeId: number | null;
+    /** ▲ target (strictly above the top), null at the first turn. */
+    upId: number | null;
+    /** ▼ target (below the top and reachable), null at the end. */
+    downId: number | null;
+}
+/** Per-render rail geometry: where the ticks and chevrons landed. */
+export interface RailGeometry {
+    /** Turn-index window shown as ticks: [windowStart, windowEnd). */
+    windowStart: number;
+    windowEnd: number;
+    /** Row of the ▲ chevron (block-local, within the rail column). */
+    upRow: number;
+    /** Row of the first tick. */
+    tickTop: number;
+    /** Row of the ▼ chevron. */
+    downRow: number;
+}
+/** What a rail row is. */
+export type RailHit = {
+    kind: 'up';
+} | {
+    kind: 'down';
+} | {
+    kind: 'tick';
+    index: number;
+};
+/** Single eligibility policy: setting, terminal width, turn count, and
+ *  geometric feasibility in one place. */
+export declare function railEligible(opts: {
+    turnCount: number;
+    terminalWidth: number;
+    viewportRows: number;
+    /** False when the content fits the viewport (inline mode / fresh
+     *  session): nothing to navigate, the terminal's own scrollback owns
+     *  the wheel. */
+    scrollable: boolean;
+}): boolean;
+/**
+ * Compute rail geometry, or null when the rail must not render.
+ *
+ * Windowing: when turns outnumber tick rows (viewport − 2 chevrons), slide
+ * a window around the ACTIVE turn; at the bottom prefer the tail so the
+ * newest ticks stay visible — but never exclude the active turn, or no
+ * tick would highlight. The chevron+tick block is vertically centered in
+ * the rail column.
+ */
+export declare function computeRailGeometry(turnCount: number, viewportRows: number, activeIndex: number | null, atBottom: boolean): RailGeometry | null;
+/**
+ * Which rail interaction a block-local row lands on. The whole rail width
+ * is the hit target (no pixel-hunting the glyph).
+ */
+export declare function railHit(geo: RailGeometry, row: number): RailHit | null;
+/**
+ * First non-empty line, char-capped with a `…` marker. Bounded work: the
+ * scan stops at the first non-empty line and slices at the cap, so a huge
+ * one-line prompt costs O(cap), not O(line length). Char cap (not display
+ * width) on purpose — this bounds the stored snapshot; the hover card
+ * re-wraps to its own width (wrapPreviewLines).
+ */
+export declare function clipPreview(text: string, maxChars?: number): string;
+/**
+ * Wrap a preview to at most 2 lines by DISPLAY width (CJK-aware — a
+ * terminal cell column budget, not a char count). The last line is
+ * ellipsized when content remains. Char-by-char accumulation keeps
+ * surrogate pairs and (best-effort) combining sequences intact by never
+ * splitting below a low surrogate.
+ */
+export declare function wrapPreviewLines(preview: string, maxWidth: number): string[];
+//# sourceMappingURL=timeline-rail.d.ts.map

package/lib/types/ink/timeline-rail.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"timeline-rail.d.ts","sourceRoot":"","sources":["../../../src/ink/timeline-rail.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAIH,qDAAqD;AACrD,eAAO,MAAM,UAAU,IAAI,CAAA;AAE3B,8EAA8E;AAC9E,eAAO,MAAM,uBAAuB,KAAK,CAAA;AAEzC,mDAAmD;AACnD,eAAO,MAAM,cAAc,IAAI,CAAA;AAE/B,0EAA0E;AAC1E,eAAO,MAAM,iBAAiB,MAAM,CAAA;AAEpC;uEACuE;AACvE,MAAM,WAAW,YAAY;IAC3B,4DAA4D;IAC5D,EAAE,EAAE,MAAM,CAAA;IACV;6BACyB;IACzB,GAAG,EAAE,MAAM,CAAA;IACX,kEAAkE;IAClE,OAAO,EAAE,MAAM,CAAA;IACf;;;;;;;;;OASG;IACH,MAAM,CAAC,EAAE,OAAO,CAAA;CACjB;AAED;iEACiE;AACjE,MAAM,WAAW,gBAAgB;IAC/B,mCAAmC;IACnC,KAAK,EAAE,aAAa,CAAC,YAAY,CAAC,CAAA;IAClC;2DACuD;IACvD,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAA;IACvB,iEAAiE;IACjE,IAAI,EAAE,MAAM,GAAG,IAAI,CAAA;IACnB,+DAA+D;IAC/D,MAAM,EAAE,MAAM,GAAG,IAAI,CAAA;CACtB;AAED,qEAAqE;AACrE,MAAM,WAAW,YAAY;IAC3B,kEAAkE;IAClE,WAAW,EAAE,MAAM,CAAA;IACnB,SAAS,EAAE,MAAM,CAAA;IACjB,kEAAkE;IAClE,KAAK,EAAE,MAAM,CAAA;IACb,6BAA6B;IAC7B,OAAO,EAAE,MAAM,CAAA;IACf,4BAA4B;IAC5B,OAAO,EAAE,MAAM,CAAA;CAChB;AAED,0BAA0B;AAC1B,MAAM,MAAM,OAAO,GACf;IAAE,IAAI,EAAE,IAAI,CAAA;CAAE,GACd;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,GAChB;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAA;AAEnC;0CAC0C;AAC1C,wBAAgB,YAAY,CAAC,IAAI,EAAE;IACjC,SAAS,EAAE,MAAM,CAAA;IACjB,aAAa,EAAE,MAAM,CAAA;IACrB,YAAY,EAAE,MAAM,CAAA;IACpB;;qBAEiB;IACjB,UAAU,EAAE,OAAO,CAAA;CACpB,GAAG,OAAO,CAOV;AAED;;;;;;;;GAQG;AACH,wBAAgB,mBAAmB,CACjC,SAAS,EAAE,MAAM,EACjB,YAAY,EAAE,MAAM,EACpB,WAAW,EAAE,MAAM,GAAG,IAAI,EAC1B,QAAQ,EAAE,OAAO,GAChB,YAAY,GAAG,IAAI,CAuBrB;AAED;;;GAGG;AACH,wBAAgB,OAAO,CAAC,GAAG,EAAE,YAAY,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,GAAG,IAAI,CAUtE;AAED;;;;;;GAMG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,SAAoB,GAAG,MAAM,CAkB9E;AAED;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,EAAE,CA+B5E"}

package/lib/types/ink/timeline-rail.js

@@ -0,0 +1,175 @@
+/**
+ * Timeline rail — the pure geometry model behind the fullscreen
+ * transcript's turn navigator.
+ *
+ * The rail is a 2-column gutter REPLACING the classic scrollbar: one tick
+ * per user turn, where tick position encodes CONVERSATION ORDER, not
+ * scroll proportion. Geometry is computed into a single frozen structure
+ * consumed by both the renderer and mouse hit-testing, so what you see is
+ * always what you can click ("看得到但点不中" impossible by construction).
+ *
+ * Viewport semantics, derived from one shared turn-top list:
+ *
+ *  - active: the LAST turn whose prompt top is at-or-above the viewport
+ *    top (the turn whose content owns the top row — "the turn being
+ *    read"). When pre-turn content (logo / loaded-context panel) owns the
+ *    top, the FIRST turn stands in. Never the newest-turn clamp: its
+ *    one-step-off-bottom highlight leap is exactly what this rule avoids.
+ *  - up target: the last turn STRICTLY above the viewport top. From
+ *    mid-turn it first aligns the current turn's own prompt, and it can
+ *    never name a trailing turn no scroll could bring to the top
+ *    (the stuck-▲ bug).
+ *  - down target: the FIRST turn whose prompt top is strictly below the
+ *    viewport top AND reachable (top ≤ maxScroll — the renderer clamps
+ *    scrollTop to maxScroll, so a turn below it could never own the top
+ *    row; naming it would make ▼ repeat itself forever).
+ *
+ */
+import { stringWidth } from './stringWidth.js';
+/** Columns the rail reserves (widest tick glyph). */
+export const RAIL_WIDTH = 2;
+/** Terminals narrower than this hide the rail (transcript needs the cols). */
+export const RAIL_MIN_TERMINAL_WIDTH = 60;
+/** Fewer turns than this and the rail is noise. */
+export const RAIL_MIN_TURNS = 2;
+/** Stored preview cap (chars). Render paths re-truncate to card width. */
+export const PREVIEW_MAX_CHARS = 120;
+/** Single eligibility policy: setting, terminal width, turn count, and
+ *  geometric feasibility in one place. */
+export function railEligible(opts) {
+    return (opts.scrollable &&
+        opts.turnCount >= RAIL_MIN_TURNS &&
+        opts.terminalWidth >= RAIL_MIN_TERMINAL_WIDTH &&
+        opts.viewportRows >= 3);
+}
+/**
+ * Compute rail geometry, or null when the rail must not render.
+ *
+ * Windowing: when turns outnumber tick rows (viewport − 2 chevrons), slide
+ * a window around the ACTIVE turn; at the bottom prefer the tail so the
+ * newest ticks stay visible — but never exclude the active turn, or no
+ * tick would highlight. The chevron+tick block is vertically centered in
+ * the rail column.
+ */
+export function computeRailGeometry(turnCount, viewportRows, activeIndex, atBottom) {
+    if (turnCount < RAIL_MIN_TURNS)
+        return null;
+    const maxTicks = viewportRows - 2;
+    if (maxTicks < 1)
+        return null;
+    let start = 0;
+    if (turnCount > maxTicks) {
+        const tailStart = turnCount - maxTicks;
+        const anchor = activeIndex ?? turnCount - 1;
+        start = atBottom
+            ? Math.min(anchor, tailStart)
+            : Math.min(Math.max(0, anchor - Math.floor(maxTicks / 2)), tailStart);
+    }
+    const shown = Math.min(turnCount, maxTicks);
+    // Vertically center the ▲ + ticks + ▼ stack, like the web rail.
+    const blockTop = Math.max(0, Math.floor((viewportRows - (shown + 2)) / 2));
+    return {
+        windowStart: start,
+        windowEnd: start + shown,
+        upRow: blockTop,
+        tickTop: blockTop + 1,
+        downRow: blockTop + 1 + shown,
+    };
+}
+/**
+ * Which rail interaction a block-local row lands on. The whole rail width
+ * is the hit target (no pixel-hunting the glyph).
+ */
+export function railHit(geo, row) {
+    if (row === geo.upRow)
+        return { kind: 'up' };
+    if (row === geo.downRow)
+        return { kind: 'down' };
+    if (row >= geo.tickTop) {
+        const rel = row - geo.tickTop;
+        if (rel < geo.windowEnd - geo.windowStart) {
+            return { kind: 'tick', index: geo.windowStart + rel };
+        }
+    }
+    return null;
+}
+/**
+ * First non-empty line, char-capped with a `…` marker. Bounded work: the
+ * scan stops at the first non-empty line and slices at the cap, so a huge
+ * one-line prompt costs O(cap), not O(line length). Char cap (not display
+ * width) on purpose — this bounds the stored snapshot; the hover card
+ * re-wraps to its own width (wrapPreviewLines).
+ */
+export function clipPreview(text, maxChars = PREVIEW_MAX_CHARS) {
+    let line = '';
+    let rest = text;
+    while (rest.length > 0) {
+        const nl = rest.indexOf('\n');
+        const head = nl === -1 ? rest : rest.slice(0, nl);
+        rest = nl === -1 ? '' : rest.slice(nl + 1);
+        const trimmed = head.trim();
+        if (trimmed.length > 0) {
+            line = trimmed;
+            break;
+        }
+    }
+    if (line.length <= maxChars)
+        return line;
+    // Keep the cap INCLUDING the ellipsis marker, like grok's preview. Slice
+    // by CODE POINTS, not UTF-16 units — a surrogate pair split mid-pair
+    // would emit a lone surrogate to the terminal.
+    return `${[...line].slice(0, maxChars - 1).join('')}…`;
+}
+/**
+ * Wrap a preview to at most 2 lines by DISPLAY width (CJK-aware — a
+ * terminal cell column budget, not a char count). The last line is
+ * ellipsized when content remains. Char-by-char accumulation keeps
+ * surrogate pairs and (best-effort) combining sequences intact by never
+ * splitting below a low surrogate.
+ */
+export function wrapPreviewLines(preview, maxWidth) {
+    const widthOf = stringWidth;
+    const lines = [];
+    let current = '';
+    let currentW = 0;
+    for (const ch of preview) {
+        const w = widthOf(ch);
+        if (w <= 0) {
+            // Zero-width (combining marks, ZWJ): attach for free.
+            current += ch;
+            continue;
+        }
+        if (currentW + w > maxWidth) {
+            if (lines.length === 1) {
+                // Second line full → ellipsize in place and stop.
+                return [lines[0], ellipsize(current, maxWidth)];
+            }
+            lines.push(current);
+            current = ch;
+            currentW = w;
+            continue;
+        }
+        current += ch;
+        currentW += w;
+    }
+    if (current.length > 0 || lines.length === 0)
+        lines.push(current);
+    if (lines.length > 2) {
+        // Cannot happen (we stop after the second), kept for exhaustiveness.
+        return [lines[0], ellipsize(lines[1], maxWidth)];
+    }
+    return lines.slice(0, 2);
+}
+function ellipsize(line, maxWidth) {
+    // Make room for '…' (1 col) then hard-cut by display width.
+    let out = '';
+    let w = 0;
+    for (const ch of line) {
+        const cw = stringWidth(ch);
+        if (cw > 0 && w + cw > maxWidth - 1)
+            break;
+        out += ch;
+        w += cw;
+    }
+    return `${out}…`;
+}

package/lib/types/ink/transcript-highlight.d.ts

@@ -0,0 +1,25 @@
+import { type Screen, type StylePool } from './screen.js';
+/**
+ * Highlight all visible occurrences of `query` in the screen buffer by
+ * inverting cell styles (SGR 7). Post-render, same damage-tracking machinery
+ * as applySelectionOverlay — the diff picks up highlighted cells as ordinary
+ * changes, LogUpdate stays a pure diff engine.
+ *
+ * Case-insensitive. Handles wide characters (CJK, emoji) by building a
+ * col-of-char map per row — the Nth character isn't at col N when wide chars
+ * are present (each occupies 2 cells: head + SpacerTail).
+ *
+ * This ONLY inverts — there is no "current match" logic here. The yellow
+ * current-match overlay is handled separately by applyPositionedHighlight
+ * (render-to-screen.ts), which writes on top using positions scanned from
+ * the target message's DOM subtree.
+ *
+ * Returns true if any match was highlighted (damage gate — caller forces
+ * full-frame damage when true).
+ * @param screen - the screen buffer to search and update.
+ * @param query - the case-insensitive search text; empty queries are a no-op.
+ * @param stylePool - the style pool providing the inverted style id.
+ * @returns true when at least one occurrence was highlighted.
+ */
+export declare function applySearchHighlight(screen: Screen, query: string, stylePool: StylePool): boolean;
+//# sourceMappingURL=transcript-highlight.d.ts.map

package/lib/types/ink/transcript-highlight.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transcript-highlight.d.ts","sourceRoot":"","sources":["../../../src/ink/transcript-highlight.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,MAAM,EACX,KAAK,SAAS,EAEf,MAAM,aAAa,CAAA;AAEpB;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,oBAAoB,CAClC,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,MAAM,EACb,SAAS,EAAE,SAAS,GACnB,OAAO,CA8DT"}

package/lib/types/ink/transcript-highlight.js

@@ -0,0 +1,82 @@
+import { cellAtIndex, setCellStyleId, } from './screen.js';
+/**
+ * Highlight all visible occurrences of `query` in the screen buffer by
+ * inverting cell styles (SGR 7). Post-render, same damage-tracking machinery
+ * as applySelectionOverlay — the diff picks up highlighted cells as ordinary
+ * changes, LogUpdate stays a pure diff engine.
+ *
+ * Case-insensitive. Handles wide characters (CJK, emoji) by building a
+ * col-of-char map per row — the Nth character isn't at col N when wide chars
+ * are present (each occupies 2 cells: head + SpacerTail).
+ *
+ * This ONLY inverts — there is no "current match" logic here. The yellow
+ * current-match overlay is handled separately by applyPositionedHighlight
+ * (render-to-screen.ts), which writes on top using positions scanned from
+ * the target message's DOM subtree.
+ *
+ * Returns true if any match was highlighted (damage gate — caller forces
+ * full-frame damage when true).
+ * @param screen - the screen buffer to search and update.
+ * @param query - the case-insensitive search text; empty queries are a no-op.
+ * @param stylePool - the style pool providing the inverted style id.
+ * @returns true when at least one occurrence was highlighted.
+ */
+export function applySearchHighlight(screen, query, stylePool) {
+    if (!query)
+        return false;
+    const lq = query.toLowerCase();
+    const qlen = lq.length;
+    const w = screen.width;
+    const noSelect = screen.noSelect;
+    const height = screen.height;
+    let applied = false;
+    for (let row = 0; row < height; row++) {
+        const rowOff = row * w;
+        // Build row text (already lowercased) + code-unit→cell-index map.
+        // Three skip conditions, all aligned with setCellStyleId /
+        // extractRowText (selection.ts):
+        //   - SpacerTail: 2nd cell of a wide char, no char of its own
+        //   - SpacerHead: end-of-line padding when a wide char wraps
+        //   - noSelect: gutters (⎿, line numbers) — same exclusion as
+        //     applySelectionOverlay. "Highlight what you see" still holds for
+        //     content; gutters aren't search targets.
+        // Lowercasing per-char (not on the joined string at the end) means
+        // codeUnitToCell maps positions in the LOWERCASED text — U+0130
+        // (Turkish İ) lowercases to 2 code units, so lowering the joined
+        // string would desync indexOf positions from the map.
+        let text = '';
+        const colOf = [];
+        const codeUnitToCell = [];
+        for (let col = 0; col < w; col++) {
+            const idx = rowOff + col;
+            const cell = cellAtIndex(screen, idx);
+            if (cell.width === 2 /* CellWidth.SpacerTail */ ||
+                cell.width === 3 /* CellWidth.SpacerHead */ ||
+                noSelect[idx] === 1) {
+                continue;
+            }
+            const lc = cell.char.toLowerCase();
+            const cellIdx = colOf.length;
+            for (let i = 0; i < lc.length; i++) {
+                codeUnitToCell.push(cellIdx);
+            }
+            text += lc;
+            colOf.push(col);
+        }
+        let pos = text.indexOf(lq);
+        while (pos >= 0) {
+            applied = true;
+            const startCi = codeUnitToCell[pos];
+            const endCi = codeUnitToCell[pos + qlen - 1];
+            for (let ci = startCi; ci <= endCi; ci++) {
+                const col = colOf[ci];
+                const cell = cellAtIndex(screen, rowOff + col);
+                setCellStyleId(screen, col, row, stylePool.withInverse(cell.styleId));
+            }
+            // Non-overlapping advance (less/vim/grep/Ctrl+F). pos+1 would find
+            // 'aa' at 0 AND 1 in 'aaa' → double-invert cell 1.
+            pos = text.indexOf(lq, pos + qlen);
+        }
+    }
+    return applied;
+}

package/lib/types/ink/truncateToWidth.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Slice a string to at most `maxWidth` terminal cells, walking by code
+ * point so CJK wide characters never split mid-glyph. Assumes no ANSI in
+ * the input (callers pass plain text).
+ */
+export declare function truncateToWidth(text: string, maxWidth: number): string;
+//# sourceMappingURL=truncateToWidth.d.ts.map

package/lib/types/ink/truncateToWidth.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"truncateToWidth.d.ts","sourceRoot":"","sources":["../../../src/ink/truncateToWidth.ts"],"names":[],"mappings":"AAEA;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAUtE"}

package/lib/types/ink/truncateToWidth.js

@@ -0,0 +1,18 @@
+import { stringWidth } from './stringWidth.js';
+/**
+ * Slice a string to at most `maxWidth` terminal cells, walking by code
+ * point so CJK wide characters never split mid-glyph. Assumes no ANSI in
+ * the input (callers pass plain text).
+ */
+export function truncateToWidth(text, maxWidth) {
+    let width = 0;
+    let out = '';
+    for (const char of text) {
+        const charWidth = stringWidth(char);
+        if (width + charWidth > maxWidth)
+            break;
+        width += charWidth;
+        out += char;
+    }
+    return out;
+}

package/lib/types/ink/update-overflow-guard.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Self-healing guard for React's nested-update overflow — Minified React
+ * error #185 ("Maximum update depth exceeded").
+ *
+ * WHY THIS EXISTS — the crash is a ratchet, not a single bad component.
+ * react-reconciler counts consecutive commits that each end with more
+ * pending Sync/InputContinuous/Default-lane updates on the same root
+ * (`nestedUpdateCount`); once 50 commits pass without one that drains the
+ * queue, the NEXT update enqueue throws #185 — from whichever timer or
+ * store notification happens to fire first, which is why the stack points
+ * at an innocent animation tick while the actual oscillating component is
+ * someone else entirely (the upstream fork lineage hit this repeatedly:
+ * Divider measure loops, MessageList streaming measure cascades, and the
+ * repeated layout measurements during streaming).
+ *
+ * The throw is SELF-HEALING BY CONTRACT: `getRootForUpdatedFiber` resets
+ * `nestedUpdateCount` to 0 and clears `rootWithNestedUpdates` *before*
+ * throwing, so swallowing exactly this error class skips at most one frame
+ * of animation while the next commit starts from a clean counter. That
+ * turns a process-killing crash into a dropped tick plus a rate-limited
+ * diagnostic breadcrumb naming the enqueue site that surfaced it.
+ *
+ * This guard deliberately does NOT swallow anything else: unknown errors
+ * rethrow unchanged.
+ */
+/** Quench action for a source: pause its notification channel for `ms`. */
+export type OverflowQuench = (ms: number) => void;
+/** Test seam: reset rate-limit bookkeeping. */
+export declare function resetUpdateOverflowGuardForTest(): void;
+/**
+ * Register a circuit-breaker action for a source. When the source trips
+ * (sustained oscillation), the quench pauses its notification channel for
+ * the backoff window — the strongest self-healing the guard can do without
+ * killing the process. Sources without a quench (data channels that must
+ * not stall) only get the escalated ERROR log.
+ */
+export declare function registerOverflowQuench(source: string, quench: OverflowQuench): void;
+/**
+ * Whether an error is the nested-update overflow (#185) — by message, the
+ * only signal the production build exposes.
+ */
+export declare function isNestedUpdateOverflow(error: unknown): boolean;
+/**
+ * Swallow the nested-update overflow error, logging (rate-limited, with a
+ * running count per window) which enqueue site surfaced it. Any other error
+ * returns false so callers rethrow it untouched.
+ *
+ * @param error - The caught error from a subscriber/enqueue notification.
+ * @param source - Stable label naming the enqueue site (for the log line).
+ * @returns true when the error was the overflow and has been absorbed.
+ */
+export declare function swallowNestedUpdateOverflow(error: unknown, source: string): boolean;
+/**
+ * Invoke a notification callback with the overflow guard applied. The
+ * callback's own non-overflow errors propagate unchanged.
+ *
+ * @param source - Stable label naming the enqueue site (for the log line).
+ * @param onChange - The subscriber callback about to run.
+ */
+export declare function callWithUpdateOverflowGuard(source: string, onChange: () => void): void;
+export declare function installNestedUpdateOverflowProcessGuard(): void;
+//# sourceMappingURL=update-overflow-guard.d.ts.map

package/lib/types/ink/update-overflow-guard.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"update-overflow-guard.d.ts","sourceRoot":"","sources":["../../../src/ink/update-overflow-guard.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAoBH,2EAA2E;AAC3E,MAAM,MAAM,cAAc,GAAG,CAAC,EAAE,EAAE,MAAM,KAAK,IAAI,CAAA;AAOjD,+CAA+C;AAC/C,wBAAgB,+BAA+B,IAAI,IAAI,CAEtD;AAED;;;;;;GAMG;AACH,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,cAAc,GAAG,IAAI,CAEnF;AAED;;;GAGG;AACH,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAG9D;AAED;;;;;;;;GAQG;AACH,wBAAgB,2BAA2B,CAAC,KAAK,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAmDnF;AAED;;;;;;GAMG;AACH,wBAAgB,2BAA2B,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,IAAI,GAAG,IAAI,CAOtF;AAeD,wBAAgB,uCAAuC,IAAI,IAAI,CAc9D"}