@askdkc/dsh-cli 0.11.3

package/lib/types/ink/measure-element.d.ts

@@ -0,0 +1,19 @@
+import type { DOMElement } from './dom.js';
+type Output = {
+    /**
+     * Element width.
+     */
+    width: number;
+    /**
+     * Element height.
+     */
+    height: number;
+};
+/**
+ * Measure the rendered dimensions of a Box element.
+ * @param node - the DOM element to measure.
+ * @returns the element's computed width and height, or zeros before layout.
+ */
+declare const measureElement: (node: DOMElement) => Output;
+export default measureElement;
+//# sourceMappingURL=measure-element.d.ts.map

package/lib/types/ink/measure-element.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"measure-element.d.ts","sourceRoot":"","sources":["../../../src/ink/measure-element.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,UAAU,CAAA;AAE1C,KAAK,MAAM,GAAG;IACZ;;OAEG;IACH,KAAK,EAAE,MAAM,CAAA;IAEb;;OAEG;IACH,MAAM,EAAE,MAAM,CAAA;CACf,CAAA;AAED;;;;GAIG;AACH,QAAA,MAAM,cAAc,GAAI,MAAM,UAAU,KAAG,MAGzC,CAAA;AAEF,eAAe,cAAc,CAAA"}

package/lib/types/ink/measure-element.js

@@ -0,0 +1,10 @@
+/**
+ * Measure the rendered dimensions of a Box element.
+ * @param node - the DOM element to measure.
+ * @returns the element's computed width and height, or zeros before layout.
+ */
+const measureElement = (node) => ({
+    width: node.yogaNode?.getComputedWidth() ?? 0,
+    height: node.yogaNode?.getComputedHeight() ?? 0,
+});
+export default measureElement;

package/lib/types/ink/measure-text.d.ts

@@ -0,0 +1,13 @@
+type Output = {
+    width: number;
+    height: number;
+};
+/**
+ * Measure wrapped text dimensions in a single pass.
+ * @param text - the text to measure.
+ * @param maxWidth - the wrap width in columns; non-positive or infinite disables wrapping.
+ * @returns the widest line width and the number of visual lines.
+ */
+declare function measureText(text: string, maxWidth: number): Output;
+export default measureText;
+//# sourceMappingURL=measure-text.d.ts.map

package/lib/types/ink/measure-text.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"measure-text.d.ts","sourceRoot":"","sources":["../../../src/ink/measure-text.ts"],"names":[],"mappings":"AAEA,KAAK,MAAM,GAAG;IACZ,KAAK,EAAE,MAAM,CAAA;IACb,MAAM,EAAE,MAAM,CAAA;CACf,CAAA;AAED;;;;;GAKG;AACH,iBAAS,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAkC3D;AAED,eAAe,WAAW,CAAA"}

package/lib/types/ink/measure-text.js

@@ -0,0 +1,38 @@
+import { lineWidth } from './line-width-cache.js';
+/**
+ * Measure wrapped text dimensions in a single pass.
+ * @param text - the text to measure.
+ * @param maxWidth - the wrap width in columns; non-positive or infinite disables wrapping.
+ * @returns the widest line width and the number of visual lines.
+ */
+function measureText(text, maxWidth) {
+    if (text.length === 0) {
+        return {
+            width: 0,
+            height: 0,
+        };
+    }
+    // Infinite or non-positive width means no wrapping — each line is one visual line.
+    // Must check before the loop since Math.ceil(w / Infinity) = 0.
+    const noWrap = maxWidth <= 0 || !Number.isFinite(maxWidth);
+    let height = 0;
+    let width = 0;
+    let start = 0;
+    while (start <= text.length) {
+        const end = text.indexOf('\n', start);
+        const line = end === -1 ? text.substring(start) : text.substring(start, end);
+        const w = lineWidth(line);
+        width = Math.max(width, w);
+        if (noWrap) {
+            height++;
+        }
+        else {
+            height += w === 0 ? 1 : Math.ceil(w / maxWidth);
+        }
+        if (end === -1)
+            break;
+        start = end + 1;
+    }
+    return { width, height };
+}
+export default measureText;

package/lib/types/ink/node-cache.d.ts

@@ -0,0 +1,54 @@
+import type { DOMElement } from './dom.js';
+import type { Rectangle } from './layout/geometry.js';
+/**
+ * Cached layout bounds for each rendered node (used for blit + clearing).
+ * `top` is the yoga-local getComputedTop() — stored so ScrollBox viewport
+ * culling can skip yoga reads for clean children whose position hasn't
+ * shifted (O(dirty) instead of O(mounted) first-pass).
+ */
+export type CachedLayout = {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    top?: number;
+    /** Effective background color (own ?? inherited) at the last render.
+     *  Renderer compares it per frame so a background change refuses the
+     *  prevScreen blit — children would otherwise resurrect the stale color
+     *  (stuck hover highlight). */
+    bg?: string;
+    /** Whether the node fills its whole rect (own backgroundColor or
+     *  `opaque`). Only such an absolute node "covers" cells a previous
+     *  overlay vacated; a transparent one leaves them stale (see
+     *  hasOverlayVacatedCells). */
+    opaque?: boolean;
+};
+/** Layout bounds cached per rendered node, used for blitting and clearing. */
+export declare const nodeCache: WeakMap<DOMElement, CachedLayout>;
+/** Current prepared text only: scrolling changes its position, not its lines.
+ * Weak keys release unmounted nodes; mutations discard the previous version. */
+export declare const textPaintCache: WeakMap<DOMElement, {
+    maxWidth: number;
+    background: string | undefined;
+    paddingLeft: number;
+    paddingTop: number;
+    text: string;
+    lines: readonly string[];
+    softWrap: boolean[] | undefined;
+}>;
+/** Rects of removed children that need clearing on next render */
+export declare const pendingClears: WeakMap<DOMElement, Rectangle[]>;
+/**
+ * Register a removed child's rect for clearing on the next render, and
+ * flag the next frame when the removed node was absolutely positioned.
+ * @param parent - the parent whose removed child rect to record.
+ * @param rect - the removed child's last known bounds.
+ * @param isAbsolute - whether the removed child was absolutely positioned; disables blit next frame.
+ */
+export declare function addPendingClear(parent: DOMElement, rect: Rectangle, isAbsolute: boolean): void;
+/**
+ * Read and clear the absolute-removal flag set by addPendingClear.
+ * @returns whether an absolutely positioned node was removed since the last render.
+ */
+export declare function consumeAbsoluteRemovedFlag(): boolean;
+//# sourceMappingURL=node-cache.d.ts.map

package/lib/types/ink/node-cache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"node-cache.d.ts","sourceRoot":"","sources":["../../../src/ink/node-cache.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,UAAU,CAAA;AAC1C,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAA;AAErD;;;;;GAKG;AACH,MAAM,MAAM,YAAY,GAAG;IACzB,CAAC,EAAE,MAAM,CAAA;IACT,CAAC,EAAE,MAAM,CAAA;IACT,KAAK,EAAE,MAAM,CAAA;IACb,MAAM,EAAE,MAAM,CAAA;IACd,GAAG,CAAC,EAAE,MAAM,CAAA;IACZ;;;mCAG+B;IAC/B,EAAE,CAAC,EAAE,MAAM,CAAA;IACX;;;mCAG+B;IAC/B,MAAM,CAAC,EAAE,OAAO,CAAA;CACjB,CAAA;AAED,8EAA8E;AAC9E,eAAO,MAAM,SAAS,mCAA0C,CAAA;AAEhE;gFACgF;AAChF,eAAO,MAAM,cAAc;cACf,MAAM;gBACJ,MAAM,GAAG,SAAS;iBACjB,MAAM;gBACP,MAAM;UACZ,MAAM;WACL,SAAS,MAAM,EAAE;cACd,OAAO,EAAE,GAAG,SAAS;EAC7B,CAAA;AAEJ,kEAAkE;AAClE,eAAO,MAAM,aAAa,kCAAyC,CAAA;AAanE;;;;;;GAMG;AACH,wBAAgB,eAAe,CAC7B,MAAM,EAAE,UAAU,EAClB,IAAI,EAAE,SAAS,EACf,UAAU,EAAE,OAAO,GAClB,IAAI,CAUN;AAED;;;GAGG;AACH,wBAAgB,0BAA0B,IAAI,OAAO,CAIpD"}

package/lib/types/ink/node-cache.js

@@ -0,0 +1,45 @@
+/** Layout bounds cached per rendered node, used for blitting and clearing. */
+export const nodeCache = new WeakMap();
+/** Current prepared text only: scrolling changes its position, not its lines.
+ * Weak keys release unmounted nodes; mutations discard the previous version. */
+export const textPaintCache = new WeakMap();
+/** Rects of removed children that need clearing on next render */
+export const pendingClears = new WeakMap();
+/**
+ * Set when a pendingClear is added for an absolute-positioned node.
+ * Signals renderer to disable blit for the next frame: the removed node
+ * may have painted over non-siblings (e.g. an overlay over a ScrollBox
+ * earlier in tree order), so their blits from prevScreen would restore
+ * the overlay's pixels. Normal-flow removals are already handled by
+ * hasRemovedChild at the parent level; only absolute positioning paints
+ * cross-subtree. Reset at the start of each render.
+ */
+let absoluteNodeRemoved = false;
+/**
+ * Register a removed child's rect for clearing on the next render, and
+ * flag the next frame when the removed node was absolutely positioned.
+ * @param parent - the parent whose removed child rect to record.
+ * @param rect - the removed child's last known bounds.
+ * @param isAbsolute - whether the removed child was absolutely positioned; disables blit next frame.
+ */
+export function addPendingClear(parent, rect, isAbsolute) {
+    const existing = pendingClears.get(parent);
+    if (existing) {
+        existing.push(rect);
+    }
+    else {
+        pendingClears.set(parent, [rect]);
+    }
+    if (isAbsolute) {
+        absoluteNodeRemoved = true;
+    }
+}
+/**
+ * Read and clear the absolute-removal flag set by addPendingClear.
+ * @returns whether an absolutely positioned node was removed since the last render.
+ */
+export function consumeAbsoluteRemovedFlag() {
+    const had = absoluteNodeRemoved;
+    absoluteNodeRemoved = false;
+    return had;
+}

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

@@ -0,0 +1,18 @@
+import type { Diff } from './frame.js';
+/**
+ * Optimize a diff by applying all optimization rules in a single pass.
+ * This reduces the number of patches that need to be written to the terminal.
+ *
+ * Rules applied:
+ * - Remove empty stdout patches
+ * - Merge consecutive cursorMove patches
+ * - Remove no-op cursorMove (0,0) patches
+ * - Concat adjacent style patches (transition diffs — can't drop either)
+ * - Dedupe consecutive hyperlinks with same URI
+ * - Cancel cursor hide/show pairs
+ * - Remove clear patches with count 0
+ * @param diff - the patch list produced by the frame diff.
+ * @returns the optimized patch list, with no-ops removed and adjacent patches merged.
+ */
+export declare function optimize(diff: Diff): Diff;
+//# sourceMappingURL=optimizer.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"optimizer.d.ts","sourceRoot":"","sources":["../../../src/ink/optimizer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,YAAY,CAAA;AAEtC;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,QAAQ,CAAC,IAAI,EAAE,IAAI,GAAG,IAAI,CA6EzC"}

package/lib/types/ink/optimizer.js

@@ -0,0 +1,83 @@
+/**
+ * Optimize a diff by applying all optimization rules in a single pass.
+ * This reduces the number of patches that need to be written to the terminal.
+ *
+ * Rules applied:
+ * - Remove empty stdout patches
+ * - Merge consecutive cursorMove patches
+ * - Remove no-op cursorMove (0,0) patches
+ * - Concat adjacent style patches (transition diffs — can't drop either)
+ * - Dedupe consecutive hyperlinks with same URI
+ * - Cancel cursor hide/show pairs
+ * - Remove clear patches with count 0
+ * @param diff - the patch list produced by the frame diff.
+ * @returns the optimized patch list, with no-ops removed and adjacent patches merged.
+ */
+export function optimize(diff) {
+    if (diff.length <= 1) {
+        return diff;
+    }
+    const result = [];
+    let len = 0;
+    for (const patch of diff) {
+        const type = patch.type;
+        // Skip no-ops
+        if (type === 'stdout') {
+            if (patch.content === '')
+                continue;
+        }
+        else if (type === 'cursorMove') {
+            if (patch.x === 0 && patch.y === 0)
+                continue;
+        }
+        else if (type === 'clear') {
+            if (patch.count === 0)
+                continue;
+        }
+        // Try to merge with previous patch
+        if (len > 0) {
+            const lastIdx = len - 1;
+            const last = result[lastIdx];
+            const lastType = last.type;
+            // Merge consecutive cursorMove
+            if (type === 'cursorMove' && lastType === 'cursorMove') {
+                result[lastIdx] = {
+                    type: 'cursorMove',
+                    x: last.x + patch.x,
+                    y: last.y + patch.y,
+                };
+                continue;
+            }
+            // Collapse consecutive cursorTo (only the last one matters)
+            if (type === 'cursorTo' && lastType === 'cursorTo') {
+                result[lastIdx] = patch;
+                continue;
+            }
+            // Concat adjacent style patches. styleStr is a transition diff
+            // (computed by diffAnsiCodes(from, to)), not a setter — dropping
+            // the first is only sound if its undo-codes are a subset of the
+            // second's, which is NOT guaranteed. e.g. [\e[49m, \e[2m]: dropping
+            // the bg reset leaks it into the next \e[2J/\e[2K via BCE.
+            if (type === 'styleStr' && lastType === 'styleStr') {
+                result[lastIdx] = { type: 'styleStr', str: last.str + patch.str };
+                continue;
+            }
+            // Dedupe hyperlinks
+            if (type === 'hyperlink' &&
+                lastType === 'hyperlink' &&
+                patch.uri === last.uri) {
+                continue;
+            }
+            // Cancel cursor hide/show pairs
+            if ((type === 'cursorShow' && lastType === 'cursorHide') ||
+                (type === 'cursorHide' && lastType === 'cursorShow')) {
+                result.pop();
+                len--;
+                continue;
+            }
+        }
+        result.push(patch);
+        len++;
+    }
+    return result;
+}

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

@@ -0,0 +1,300 @@
+import { type Rectangle } from './layout/geometry.js';
+import { type Screen, type StylePool } from './screen.js';
+import type { DOMElement } from './dom.js';
+import { type TerminalImagePlacement, type TerminalImageSource } from './terminal-image.js';
+/**
+ * A grapheme cluster with precomputed terminal width, styleId, and hyperlink.
+ * Built once per unique line (cached via charCache), so the per-char hot loop
+ * is just property reads + setCellAt — no stringWidth, no style interning,
+ * no hyperlink extraction per frame.
+ *
+ * styleId is safe to cache: StylePool is session-lived (never reset).
+ * hyperlink is stored as a string (not interned ID) since hyperlinkPool
+ * resets every 5 min; setCellAt interns it per-frame (cheap Map.get).
+ */
+type ClusteredChar = {
+    value: string;
+    width: number;
+    styleId: number;
+    hyperlink: string | undefined;
+};
+/**
+ * Bounded cache of line → clustered characters. Enforces all three guards
+ * (line-length threshold, entry count, byte budget) at insertion time, so
+ * no caller can accidentally grow it unboundedly.
+ */
+export declare class CharCache {
+    /**
+     * LRU of line → clustered characters. A full clear on overflow
+     * (the original behavior) thrashes during long-session streaming: the
+     * mounted window's static lines alone approach the char budget, so the
+     * streaming row's per-frame new keys tip it over every frame or two,
+     * nuking the cache and forcing ~1800 line re-tokenizations per frame
+     * (measured ~100ms/frame at a 175-row session). Evicting oldest-first
+     * keeps the hot mounted lines resident while streaming churn falls out
+     * the back. Recency is refreshed on hit (delete + re-insert) so lines
+     * read every frame are never evicted by one-shot churn.
+     */
+    private map;
+    private chars;
+    /**
+     * Return the cached clustered characters for a line, if present, and
+     * refresh the entry's recency.
+     * @param line - the line to look up.
+     * @returns the cached characters, or undefined on a miss.
+     */
+    get(line: string): ClusteredChar[] | undefined;
+    /**
+     * Cache clustered characters for a line, enforcing the cache bounds by
+     * evicting least-recently-used entries (never a full clear).
+     * @param line - the line key.
+     * @param characters - the clustered characters to cache.
+     */
+    set(line: string, characters: ClusteredChar[]): void;
+    /** Retained-key character total, exposed for diagnostics/tests. */
+    get retainedChars(): number;
+    /** Number of cached line entries. */
+    get size(): number;
+}
+/**
+ * Collects write/blit/clear/clip operations from the render tree, then
+ * applies them to a Screen buffer in get(). The Screen is what gets
+ * diffed against the previous frame to produce terminal updates.
+ */
+type Options = {
+    width: number;
+    height: number;
+    stylePool: StylePool;
+    /**
+     * Screen to render into. Will be reset before use.
+     * For double-buffering, pass a reusable screen. Otherwise create a new one.
+     */
+    screen: Screen;
+    /** Paint image fallbacks as blank backing cells and collect placements. */
+    terminalImages?: boolean;
+    imageReady?: (placement: TerminalImagePlacement) => boolean;
+    /**
+     * True when the active protocol paints rasters OVER the cell grid (Sixel)
+     * instead of behind it (Kitty). Image-owned cells must then carry the
+     * surface background: the raster covers them anyway, and terminal-default
+     * blanks would show as black holes wherever a raster fails to cover a cell
+     * (aspect rounding, suppressed/occluded placements).
+     */
+    opaqueImageBacking?: boolean;
+    /** Image requests from the diff baseline, reused by clean subtree blits. */
+    previousImages?: readonly TerminalImagePlacement[];
+};
+/** A queued paint operation: write, clip, unclip, blit, clear, shade, noSelect, or shift. */
+export type Operation = WriteOperation | ClipOperation | UnclipOperation | BlitOperation | ClearOperation | ShadeOperation | NoSelectOperation | ShiftOperation;
+/**
+ * Restyle the cells already in the region at this point of the paint
+ * order: a modal layer's backdrop. Applied in sequence like a write, so
+ * everything painted earlier (the transcript beneath) is shaded and
+ * everything painted later (the card on top) is not.
+ */
+type ShadeOperation = {
+    type: 'shade';
+    region: Rectangle;
+};
+type WriteOperation = {
+    type: 'write';
+    x: number;
+    y: number;
+    text: string;
+    /** Prepared physical lines, reused by unchanged Text nodes across scrolls. */
+    lines?: readonly string[];
+    /**
+     * Per-line soft-wrap flags, parallel to text.split('\n'). softWrap[i]=true
+     * means line i is a continuation of line i-1 (the `\n` before it was
+     * inserted by word-wrap, not in the source). Index 0 is always false.
+     * Undefined means the producer didn't track wrapping (e.g. fills,
+     * raw-ansi) — the screen's per-row bitmap is left untouched.
+     */
+    softWrap?: boolean[];
+};
+type ClipOperation = {
+    type: 'clip';
+    clip: Clip;
+};
+/** A rectangular clip region; undefined on an axis means unbounded. */
+export type Clip = {
+    x1: number | undefined;
+    x2: number | undefined;
+    y1: number | undefined;
+    y2: number | undefined;
+};
+type UnclipOperation = {
+    type: 'unclip';
+};
+type BlitOperation = {
+    type: 'blit';
+    src: Screen;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+};
+type ShiftOperation = {
+    type: 'shift';
+    top: number;
+    bottom: number;
+    n: number;
+};
+type ClearOperation = {
+    type: 'clear';
+    region: Rectangle;
+    /**
+     * Set when the clear is for an absolute-positioned node's old bounds.
+     * Absolute nodes overlay normal-flow siblings, so their stale paint is
+     * what an earlier sibling's clean-subtree blit wrongly restores from
+     * prevScreen. Normal-flow siblings' clears don't have this problem —
+     * their old position can't have been painted on top of a sibling.
+     */
+    fromAbsolute?: boolean;
+};
+type NoSelectOperation = {
+    type: 'noSelect';
+    region: Rectangle;
+};
+/**
+ * Collects write/blit/clear/clip operations from the render tree, then
+ * applies them to a Screen buffer in get(). The Screen is what gets
+ * diffed against the previous frame to produce terminal updates.
+ */
+export default class Output {
+    /** Screen width in columns. */
+    width: number;
+    /** Screen height in rows. */
+    height: number;
+    private readonly stylePool;
+    private screen;
+    terminalImagesEnabled: boolean;
+    opaqueImageBacking: boolean;
+    private imageReady;
+    private readonly operations;
+    private readonly imagePlacements;
+    private readonly imageNodes;
+    private readonly imageBackingEnds;
+    private readonly imageClips;
+    private imageDecodedBytes;
+    private previousImages;
+    private charCache;
+    /**
+     * LRU of line → recorded packed cell run, mirroring charCache's bounds.
+     * The main-screen architecture repaints every settled line each frame;
+     * the recorded run replays as raw two-word stores (no interning, no
+     * packing, no guard branches) — the long-session streaming fix. Runs are
+     * validated against the screen they were interned on and die with it.
+     */
+    private packedLines;
+    private packedChars;
+    /** Stable owner handle passed to writeLineToScreen (no per-call closure). */
+    private readonly packedOwner;
+    /** Insert into the packed-lines LRU, evicting oldest entries on budget. */
+    private setPackedLine;
+    /**
+     * Streaming-tail slot, shared by every writeLineToScreen call of this
+     * Output (only one line grows per frame during streaming). Survives reset()
+     * like charCache - it is keyed by strict line extension, so stale entries
+     * can never produce a wrong hit.
+     */
+    private streamingSlot;
+    constructor(options: Options);
+    /**
+     * Reuse this Output for a new frame. Zeroes the screen buffer, clears
+     * the operation list (backing storage is retained), and caps charCache
+     * growth. Preserving charCache across frames is the main win — most
+     * lines don't change between renders, so tokenize + grapheme clustering
+     * becomes a cache hit.
+     * @param width - the new screen width in columns.
+     * @param height - the new screen height in rows.
+     * @param screen - the screen buffer to render into.
+     */
+    reset(width: number, height: number, screen: Screen, terminalImages?: boolean, previousImages?: readonly TerminalImagePlacement[], imageReady?: (placement: TerminalImagePlacement) => boolean, opaqueImageBacking?: boolean): void;
+    /**
+     * Copy cells from a source screen region (blit = block image transfer).
+     * @param src - the source screen.
+     * @param x - the destination left column.
+     * @param y - the destination top row.
+     * @param width - the region width in columns.
+     * @param height - the region height in rows.
+     */
+    blit(src: Screen, x: number, y: number, width: number, height: number): void;
+    /**
+     * Shift full-width rows within [top, bottom] by n. n > 0 = up. Mirrors
+     * what DECSTBM + SU/SD does to the terminal. Paired with blit() to reuse
+     * prevScreen content during pure scroll, avoiding full child re-render.
+     * @param top - the first row of the shift region.
+     * @param bottom - the last row of the shift region.
+     * @param n - the shift amount; positive moves content up.
+     */
+    shift(top: number, bottom: number, n: number): void;
+    /**
+     * Clear a region by writing empty cells. Used when a node shrinks to
+     * ensure stale content from the previous frame is removed.
+     * @param region - the region to clear.
+     * @param fromAbsolute - whether the clear is for an absolute-positioned node's old bounds.
+     */
+    clear(region: Rectangle, fromAbsolute?: boolean): void;
+    /**
+     * Shade the cells painted so far inside `region` (see ShadeOperation).
+     * Idempotent per cell, so a clean subtree blitted back from prevScreen
+     * with last frame's shade is not shaded twice.
+     * @param region - the backdrop node's rect.
+     */
+    shade(region: Rectangle): void;
+    /**
+     * Mark a region as non-selectable (excluded from fullscreen text
+     * selection copy + highlight). Used by <NoSelect> to fence off
+     * gutters (line numbers, diff sigils). Applied AFTER blit/write so
+     * the mark wins regardless of what's blitted into the region.
+     * @param region - the region to mark.
+     */
+    noSelect(region: Rectangle): void;
+    /**
+     * Record a fully visible, frame-budgeted image request. Rejected placements
+     * keep their cell fallback, so terminal graphics never escape a clip or
+     * create an unbounded decoded-data upload burst.
+     */
+    image(node: DOMElement, x: number, y: number, columns: number, rows: number, source: TerminalImageSource, background?: string): boolean;
+    /**
+     * Reuse images inside a clean subtree whose cells came from prevScreen.
+     * Returns false when any former placement no longer fits this frame, so
+     * the painter can descend and restore that image's text fallback instead
+     * of blitting its old blank backing cells.
+     */
+    reuseImages(node: DOMElement): boolean;
+    /** Whether this node owned a terminal placement in the previous frame. */
+    hadPreviousImage(node: DOMElement): boolean;
+    /** Whether a baseline placement overlaps a screen region. */
+    hasPreviousImageInRegion(x: number, y: number, width: number, height: number): boolean;
+    /** Current frame's immutable-by-convention terminal image requests. */
+    getImages(): readonly TerminalImagePlacement[];
+    /** Pixel ownership is determined by paint order, not just final text values. */
+    imageBacking(node: DOMElement): void;
+    /**
+     * Queue a text write at a position, split across lines on newlines.
+     * @param x - the left column.
+     * @param y - the top row.
+     * @param text - the text to write.
+     * @param softWrap - per-line soft-wrap flags parallel to text.split('\n').
+     * @param lines - optional pre-split physical lines, exactly text.split('\n').
+     */
+    write(x: number, y: number, text: string, softWrap?: boolean[], lines?: readonly string[]): void;
+    /** Whether a rectangle can contribute cells under the current paint clip. */
+    isRectVisible(x: number, y: number, width: number, height: number): boolean;
+    /**
+     * Push a clip region; subsequent writes are restricted to it.
+     * @param clip - the clip region to apply.
+     */
+    clip(clip: Clip): void;
+    /** Pop the most recent clip region. */
+    unclip(): void;
+    /**
+     * Apply all queued operations to the screen buffer and return it.
+     * @returns the rendered screen, diffable against the previous frame.
+     */
+    get(): Screen;
+}
+export {};
+//# sourceMappingURL=output.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"output.d.ts","sourceRoot":"","sources":["../../../src/ink/output.ts"],"names":[],"mappings":"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"}