tinky 1.4.4 → 1.6.0

package/lib/core/cell-renderer.js

@@ -0,0 +1,60 @@
+import { renderNodeToOutput, renderNodeToScreenReaderOutput, } from "./render-node-to-output.js";
+import { Output } from "./output.js";
+import { CellOutput } from "./cell-output.js";
+/**
+ * Renderer that writes interactive output into a CellBuffer.
+ *
+ * Static output is still rendered as string output because it is emitted once
+ * and not updated incrementally.
+ *
+ * @param node - Root DOM node to render.
+ * @param buffer - Reusable destination buffer for the interactive frame.
+ * @param isScreenReaderEnabled - Enables screen-reader rendering path.
+ * @returns The rendered interactive frame and any static output emitted this pass.
+ */
+export const cellRenderer = (node, buffer, isScreenReaderEnabled) => {
+    if (!node.taffyNode) {
+        buffer.resize(0, 0);
+        buffer.clear();
+        return { buffer, outputHeight: 0, staticOutput: "" };
+    }
+    if (isScreenReaderEnabled) {
+        const output = renderNodeToScreenReaderOutput(node, {
+            skipStaticElements: true,
+        });
+        const outputHeight = output === "" ? 0 : output.split("\n").length;
+        let staticOutput = "";
+        if (node.staticNode) {
+            staticOutput = renderNodeToScreenReaderOutput(node.staticNode, {
+                skipStaticElements: false,
+            });
+        }
+        return {
+            buffer,
+            outputHeight,
+            staticOutput: staticOutput ? `${staticOutput}\n` : "",
+            screenReaderOutput: output,
+        };
+    }
+    const layout = node.taffyNode.tree.getLayout(node.taffyNode.id);
+    buffer.resize(layout.width, layout.height);
+    buffer.clear();
+    const output = new CellOutput(buffer);
+    renderNodeToOutput(node, output, { skipStaticElements: true });
+    let staticOutput;
+    if (node.staticNode?.taffyNode) {
+        const staticLayout = node.staticNode.taffyNode.tree.getLayout(node.staticNode.taffyNode.id);
+        staticOutput = new Output({
+            width: staticLayout.width,
+            height: staticLayout.height,
+        });
+        renderNodeToOutput(node.staticNode, staticOutput, {
+            skipStaticElements: false,
+        });
+    }
+    return {
+        buffer,
+        outputHeight: buffer.height,
+        staticOutput: staticOutput ? `${staticOutput.get().output}\n` : "",
+    };
+};

package/lib/core/incremental-rendering.d.ts

@@ -0,0 +1,43 @@
+/**
+ * User-facing configuration for incremental rendering.
+ *
+ * You can use this object form when you need to choose a strategy explicitly
+ * or disable incremental rendering without changing existing option shapes.
+ */
+export interface IncrementalRenderingConfig {
+    /**
+     * Master on/off switch for object mode.
+     *
+     * - `false`: disables incremental rendering, regardless of `strategy`.
+     * - `true` or omitted: enables incremental rendering and uses `strategy`.
+     */
+    enabled?: boolean;
+    /**
+     * Diff strategy used for interactive output updates.
+     *
+     * - `"line"`: compares line strings and redraws changed lines.
+     * - `"run"`: compares terminal cells and rewrites minimal changed runs.
+     *
+     * @defaultValue "run"
+     */
+    strategy?: "line" | "run";
+}
+/**
+ * Public option accepted by `render(..., { incrementalRendering })`.
+ */
+export type IncrementalRenderingOption = boolean | IncrementalRenderingConfig;
+/**
+ * Internal normalized strategy used inside the renderer.
+ */
+export type IncrementalRenderStrategy = "none" | "line" | "run";
+/**
+ * Normalizes user-facing incremental rendering options to an internal strategy.
+ *
+ * Resolution order:
+ * - `undefined` or `false` -> `"none"`
+ * - `true` -> `"run"`
+ * - `{ enabled: false }` -> `"none"`
+ * - `{ strategy: "line" }` -> `"line"`
+ * - `{ strategy: "run" }` or omitted strategy -> `"run"`
+ */
+export declare const normalizeIncrementalRendering: (value: IncrementalRenderingOption | undefined) => IncrementalRenderStrategy;

package/lib/core/incremental-rendering.js

@@ -0,0 +1,22 @@
+/**
+ * Normalizes user-facing incremental rendering options to an internal strategy.
+ *
+ * Resolution order:
+ * - `undefined` or `false` -> `"none"`
+ * - `true` -> `"run"`
+ * - `{ enabled: false }` -> `"none"`
+ * - `{ strategy: "line" }` -> `"line"`
+ * - `{ strategy: "run" }` or omitted strategy -> `"run"`
+ */
+export const normalizeIncrementalRendering = (value) => {
+    if (value === undefined || value === false) {
+        return "none";
+    }
+    if (value === true) {
+        return "run";
+    }
+    if (value.enabled === false) {
+        return "none";
+    }
+    return value.strategy ?? "run";
+};

package/lib/core/output.d.ts

@@ -1,9 +1,16 @@
 import { type OutputTransformer } from "./render-node-to-output.js";
 import { type Dimension } from "../utils/dimension.js";
+/**
+ * Options for writing text to an output target.
+ */
+export interface OutputWriteOptions {
+    /** Array of transformers to apply to each rendered line. */
+    transformers: OutputTransformer[];
+}
 /**
  * Represents a clipping rectangle.
  */
-interface Clip {
+export interface Clip {
     /** Left boundary (undefined for no limit). */
     x1: number | undefined;
     /** Right boundary (undefined for no limit). */
@@ -13,6 +20,14 @@ interface Clip {
     /** Bottom boundary (undefined for no limit). */
     y2: number | undefined;
 }
+/**
+ * Shared write/clip/unclip surface used by render traversal.
+ */
+export interface OutputLike {
+    write(x: number, y: number, text: string, options: OutputWriteOptions): void;
+    clip(clip: Clip): void;
+    unclip(): void;
+}
 /**
  * "Virtual" output class
  *
@@ -21,7 +36,7 @@ interface Clip {
  *
  * Used to generate the final output of all nodes before writing to stdout.
  */
-export declare class Output {
+export declare class Output implements OutputLike {
     width: number;
     height: number;
     private readonly operations;
@@ -39,9 +54,7 @@ export declare class Output {
      * @param text - The text to write.
      * @param options - Options containing transformers.
      */
-    write(x: number, y: number, text: string, options: {
-        transformers: OutputTransformer[];
-    }): void;
+    write(x: number, y: number, text: string, options: OutputWriteOptions): void;
     /**
      * Sets a clipping area for subsequent operations.
      *
@@ -62,4 +75,3 @@ export declare class Output {
         height: number;
     };
 }
-export {};

package/lib/core/output.js

@@ -33,7 +33,6 @@ export class Output {
      * @param options - Options containing transformers.
      */
     write(x, y, text, options) {
-        const { transformers } = options;
         if (!text) {
             return;
         }
@@ -42,7 +41,7 @@ export class Output {
             x,
             y,
             text,
-            transformers,
+            options,
         });
     }
     /**
@@ -73,6 +72,10 @@ export class Output {
         // Initialize output array with a specific set of rows, so that
         // margin/padding at the bottom is preserved
         const output = [];
+        // Tracks whether a cell was explicitly written this frame.
+        const touched = [];
+        // Preserves intentional trailing spaces produced by transformers.
+        const preserveTrailingSpace = [];
         for (let y = 0; y < this.height; y++) {
             const row = [];
             for (let x = 0; x < this.width; x++) {
@@ -83,7 +86,11 @@ export class Output {
                     styles: [],
                 });
             }
+            const rowTouched = new Array(this.width).fill(false);
+            const rowPreserve = new Array(this.width).fill(false);
             output.push(row);
+            touched.push(rowTouched);
+            preserveTrailingSpace.push(rowPreserve);
         }
         const clips = [];
         for (const operation of this.operations) {
@@ -94,9 +101,11 @@ export class Output {
                 clips.pop();
             }
             if (operation.type === "write") {
-                const { text, transformers } = operation;
+                const { text } = operation;
+                const { transformers } = operation.options;
                 let { x, y } = operation;
                 let lines = text.split("\n");
+                const preserveLineTrailingSpaces = transformers.length > 0;
                 const clip = clips.at(-1);
                 if (clip) {
                     const clipHorizontally = typeof clip.x1 === "number" && typeof clip.x2 === "number";
@@ -142,10 +151,13 @@ export class Output {
                 }
                 let offsetY = 0;
                 for (const [index, line] of lines.entries()) {
-                    const currentLine = output[y + offsetY];
+                    const rowIndex = y + offsetY;
+                    const currentLine = output[rowIndex];
+                    const touchedRow = touched[rowIndex];
+                    const preserveRow = preserveTrailingSpace[rowIndex];
                     // Line can be missing if `text` is taller than height of
                     // pre-initialized `this.output`
-                    if (!currentLine) {
+                    if (!currentLine || !touchedRow || !preserveRow) {
                         continue;
                     }
                     let transformedLine = line;
@@ -156,6 +168,8 @@ export class Output {
                     let offsetX = x;
                     for (const character of characters) {
                         currentLine[offsetX] = character;
+                        touchedRow[offsetX] = true;
+                        preserveRow[offsetX] = preserveLineTrailingSpaces;
                         // Determine printed width using string-width to align with measurement
                         const characterWidth = Math.max(1, stringWidth(character.value));
                         // For multi-column characters, clear following cells to avoid stray
@@ -168,6 +182,8 @@ export class Output {
                                     fullWidth: false,
                                     styles: character.styles,
                                 };
+                                touchedRow[offsetX + index] = true;
+                                preserveRow[offsetX + index] = preserveLineTrailingSpaces;
                             }
                         }
                         offsetX += characterWidth;
@@ -177,9 +193,46 @@ export class Output {
             }
         }
         const generatedOutput = output
-            .map((line) => {
-            const lineWithoutEmptyItems = line.filter((item) => item !== undefined);
-            return styledCharsToString(lineWithoutEmptyItems).trimEnd();
+            .map((line, rowIndex) => {
+            const rowTouched = touched[rowIndex] ?? [];
+            const rowPreserve = preserveTrailingSpace[rowIndex] ?? [];
+            const compactLine = [];
+            const compactTouched = [];
+            const compactPreserve = [];
+            for (let index = 0; index < line.length; index++) {
+                const item = line[index];
+                if (item === undefined) {
+                    continue;
+                }
+                compactLine.push(item);
+                compactTouched.push(rowTouched[index] === true);
+                compactPreserve.push(rowPreserve[index] === true);
+            }
+            let end = compactLine.length - 1;
+            while (end >= 0) {
+                const item = compactLine[end];
+                if (!item) {
+                    end--;
+                    continue;
+                }
+                if (!compactTouched[end]) {
+                    end--;
+                    continue;
+                }
+                const canTrimUnstyledSpace = item.type === "char" &&
+                    item.value === " " &&
+                    item.styles.length === 0 &&
+                    !compactPreserve[end];
+                if (canTrimUnstyledSpace) {
+                    end--;
+                    continue;
+                }
+                break;
+            }
+            if (end < 0) {
+                return "";
+            }
+            return styledCharsToString(compactLine.slice(0, end + 1));
         })
             .join("\n");
         return {

package/lib/core/render-border.d.ts

@@ -1,5 +1,5 @@
 import { type DOMNode } from "./dom.js";
-import { type Output } from "./output.js";
+import { type OutputLike } from "./output.js";
 /**
  * Renders the border for a DOM node.
  * Calculates border dimensions and draws border characters with specified
@@ -10,4 +10,4 @@ import { type Output } from "./output.js";
  * @param node - The DOM node for which to render the border.
  * @param output - The output instance to write the border to.
  */
-export declare const renderBorder: (x: number, y: number, node: DOMNode, output: Output) => void;
+export declare const renderBorder: (x: number, y: number, node: DOMNode, output: OutputLike) => void;

package/lib/core/render-node-to-output.d.ts

@@ -1,5 +1,5 @@
 import { type DOMElement } from "./dom.js";
-import { type Output } from "./output.js";
+import { type OutputLike } from "./output.js";
 /**
  * Function type for transforming output text.
  */
@@ -35,7 +35,7 @@ export declare const renderNodeToScreenReaderOutput: (node: DOMElement, options?
  * @param options.transformers - Array of text transformers.
  * @param options.skipStaticElements - Whether to skip static elements.
  */
-export declare const renderNodeToOutput: (node: DOMElement, output: Output, options: {
+export declare const renderNodeToOutput: (node: DOMElement, output: OutputLike, options: {
     offsetX?: number;
     offsetY?: number;
     transformers?: OutputTransformer[];

package/lib/core/render.d.ts

@@ -1,6 +1,8 @@
 import { type ReactNode } from "react";
 import { type ReadStream, type WriteStream } from "../types/io.js";
 import { Tinky, type RenderMetrics } from "./tinky.js";
+import { type IncrementalRenderingConfig, type IncrementalRenderingOption } from "./incremental-rendering.js";
+export type { IncrementalRenderingConfig, IncrementalRenderingOption };
 /**
  * Options for the render function.
  */
@@ -64,13 +66,23 @@ export interface RenderOptions {
      */
     maxFps?: number;
     /**
-     * Enable incremental rendering mode which only updates changed lines instead
-     * of redrawing the entire output. Reduces flickering and improves
-     * performance.
+     * Configure incremental rendering mode.
+     *
+     * - `true`: Enables run-diff incremental rendering.
+     * - `false` or omitted: Disables incremental rendering.
+     * - Object mode:
+     *   - `{ enabled: false }` disables incremental rendering.
+     *   - `{ strategy: "line" }` enables line-diff incremental rendering.
+     *   - `{ strategy: "run" }` (or omitted strategy) enables run-diff rendering.
+     *
+     * Runtime notes:
+     * - In `debug` mode, Tinky always writes full frames.
+     * - In screen-reader mode, Tinky uses the screen-reader output path.
+     * - In CI mode, Tinky avoids cursor-diff updates.
      *
      * @defaultValue false
      */
-    incrementalRendering?: boolean;
+    incrementalRendering?: IncrementalRenderingOption;
     /**
      * Environment variables.
      *

package/lib/core/tinky.d.ts

@@ -1,5 +1,6 @@
 import { type ReactNode } from "react";
 import { type ReadStream, type WriteStream } from "../types/io.js";
+import { type IncrementalRenderingOption } from "./incremental-rendering.js";
 /**
  * Performance metrics for a render operation.
  */
@@ -59,10 +60,15 @@ export interface Options {
      */
     maxFps?: number;
     /**
-     * Enable incremental rendering mode which only updates changed lines instead
-     * of redrawing the entire output.
+     * Configure incremental rendering mode.
+     *
+     * - `true`: Enables run-diff incremental rendering.
+     * - `false` or omitted: Disables incremental rendering.
+     * - `{ enabled: false }`: Disables incremental rendering.
+     * - `{ strategy: "line" }`: Enables line-diff incremental rendering.
+     * - `{ strategy: "run" }` (or omitted strategy): Enables run-diff rendering.
      */
-    incrementalRendering?: boolean;
+    incrementalRendering?: IncrementalRenderingOption;
     /**
      * Environment variables.
      */
@@ -103,6 +109,16 @@ export declare class Tinky {
     private readonly unsubscribeResize?;
     /** Whether we are running in a CI environment. */
     private readonly isCI;
+    /** Whether run-diff incremental rendering is active for this instance. */
+    private readonly usesRunIncrementalRendering;
+    /** Run-diff log updater. */
+    private readonly cellLog?;
+    /** Shared style registry for run buffers. */
+    private readonly styleRegistry?;
+    /** Previous rendered frame for run-diff strategy. */
+    private frontBuffer?;
+    /** Current frame render target for run-diff strategy. */
+    private backBuffer?;
     /**
      * Creates an instance of Tinky.
      *
@@ -137,6 +153,15 @@ export declare class Tinky {
      * Handles string generation, static output, screen reader logic, and writing.
      */
     onRender: () => void;
+    private isRunFrameEqual;
+    /**
+     * Swaps front and back buffers. After swap, the caller's newly-rendered
+     * frame becomes the front buffer. The old front becomes the back buffer
+     * and will be cleared by cellRenderer (resize + clear) at the start of
+     * the next render cycle.
+     */
+    private swapRunBuffers;
+    private redrawRunBuffer;
     /**
      * Renders the given React node.
      *

package/lib/core/tinky.js

@@ -9,11 +9,15 @@ import { LegacyRoot } from "react-reconciler/constants.js";
 import wrapAnsi from "wrap-ansi";
 import { reconciler } from "./reconciler.js";
 import { renderer } from "./renderer.js";
+import { cellRenderer } from "./cell-renderer.js";
 import * as dom from "./dom.js";
 import { logUpdate } from "./log-update.js";
+import { cellLogUpdateRun, } from "./cell-log-update-run.js";
 import { instances } from "./instances.js";
 import { App } from "../components/App.js";
 import { AccessibilityContext } from "../contexts/AccessibilityContext.js";
+import { CellBuffer, StyleRegistry } from "./cell-buffer.js";
+import { normalizeIncrementalRendering, } from "./incremental-rendering.js";
 const noop = () => {
     // no-op
 };
@@ -52,6 +56,16 @@ export class Tinky {
     unsubscribeResize;
     /** Whether we are running in a CI environment. */
     isCI;
+    /** Whether run-diff incremental rendering is active for this instance. */
+    usesRunIncrementalRendering;
+    /** Run-diff log updater. */
+    cellLog;
+    /** Shared style registry for run buffers. */
+    styleRegistry;
+    /** Previous rendered frame for run-diff strategy. */
+    frontBuffer;
+    /** Current frame render target for run-diff strategy. */
+    backBuffer;
     /**
      * Creates an instance of Tinky.
      *
@@ -65,6 +79,16 @@ export class Tinky {
         this.isScreenReaderEnabled =
             options.isScreenReaderEnabled ??
                 options.env?.["TINKY_SCREEN_READER"] === "true";
+        this.isCI = isCI(options.env);
+        const incrementalRenderStrategy = normalizeIncrementalRendering(options.incrementalRendering);
+        // Run-diff uses cursor addressing and interactive frame tracking, so we keep
+        // existing render paths in debug/screen-reader/CI modes.
+        this.usesRunIncrementalRendering =
+            incrementalRenderStrategy === "run" &&
+                !options.debug &&
+                !this.isScreenReaderEnabled &&
+                !this.isCI;
+        const useLineIncremental = incrementalRenderStrategy === "line";
         const unthrottled = options.debug || this.isScreenReaderEnabled;
         const maxFps = options.maxFps ?? 30;
         const renderThrottleMs = maxFps > 0 ? Math.max(1, Math.ceil(1000 / maxFps)) : 0;
@@ -76,7 +100,7 @@ export class Tinky {
             });
         this.rootNode.onImmediateRender = this.onRender;
         this.log = logUpdate.create(options.stdout, {
-            incremental: options.incrementalRendering,
+            incremental: useLineIncremental,
         });
         this.throttledLog = unthrottled
             ? this.log
@@ -84,6 +108,17 @@ export class Tinky {
                 leading: true,
                 trailing: true,
             });
+        if (this.usesRunIncrementalRendering) {
+            this.styleRegistry = new StyleRegistry();
+            this.frontBuffer = new CellBuffer({ width: 0, height: 0 }, this.styleRegistry);
+            this.backBuffer = new CellBuffer({ width: 0, height: 0 }, this.styleRegistry);
+            this.cellLog = cellLogUpdateRun.create(options.stdout, {
+                incremental: true,
+                mergeStrategy: "cost",
+                maxSegmentsBeforeFullRow: 12,
+                overwriteGapPenaltyBytes: 0,
+            });
+        }
         // Ignore last render after unmounting a tree to prevent empty output before
         // exit
         this.isUnmounted = false;
@@ -108,7 +143,6 @@ export class Tinky {
                 rendererPackageName: "tinky",
             });
         }
-        this.isCI = isCI(options.env);
         if (this.options.patchConsole) {
             this.patchConsole();
         }
@@ -138,8 +172,16 @@ export class Tinky {
         if (currentWidth < this.lastTerminalWidth) {
             // We clear the screen when decreasing terminal width to prevent duplicate
             // overlapping re-renders.
-            this.log.clear();
+            if (this.usesRunIncrementalRendering) {
+                this.cellLog?.clear();
+                this.frontBuffer?.resize(0, 0);
+                this.frontBuffer?.clear();
+            }
+            else {
+                this.log.clear();
+            }
             this.lastOutput = "";
+            this.lastOutputHeight = 0;
         }
         this.calculateLayout();
         this.onRender();
@@ -186,6 +228,42 @@ export class Tinky {
         if (this.isUnmounted) {
             return;
         }
+        if (this.usesRunIncrementalRendering && this.backBuffer) {
+            const startTime = performance.now();
+            const { buffer, outputHeight, staticOutput } = cellRenderer(this.rootNode, this.backBuffer, false);
+            this.options.onRender?.({ renderTime: performance.now() - startTime });
+            const hasStaticOutput = staticOutput && staticOutput !== "\n";
+            if (hasStaticOutput) {
+                this.fullStaticOutput += staticOutput;
+            }
+            if (this.options.stdout.rows &&
+                this.lastOutputHeight >= this.options.stdout.rows) {
+                const output = buffer.toString();
+                this.options.stdout.write(ansiEscapes.clearTerminal + this.fullStaticOutput + output);
+                this.lastOutput = output;
+                this.lastOutputHeight = outputHeight;
+                this.cellLog?.sync(buffer);
+                this.swapRunBuffers();
+                return;
+            }
+            if (hasStaticOutput) {
+                // Static output is appended once, then the interactive frame is redrawn.
+                this.cellLog?.clear();
+                this.options.stdout.write(staticOutput);
+                if (this.frontBuffer && this.cellLog) {
+                    this.cellLog(this.frontBuffer, buffer, { forceFull: true });
+                    this.swapRunBuffers();
+                }
+            }
+            else if (this.frontBuffer &&
+                this.cellLog &&
+                !this.isRunFrameEqual(buffer)) {
+                this.cellLog(this.frontBuffer, buffer);
+                this.swapRunBuffers();
+            }
+            this.lastOutputHeight = outputHeight;
+            return;
+        }
         const startTime = performance.now();
         const { output, outputHeight, staticOutput } = renderer(this.rootNode, this.isScreenReaderEnabled);
         this.options.onRender?.({ renderTime: performance.now() - startTime });
@@ -264,6 +342,28 @@ export class Tinky {
         this.lastOutput = output;
         this.lastOutputHeight = outputHeight;
     };
+    isRunFrameEqual(nextBuffer) {
+        return this.frontBuffer?.isEqual(nextBuffer) ?? false;
+    }
+    /**
+     * Swaps front and back buffers. After swap, the caller's newly-rendered
+     * frame becomes the front buffer. The old front becomes the back buffer
+     * and will be cleared by cellRenderer (resize + clear) at the start of
+     * the next render cycle.
+     */
+    swapRunBuffers() {
+        const previous = this.frontBuffer;
+        this.frontBuffer = this.backBuffer;
+        this.backBuffer = previous;
+    }
+    redrawRunBuffer() {
+        if (!this.frontBuffer || !this.cellLog) {
+            return;
+        }
+        this.cellLog(this.frontBuffer, this.frontBuffer, { forceFull: true });
+        this.lastOutput = this.frontBuffer.toString();
+        this.lastOutputHeight = this.frontBuffer.height;
+    }
     /**
      * Renders the given React node.
      *
@@ -291,6 +391,12 @@ export class Tinky {
             this.options.stdout.write(data);
             return;
         }
+        if (this.usesRunIncrementalRendering) {
+            this.cellLog?.clear();
+            this.options.stdout.write(data);
+            this.redrawRunBuffer();
+            return;
+        }
         this.log.clear();
         this.options.stdout.write(data);
         this.log(this.lastOutput);
@@ -313,6 +419,12 @@ export class Tinky {
             this.options.stderr.write(data);
             return;
         }
+        if (this.usesRunIncrementalRendering) {
+            this.cellLog?.clear();
+            this.options.stderr.write(data);
+            this.redrawRunBuffer();
+            return;
+        }
         this.log.clear();
         this.options.stderr.write(data);
         this.log(this.lastOutput);
@@ -345,7 +457,12 @@ export class Tinky {
             this.options.stdout.write(this.lastOutput + "\n");
         }
         else if (!this.options.debug) {
-            this.log.done();
+            if (this.usesRunIncrementalRendering) {
+                this.cellLog?.done();
+            }
+            else {
+                this.log.done();
+            }
         }
         this.isUnmounted = true;
         reconciler.updateContainerSync(null, this.container, null, noop);
@@ -387,7 +504,12 @@ export class Tinky {
     clear() {
         const isCiEnv = isCI(this.options.env);
         if (!isCiEnv) {
-            this.log.clear();
+            if (this.usesRunIncrementalRendering) {
+                this.cellLog?.clear();
+            }
+            else {
+                this.log.clear();
+            }
         }
     }
     /**

package/lib/index.d.ts

@@ -1,5 +1,6 @@
 export { type ReadStream, type WriteStream } from "./types/io.js";
 export { render, type RenderOptions, type Instance } from "./core/render.js";
+export { type IncrementalRenderingConfig, type IncrementalRenderingOption, } from "./core/render.js";
 export { Box, type BoxProps } from "./components/Box.js";
 export { Text, type TextProps } from "./components/Text.js";
 export { AppContext, type AppProps } from "./contexts/AppContext.js";