@svelterm/core 0.1.0 → 0.23.0

package/dist/src/render/ansi-text.js

@@ -0,0 +1,131 @@
+/**
+ * Minimal ANSI/SGR parser for the <svt-ansi> passthrough element:
+ * pre-styled tool output (git diff, ls --color, build logs) renders as
+ * styled cells. SGR sequences apply; every other escape sequence is
+ * dropped. Content is `pre` — lines split on newline, no wrapping.
+ */
+const SGR_NAMES = ['black', 'red', 'green', 'yellow', 'blue', 'magenta', 'cyan', 'white'];
+/** Standard xterm palette entries 8–15 (the bright variants). */
+const BRIGHT_HEX = ['#808080', '#ff0000', '#00ff00', '#ffff00', '#0000ff', '#ff00ff', '#00ffff', '#ffffff'];
+const CUBE_LEVELS = [0, 95, 135, 175, 215, 255];
+/** The xterm 256-palette entry as #rrggbb (16–255; 0–15 use names/brights). */
+export function palette256(index) {
+    if (index < 8)
+        return SGR_NAMES[index];
+    if (index < 16)
+        return BRIGHT_HEX[index - 8];
+    if (index < 232) {
+        const n = index - 16;
+        const r = CUBE_LEVELS[Math.floor(n / 36)];
+        const g = CUBE_LEVELS[Math.floor(n / 6) % 6];
+        const b = CUBE_LEVELS[n % 6];
+        return hex(r, g, b);
+    }
+    const grey = 8 + (index - 232) * 10;
+    return hex(grey, grey, grey);
+}
+function hex(r, g, b) {
+    return '#' + [r, g, b].map(c => c.toString(16).padStart(2, '0')).join('');
+}
+const DEFAULT_STYLE = {
+    fg: 'default', bg: 'default',
+    bold: false, dim: false, italic: false,
+    underline: false, strikethrough: false, inverse: false,
+};
+const ESCAPE_RE = /\x1b(?:\[([0-9;]*)([a-zA-Z])|\][^\x07\x1b]*(?:\x07|\x1b\\)|[a-zA-Z=><])/;
+/** Parse ANSI-styled text into lines of styled cells. */
+export function parseAnsiText(text) {
+    const lines = [[]];
+    let style = { ...DEFAULT_STYLE };
+    let rest = text;
+    while (rest.length > 0) {
+        const match = ESCAPE_RE.exec(rest);
+        const plain = match ? rest.slice(0, match.index) : rest;
+        for (const char of plain) {
+            const line = lines[lines.length - 1];
+            if (char === '\n')
+                lines.push([]);
+            else if (char === '\r')
+                continue;
+            else if (char === '\t') {
+                const stop = (Math.floor(line.length / 8) + 1) * 8;
+                while (line.length < stop)
+                    line.push({ char: ' ', ...style });
+            }
+            else {
+                line.push({ char, ...style });
+            }
+        }
+        if (!match)
+            break;
+        if (match[2] === 'm')
+            style = applySgr(style, match[1] ?? '');
+        rest = rest.slice(match.index + match[0].length);
+    }
+    return lines;
+}
+function applySgr(style, params) {
+    const next = { ...style };
+    const codes = params === '' ? [0] : params.split(';').map(n => parseInt(n, 10) || 0);
+    for (let i = 0; i < codes.length; i++) {
+        const code = codes[i];
+        if (code === 0)
+            Object.assign(next, DEFAULT_STYLE);
+        else if (code === 1)
+            next.bold = true;
+        else if (code === 2)
+            next.dim = true;
+        else if (code === 3)
+            next.italic = true;
+        else if (code === 4)
+            next.underline = true;
+        else if (code === 7)
+            next.inverse = true;
+        else if (code === 9)
+            next.strikethrough = true;
+        else if (code === 22) {
+            next.bold = false;
+            next.dim = false;
+        }
+        else if (code === 23)
+            next.italic = false;
+        else if (code === 24)
+            next.underline = false;
+        else if (code === 27)
+            next.inverse = false;
+        else if (code === 29)
+            next.strikethrough = false;
+        else if (code >= 30 && code <= 37)
+            next.fg = SGR_NAMES[code - 30];
+        else if (code === 39)
+            next.fg = 'default';
+        else if (code >= 40 && code <= 47)
+            next.bg = SGR_NAMES[code - 40];
+        else if (code === 49)
+            next.bg = 'default';
+        else if (code >= 90 && code <= 97)
+            next.fg = BRIGHT_HEX[code - 90];
+        else if (code >= 100 && code <= 107)
+            next.bg = BRIGHT_HEX[code - 100];
+        else if (code === 38 || code === 48) {
+            const target = code === 38 ? 'fg' : 'bg';
+            if (codes[i + 1] === 5 && codes.length > i + 2) {
+                next[target] = palette256(codes[i + 2]);
+                i += 2;
+            }
+            else if (codes[i + 1] === 2 && codes.length > i + 4) {
+                next[target] = hex(codes[i + 2], codes[i + 3], codes[i + 4]);
+                i += 4;
+            }
+        }
+    }
+    return next;
+}
+/** Width/height of parsed content (pre semantics — longest line, no wrap). */
+export function measureAnsiText(text) {
+    const lines = parseAnsiText(text);
+    return {
+        width: lines.reduce((max, line) => Math.max(max, line.length), 0),
+        height: lines.length,
+    };
+}

package/dist/src/render/ansi.d.ts

@@ -1,3 +1,6 @@
+import type { ColorDepth } from '../terminal/capabilities.js';
+export declare function setColorDepth(depth: ColorDepth): void;
+export declare function getColorDepth(): ColorDepth;
 export declare function moveTo(col: number, row: number): string;
 export declare function clearScreen(): string;
 export declare function hideCursor(): string;
@@ -10,6 +13,7 @@ export declare function dim(): string;
 export declare function italic(): string;
 export declare function underline(): string;
 export declare function strikethrough(): string;
+export declare function inverse(): string;
 export declare function fgColor(color: string): string;
 export declare function bgColor(color: string): string;
 export declare function hyperlinkOpen(url: string): string;
@@ -17,7 +21,21 @@ export declare function hyperlinkClose(): string;
 export declare function enableMouse(): string;
 export declare function disableMouse(): string;
 export declare function setCursorShape(shape: 'block' | 'underline' | 'bar'): string;
+/** DECSCUSR 0 — the terminal's configured default cursor. */
+export declare function resetCursorShape(): string;
+/** Kitty keyboard protocol: push disambiguate-escape-codes mode. */
+export declare function pushKittyKeyboard(): string;
+/** Kitty keyboard protocol: pop our mode entry. */
+export declare function popKittyKeyboard(): string;
 export declare function enableBracketedPaste(): string;
 export declare function disableBracketedPaste(): string;
+/** DECSTBM — set the scroll region to rows [top, bottom] (1-based). */
+export declare function setScrollRegion(top: number, bottom: number): string;
+/** DECSTBM reset — scroll region back to the full screen. */
+export declare function resetScrollRegion(): string;
+/** IND — index: move down one line, scrolling the region at its bottom. */
+export declare function index(): string;
+/** RI — reverse index: move up one line, scrolling the region at its top. */
+export declare function reverseIndex(): string;
 export declare function beginSyncUpdate(): string;
 export declare function endSyncUpdate(): string;

package/dist/src/render/ansi.js

@@ -1,5 +1,15 @@
+import { quantizeTo256, quantizeTo16 } from './color-depth.js';
 const ESC = '\x1b';
 const CSI = `${ESC}[`;
+// Colour depth applies to the whole process's output stream, set once
+// after capability detection (default: truecolor, today's common case).
+let colorDepth = 'truecolor';
+export function setColorDepth(depth) {
+    colorDepth = depth;
+}
+export function getColorDepth() {
+    return colorDepth;
+}
 function expandHex(color) {
     if (color.length === 4) {
         return '#' + color[1] + color[1] + color[2] + color[2] + color[3] + color[3];
@@ -42,31 +52,38 @@ export function underline() {
 export function strikethrough() {
     return `${CSI}9m`;
 }
+export function inverse() {
+    return `${CSI}7m`;
+}
 export function fgColor(color) {
-    const code = ANSI_FG[color];
-    if (code !== undefined)
-        return `${CSI}${code}m`;
-    if (color.startsWith('#')) {
-        const hex = expandHex(color);
-        const r = parseInt(hex.slice(1, 3), 16);
-        const g = parseInt(hex.slice(3, 5), 16);
-        const b = parseInt(hex.slice(5, 7), 16);
-        return `${CSI}38;2;${r};${g};${b}m`;
-    }
-    return '';
+    return sgrColor(color, ANSI_FG, 38);
 }
 export function bgColor(color) {
-    const code = ANSI_BG[color];
+    return sgrColor(color, ANSI_BG, 48);
+}
+function sgrColor(color, names, extended) {
+    if (colorDepth === 'mono') {
+        // Colour is disabled; only default (the reset) still emits.
+        return color === 'default' ? `${CSI}${names.default}m` : '';
+    }
+    const code = names[color];
     if (code !== undefined)
         return `${CSI}${code}m`;
-    if (color.startsWith('#')) {
-        const hex = expandHex(color);
-        const r = parseInt(hex.slice(1, 3), 16);
-        const g = parseInt(hex.slice(3, 5), 16);
-        const b = parseInt(hex.slice(5, 7), 16);
-        return `${CSI}48;2;${r};${g};${b}m`;
+    if (!color.startsWith('#'))
+        return '';
+    const hex = expandHex(color);
+    switch (colorDepth) {
+        case '256':
+            return `${CSI}${extended};5;${quantizeTo256(hex)}m`;
+        case '16':
+            return `${CSI}${names[quantizeTo16(hex)]}m`;
+        default: {
+            const r = parseInt(hex.slice(1, 3), 16);
+            const g = parseInt(hex.slice(3, 5), 16);
+            const b = parseInt(hex.slice(5, 7), 16);
+            return `${CSI}${extended};2;${r};${g};${b}m`;
+        }
     }
-    return '';
 }
 const ANSI_FG = {
     black: 30, red: 31, green: 32, yellow: 33,
@@ -89,12 +106,40 @@ export function setCursorShape(shape) {
     const code = shape === 'block' ? 2 : shape === 'underline' ? 4 : 6;
     return `${CSI}${code} q`;
 }
+/** DECSCUSR 0 — the terminal's configured default cursor. */
+export function resetCursorShape() {
+    return `${CSI}0 q`;
+}
+/** Kitty keyboard protocol: push disambiguate-escape-codes mode. */
+export function pushKittyKeyboard() {
+    return `${CSI}>1u`;
+}
+/** Kitty keyboard protocol: pop our mode entry. */
+export function popKittyKeyboard() {
+    return `${CSI}<u`;
+}
 export function enableBracketedPaste() {
     return `${CSI}?2004h`;
 }
 export function disableBracketedPaste() {
     return `${CSI}?2004l`;
 }
+/** DECSTBM — set the scroll region to rows [top, bottom] (1-based). */
+export function setScrollRegion(top, bottom) {
+    return `${CSI}${top};${bottom}r`;
+}
+/** DECSTBM reset — scroll region back to the full screen. */
+export function resetScrollRegion() {
+    return `${CSI}r`;
+}
+/** IND — index: move down one line, scrolling the region at its bottom. */
+export function index() {
+    return `${ESC}D`;
+}
+/** RI — reverse index: move up one line, scrolling the region at its top. */
+export function reverseIndex() {
+    return `${ESC}M`;
+}
 export function beginSyncUpdate() {
     return `${CSI}?2026h`;
 }

package/dist/src/render/border.js

@@ -1,12 +1,96 @@
 const BORDER_SETS = {
-    single: { topLeft: '┌', topRight: '┐', bottomLeft: '└', bottomRight: '┘', horizontal: '─', vertical: '│' },
-    double: { topLeft: '╔', topRight: '╗', bottomLeft: '╚', bottomRight: '╝', horizontal: '═', vertical: '║' },
-    rounded: { topLeft: '╭', topRight: '╮', bottomLeft: '╰', bottomRight: '╯', horizontal: '─', vertical: '│' },
-    heavy: { topLeft: '┏', topRight: '┓', bottomLeft: '┗', bottomRight: '┛', horizontal: '━', vertical: '┃' },
+    single: { topLeft: '┌', topRight: '┐', bottomLeft: '└', bottomRight: '┘', horizontal: '─', vertical: '│', teeLeft: '├', teeRight: '┤', teeTop: '┬', teeBottom: '┴', cross: '┼' },
+    double: { topLeft: '╔', topRight: '╗', bottomLeft: '╚', bottomRight: '╝', horizontal: '═', vertical: '║', teeLeft: '╠', teeRight: '╣', teeTop: '╦', teeBottom: '╩', cross: '╬' },
+    rounded: { topLeft: '╭', topRight: '╮', bottomLeft: '╰', bottomRight: '╯', horizontal: '─', vertical: '│', teeLeft: '├', teeRight: '┤', teeTop: '┬', teeBottom: '┴', cross: '┼' },
+    heavy: { topLeft: '┏', topRight: '┓', bottomLeft: '┗', bottomRight: '┛', horizontal: '━', vertical: '┃', teeLeft: '┣', teeRight: '┫', teeTop: '┳', teeBottom: '┻', cross: '╋' },
+    ascii: { topLeft: '+', topRight: '+', bottomLeft: '+', bottomRight: '+', horizontal: '-', vertical: '|', teeLeft: '+', teeRight: '+', teeTop: '+', teeBottom: '+', cross: '+' },
+};
+/**
+ * Direction masks for box-drawing glyph merging. Each glyph is the set of
+ * directions its strokes point in; overlapping glyphs merge by unioning
+ * their masks (e.g. ┐ over └ → all four directions → ┼).
+ */
+const UP = 1, RIGHT = 2, DOWN = 4, LEFT = 8;
+const GLYPH_MASKS = {};
+for (const s of Object.values(BORDER_SETS)) {
+    GLYPH_MASKS[s.topLeft] = RIGHT | DOWN;
+    GLYPH_MASKS[s.topRight] = LEFT | DOWN;
+    GLYPH_MASKS[s.bottomLeft] = UP | RIGHT;
+    GLYPH_MASKS[s.bottomRight] = UP | LEFT;
+    GLYPH_MASKS[s.horizontal] = LEFT | RIGHT;
+    GLYPH_MASKS[s.vertical] = UP | DOWN;
+    GLYPH_MASKS[s.teeLeft] = UP | DOWN | RIGHT;
+    GLYPH_MASKS[s.teeRight] = UP | DOWN | LEFT;
+    GLYPH_MASKS[s.teeTop] = LEFT | RIGHT | DOWN;
+    GLYPH_MASKS[s.teeBottom] = LEFT | RIGHT | UP;
+    GLYPH_MASKS[s.cross] = UP | RIGHT | DOWN | LEFT;
+}
+function glyphForMask(chars, mask) {
+    switch (mask) {
+        case RIGHT | DOWN: return chars.topLeft;
+        case LEFT | DOWN: return chars.topRight;
+        case UP | RIGHT: return chars.bottomLeft;
+        case UP | LEFT: return chars.bottomRight;
+        case LEFT | RIGHT: return chars.horizontal;
+        case UP | DOWN: return chars.vertical;
+        case UP | DOWN | RIGHT: return chars.teeLeft;
+        case UP | DOWN | LEFT: return chars.teeRight;
+        case LEFT | RIGHT | DOWN: return chars.teeTop;
+        case LEFT | RIGHT | UP: return chars.teeBottom;
+        case UP | RIGHT | DOWN | LEFT: return chars.cross;
+        default: return undefined;
+    }
+}
+/**
+ * Merge a border glyph with whatever box-drawing character is already in the
+ * buffer cell, producing T-junctions and crosses where strokes meet. The new
+ * glyph's family (single/double/...) wins for the merged character.
+ */
+function mergeGlyph(buffer, cx, cy, newMask, chars) {
+    const fallback = glyphForMask(chars, newMask) ?? chars.cross;
+    const existing = buffer.getCell(cx, cy)?.char;
+    const existingMask = existing !== undefined ? GLYPH_MASKS[existing] : undefined;
+    if (existingMask === undefined)
+        return fallback;
+    return glyphForMask(chars, existingMask | newMask) ?? fallback;
+}
+const BLOCK_EDGES = {
+    'eighth-cell-inner': { top: '\u2581', bottom: '\u2594', left: '\u2595', right: '\u258F' },
+    'eighth-cell-outer': { top: '\u2594', bottom: '\u2581', left: '\u258F', right: '\u2595' },
+    'half-cell-inner': { top: '\u2584', bottom: '\u2580', left: '\u2590', right: '\u258C' },
+    'half-cell-outer': { top: '\u2580', bottom: '\u2584', left: '\u258C', right: '\u2590' },
+    'full-cell': { top: '\u2588', bottom: '\u2588', left: '\u2588', right: '\u2588' },
+};
+const BLOCK_CORNERS = {
+    // Inner-facing: strokes face the content area, so corner glyphs fill the
+    // inner quadrant relative to the cell (e.g. top-left corner fills lower-right).
+    'half-cell-inner': {
+        topLeft: '\u2597', // ▗ lower-right quadrant
+        topRight: '\u2596', // ▖ lower-left quadrant
+        bottomLeft: '\u259D', // ▝ upper-right quadrant
+        bottomRight: '\u2598', // ▘ upper-left quadrant
+    },
+    // Outer-facing: strokes face outward. Corner cells combine the full upper
+    // half (or lower half) with the full left half (or right half), forming
+    // three-quadrant L glyphs with just the diagonally-inner quadrant empty.
+    'half-cell-outer': {
+        topLeft: '\u259B', // ▛ TL+TR+BL (missing BR)
+        topRight: '\u259C', // ▜ TL+TR+BR (missing BL)
+        bottomLeft: '\u2599', // ▙ TL+BL+BR (missing TR)
+        bottomRight: '\u259F', // ▟ TR+BL+BR (missing TL)
+    },
+    'full-cell': {
+        topLeft: '\u2588', topRight: '\u2588', bottomLeft: '\u2588', bottomRight: '\u2588',
+    },
 };
 export function renderBorder(buffer, box, style) {
     if (style.borderStyle === 'none')
         return;
+    const blockEdges = BLOCK_EDGES[style.borderStyle];
+    if (blockEdges) {
+        renderBlockBorder(buffer, box, style, blockEdges);
+        return;
+    }
     const chars = BORDER_SETS[style.borderStyle];
     if (!chars)
         return;
@@ -16,21 +100,25 @@ export function renderBorder(buffer, box, style) {
     const right = style.borderRight;
     const bottom = style.borderBottom;
     const left = style.borderLeft;
-    // Corners (only where two adjacent sides meet)
-    if (top && left)
-        buffer.setCell(x, y, { char: chars.topLeft, fg });
-    if (top && right)
-        buffer.setCell(x + width - 1, y, { char: chars.topRight, fg });
-    if (bottom && left)
-        buffer.setCell(x, y + height - 1, { char: chars.bottomLeft, fg });
-    if (bottom && right)
-        buffer.setCell(x + width - 1, y + height - 1, { char: chars.bottomRight, fg });
+    // Corners — merge into T-junctions or crosses when overlapping a sibling's border
+    if (top && left) {
+        buffer.setCell(x, y, { char: mergeGlyph(buffer, x, y, RIGHT | DOWN, chars), fg });
+    }
+    if (top && right) {
+        buffer.setCell(x + width - 1, y, { char: mergeGlyph(buffer, x + width - 1, y, LEFT | DOWN, chars), fg });
+    }
+    if (bottom && left) {
+        buffer.setCell(x, y + height - 1, { char: mergeGlyph(buffer, x, y + height - 1, UP | RIGHT, chars), fg });
+    }
+    if (bottom && right) {
+        buffer.setCell(x + width - 1, y + height - 1, { char: mergeGlyph(buffer, x + width - 1, y + height - 1, UP | LEFT, chars), fg });
+    }
     // Top edge
     if (top) {
         const startCol = left ? x + 1 : x;
         const endCol = right ? x + width - 1 : x + width;
         for (let col = startCol; col < endCol; col++) {
-            buffer.setCell(col, y, { char: chars.horizontal, fg });
+            buffer.setCell(col, y, { char: mergeGlyph(buffer, col, y, LEFT | RIGHT, chars), fg });
         }
     }
     // Bottom edge
@@ -38,7 +126,7 @@ export function renderBorder(buffer, box, style) {
         const startCol = left ? x + 1 : x;
         const endCol = right ? x + width - 1 : x + width;
         for (let col = startCol; col < endCol; col++) {
-            buffer.setCell(col, y + height - 1, { char: chars.horizontal, fg });
+            buffer.setCell(col, y + height - 1, { char: mergeGlyph(buffer, col, y + height - 1, LEFT | RIGHT, chars), fg });
         }
     }
     // Left edge
@@ -46,7 +134,7 @@ export function renderBorder(buffer, box, style) {
         const startRow = top ? y + 1 : y;
         const endRow = bottom ? y + height - 1 : y + height;
         for (let row = startRow; row < endRow; row++) {
-            buffer.setCell(x, row, { char: chars.vertical, fg });
+            buffer.setCell(x, row, { char: mergeGlyph(buffer, x, row, UP | DOWN, chars), fg });
         }
     }
     // Right edge
@@ -54,7 +142,68 @@ export function renderBorder(buffer, box, style) {
         const startRow = top ? y + 1 : y;
         const endRow = bottom ? y + height - 1 : y + height;
         for (let row = startRow; row < endRow; row++) {
-            buffer.setCell(x + width - 1, row, { char: chars.vertical, fg });
+            buffer.setCell(x + width - 1, row, { char: mergeGlyph(buffer, x + width - 1, row, UP | DOWN, chars), fg });
+        }
+    }
+}
+/**
+ * Render a block-character border (eighth-cell-*, half-cell-*, full-cell).
+ * Corner cells are owned by the axis selected via border-corner: 'h' (default top/bottom),
+ * 'v' (sides), or 'none' (corners blank).
+ */
+function renderBlockBorder(buffer, box, style, edges) {
+    const fg = style.borderColor !== 'default' ? style.borderColor : undefined;
+    const { x, y, width, height } = box;
+    const top = style.borderTop;
+    const right = style.borderRight;
+    const bottom = style.borderBottom;
+    const left = style.borderLeft;
+    const corner = style.borderCorner;
+    // Corner ownership controls how far horizontal vs vertical edges extend.
+    // 'h' = top/bottom strokes extend through the full row, sides indent by 1
+    // 'v' = sides extend through the full column, top/bottom indent by 1
+    // 'none' = corners blank (or filled by dedicated corner glyphs, if available)
+    //
+    // eighth-cell-outer defaults to 'h' when 'none' is specified — there's no
+    // corner glyph in Block Elements for 1/8-thick L pieces, and with no
+    // extension the corners would be visibly missing from the outer frame.
+    const effectiveCorner = (corner === 'none' && style.borderStyle === 'eighth-cell-outer') ? 'h' : corner;
+    const hOwnsCorners = effectiveCorner === 'h';
+    const vOwnsCorners = effectiveCorner === 'v';
+    const corners = (effectiveCorner === 'none') ? BLOCK_CORNERS[style.borderStyle] : undefined;
+    const horizStart = (left && !hOwnsCorners) ? x + 1 : x;
+    const horizEnd = (right && !hOwnsCorners) ? x + width - 1 : x + width;
+    const vertStart = (top && !vOwnsCorners) ? y + 1 : y;
+    const vertEnd = (bottom && !vOwnsCorners) ? y + height - 1 : y + height;
+    // Place corner glyphs first so edge-paint loops don't overwrite them.
+    if (corners) {
+        if (top && left)
+            buffer.setCell(x, y, { char: corners.topLeft, fg });
+        if (top && right)
+            buffer.setCell(x + width - 1, y, { char: corners.topRight, fg });
+        if (bottom && left)
+            buffer.setCell(x, y + height - 1, { char: corners.bottomLeft, fg });
+        if (bottom && right)
+            buffer.setCell(x + width - 1, y + height - 1, { char: corners.bottomRight, fg });
+    }
+    if (top) {
+        for (let col = horizStart; col < horizEnd; col++) {
+            buffer.setCell(col, y, { char: edges.top, fg });
+        }
+    }
+    if (bottom) {
+        for (let col = horizStart; col < horizEnd; col++) {
+            buffer.setCell(col, y + height - 1, { char: edges.bottom, fg });
+        }
+    }
+    if (left) {
+        for (let row = vertStart; row < vertEnd; row++) {
+            buffer.setCell(x, row, { char: edges.left, fg });
+        }
+    }
+    if (right) {
+        for (let row = vertStart; row < vertEnd; row++) {
+            buffer.setCell(x + width - 1, row, { char: edges.right, fg });
         }
     }
 }

package/dist/src/render/buffer.d.ts

@@ -7,6 +7,7 @@ export interface Cell {
     underline: boolean;
     strikethrough: boolean;
     dim: boolean;
+    inverse: boolean;
     hyperlink?: string;
 }
 export declare class CellBuffer {

package/dist/src/render/buffer.js

@@ -1,7 +1,7 @@
 const EMPTY_CELL = {
     char: ' ', fg: 'default', bg: 'default',
     bold: false, italic: false, underline: false,
-    strikethrough: false, dim: false,
+    strikethrough: false, dim: false, inverse: false,
 };
 export class CellBuffer {
     width;
@@ -37,6 +37,7 @@ export class CellBuffer {
             underline: cell.underline ?? existing.underline,
             strikethrough: cell.strikethrough ?? existing.strikethrough,
             dim: cell.dim ?? existing.dim,
+            inverse: cell.inverse ?? existing.inverse,
             hyperlink: cell.hyperlink ?? existing.hyperlink,
         };
     }
@@ -51,6 +52,7 @@ export class CellBuffer {
                 underline: style?.underline,
                 strikethrough: style?.strikethrough,
                 dim: style?.dim,
+                inverse: style?.inverse,
             });
         }
     }
@@ -66,5 +68,6 @@ export function cellsEqual(a, b) {
     return a.char === b.char && a.fg === b.fg && a.bg === b.bg
         && a.bold === b.bold && a.italic === b.italic
         && a.underline === b.underline && a.strikethrough === b.strikethrough
-        && a.dim === b.dim && a.hyperlink === b.hyperlink;
+        && a.dim === b.dim && a.inverse === b.inverse
+        && a.hyperlink === b.hyperlink;
 }

package/dist/src/render/clock.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Clock seam for time-driven rendering (animations, transitions, and the
+ * scrollbar fade). Abstracts both the time source and the frame
+ * scheduler so tests can advance time and fire ticks deterministically
+ * instead of depending on `Date.now()` and real `setInterval`.
+ */
+export type ClockTimer = unknown;
+export interface Clock {
+    now(): number;
+    setInterval(fn: () => void, ms: number): ClockTimer;
+    clearInterval(timer: ClockTimer): void;
+}
+/** The real clock: wall time and the platform timer. */
+export declare const systemClock: Clock;
+/** Wrap a bare time function in a Clock backed by the real scheduler. */
+export declare function clockFromNow(now: () => number): Clock;
+/**
+ * A controllable clock for tests: set the time directly, or `advance`
+ * it, which fires any registered intervals at each tick they cross.
+ */
+export declare class TestClock implements Clock {
+    private time;
+    private timers;
+    constructor(start?: number);
+    now(): number;
+    setInterval(fn: () => void, ms: number): ClockTimer;
+    clearInterval(timer: ClockTimer): void;
+    /** Jump to an absolute time without firing intervals. */
+    setTime(time: number): void;
+    /** Advance by `ms`, firing each interval at every tick it crosses. */
+    advance(ms: number): void;
+    /** Timers registered right now (for assertions). */
+    get activeTimers(): number;
+    private nextTimerBefore;
+}

package/dist/src/render/clock.js

@@ -0,0 +1,67 @@
+/**
+ * Clock seam for time-driven rendering (animations, transitions, and the
+ * scrollbar fade). Abstracts both the time source and the frame
+ * scheduler so tests can advance time and fire ticks deterministically
+ * instead of depending on `Date.now()` and real `setInterval`.
+ */
+/** The real clock: wall time and the platform timer. */
+export const systemClock = {
+    now: () => Date.now(),
+    setInterval: (fn, ms) => setInterval(fn, ms),
+    clearInterval: (timer) => clearInterval(timer),
+};
+/** Wrap a bare time function in a Clock backed by the real scheduler. */
+export function clockFromNow(now) {
+    return { now, setInterval: systemClock.setInterval, clearInterval: systemClock.clearInterval };
+}
+/**
+ * A controllable clock for tests: set the time directly, or `advance`
+ * it, which fires any registered intervals at each tick they cross.
+ */
+export class TestClock {
+    time;
+    timers = new Set();
+    constructor(start = 0) {
+        this.time = start;
+    }
+    now() {
+        return this.time;
+    }
+    setInterval(fn, ms) {
+        const timer = { fn, ms, next: this.time + ms };
+        this.timers.add(timer);
+        return timer;
+    }
+    clearInterval(timer) {
+        this.timers.delete(timer);
+    }
+    /** Jump to an absolute time without firing intervals. */
+    setTime(time) {
+        this.time = time;
+    }
+    /** Advance by `ms`, firing each interval at every tick it crosses. */
+    advance(ms) {
+        const target = this.time + ms;
+        while (true) {
+            const due = this.nextTimerBefore(target);
+            if (!due)
+                break;
+            this.time = due.next;
+            due.next += due.ms;
+            due.fn();
+        }
+        this.time = target;
+    }
+    /** Timers registered right now (for assertions). */
+    get activeTimers() {
+        return this.timers.size;
+    }
+    nextTimerBefore(target) {
+        let earliest = null;
+        for (const timer of this.timers) {
+            if (timer.next <= target && (!earliest || timer.next < earliest.next))
+                earliest = timer;
+        }
+        return earliest;
+    }
+}

package/dist/src/render/color-depth.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Colour quantization for terminals without truecolor: hex → the xterm
+ * 256-colour palette, or the nearest of the 16 base colours.
+ */
+/** Map #rrggbb to the nearest xterm 256-palette index (cube or grey ramp). */
+export declare function quantizeTo256(hex: string): number;
+/** Map #rrggbb to the nearest of the 16 base colour names. */
+export declare function quantizeTo16(hex: string): string;