@oh-my-pi/pi-tui 18.0.0 → 18.0.3

package/CHANGELOG.md

@@ -2,6 +2,43 @@
 
 ## [Unreleased]
 
+## [18.0.3] - 2026-08-23
+
+### Fixed
+
+- Fixed inline images vanishing from the transcript and scrollback when the session exits: stop no longer deletes transmitted Kitty images from the terminal's graphics store.
+
+## [18.0.2] - 2026-08-23
+
+### Fixed
+
+- Fixed visible history being erased when enlarging the terminal.
+
+## [18.0.1] - 2026-08-23
+
+### Added
+
+- Collapsed individual skill commands into a `/skill:` namespace entry to declutter suggestions
+- Added `TUI.renderNow()` for terminal-safe synchronous priority frames that retain resize debounce, output-backlog, and image deferral safeguards.
+
+### Changed
+
+- Improved slash command autocompletion to chain suggestions after selecting a namespace
+- Replaced the native-scrollback inference API (`NativeScrollback*` interfaces and the scrollback rebuild/resize settings hooks) with explicit `TerminalFramePlan` history batches.
+- Post-resize repaints now recover the reflowed viewport anchor with a cursor-position report (DSR) instead of trusting stale grid coordinates, so a settled resize no longer duplicates the editor/status rows on screen.
+- History appends that overflow the screen erase the old live viewport first, so a scroll can only push committed rows and blanks into scrollback, never an unfinished frame.
+
+### Fixed
+
+- Fixed consecutive prompt submissions being skipped by persistent history, allowing the latest project metadata to replace the previous entry without duplicating editor navigation history.
+- Fixed the history drain stalling on idle screens: accepting a batch now pumps the next frame, so a large resumed transcript retires to terminal history instead of pinning the live viewport in its emergency aggregate.
+- Fixed fuzzy matching so a qualifying whole-word hit is not hidden by an earlier mid-word occurrence ([#8465](https://github.com/can1357/oh-my-pi/pull/8465) by [@Mustaqeem66](https://github.com/Mustaqeem66)).
+- Fixed stray characters appearing in the terminal viewport during title updates
+- Fixed editor input lag when autocomplete providers are slow by keeping only the latest pending lookup.
+- Fixed pasting an image in kitty occasionally spraying base64 text into the composer alongside the image attachment: a kitty OSC 5522 clipboard packet torn by the incomplete-escape flush is now discarded up to its terminator instead of being replayed as keystrokes.
+- Fixed Kitty OSC 66 headings activating before the host explicitly enables text sizing.
+- Markdown streaming renderer now scans only the mutable tail (not the full document) for reference-link definitions and CR on every frame, eliminating the O(n²) `RegExp.test` cost that accounted for ~26% CPU during active streaming ([#9048](https://github.com/can1357/oh-my-pi/issues/9048)).
+
 ## [18.0.0] - 2026-08-22
 
 ### Breaking Changes

package/dist/types/autocomplete.d.ts

@@ -32,8 +32,8 @@ export interface SlashCommand {
     getInlineHint?(argumentText: string): string | null;
 }
 export interface AutocompleteProvider {
-    /** Get autocomplete suggestions for current text/cursor position */
-    getSuggestions(lines: string[], cursorLine: number, cursorCol: number): Promise<{
+    /** Get autocomplete suggestions for current text/cursor position. Expensive providers SHOULD stop when `signal` aborts. */
+    getSuggestions(lines: string[], cursorLine: number, cursorCol: number, signal?: AbortSignal): Promise<{
         items: AutocompleteItem[];
         prefix: string;
     } | null>;
@@ -68,8 +68,9 @@ export interface AutocompleteProvider {
      * Force file-path completion (called on Tab). Returns matched items plus the
      * full prefix, or null when no path token sits before the cursor. Present on
      * file-aware providers; absent on slash-only ones.
+     * Expensive providers SHOULD stop when `signal` aborts.
      */
-    getForceFileSuggestions?(lines: string[], cursorLine: number, cursorCol: number): Promise<{
+    getForceFileSuggestions?(lines: string[], cursorLine: number, cursorCol: number, signal?: AbortSignal): Promise<{
         items: AutocompleteItem[];
         prefix: string;
     } | null>;
@@ -83,6 +84,7 @@ export interface CombinedAutocompleteOptions {
     commandUsage?: (name: string) => number;
 }
 export declare function scoreCommandTextMatch(lowerPrefix: string, lowerTarget: string): number;
+export declare const SKILL_NAMESPACE = "skill:";
 /**
  * Whether a mid-prompt slash token (`prose … /tok`) is skill-shaped enough to
  * surface `name` in the skill popup. Deliberately stricter than submitted
@@ -100,7 +102,7 @@ export declare function midPromptSkillTokenMatches(lowerToken: string, name: str
 export declare class CombinedAutocompleteProvider implements AutocompleteProvider {
     #private;
     constructor(commands?: CommandEntry[], basePath?: string, options?: CombinedAutocompleteOptions);
-    getSuggestions(lines: string[], cursorLine: number, cursorCol: number): Promise<{
+    getSuggestions(lines: string[], cursorLine: number, cursorCol: number, signal?: AbortSignal): Promise<{
         items: AutocompleteItem[];
         prefix: string;
     } | null>;
@@ -110,7 +112,7 @@ export declare class CombinedAutocompleteProvider implements AutocompleteProvide
         cursorCol: number;
     };
     invalidateDirCache(dir?: string): void;
-    getForceFileSuggestions(lines: string[], cursorLine: number, cursorCol: number): Promise<{
+    getForceFileSuggestions(lines: string[], cursorLine: number, cursorCol: number, signal?: AbortSignal): Promise<{
         items: AutocompleteItem[];
         prefix: string;
     } | null>;

package/dist/types/components/editor.d.ts

@@ -114,9 +114,7 @@ export declare class Editor implements Component, Focusable {
      * Use this when the top border derives from state that mutates far faster
      * than the render cadence (session events, streaming, subagent updates).
      * The TUI already throttles renders, so a provider is invoked exactly once
-     * per frame and does no work between paints. Return a logical `revision` to
-     * distinguish concurrent status mutations from pure width reflow.
-     */
+     * per frame and does no work between paints. 	 */
     setTopBorderProvider(provider: ((availableWidth: number) => EditorTopBorder | undefined) | undefined): void;
     /**
      * Show or hide the editor border chrome.
@@ -145,6 +143,7 @@ export declare class Editor implements Component, Focusable {
     setPaddingX(paddingX: number): void;
     getAutocompleteMaxVisible(): number;
     setAutocompleteMaxVisible(maxVisible: number): void;
+    /** Loads persistent prompts for navigation and enables future persistence. */
     setHistoryStorage(storage: HistoryStorage): void;
     /**
      * Add a prompt to history for up/down arrow navigation.
@@ -155,7 +154,6 @@ export declare class Editor implements Component, Focusable {
     render(width: number): readonly string[];
     handleInput(data: string): void;
     getText(): string;
-    getNativeScrollbackWidthEpochRevision(): number;
     /** Whether the buffer text equals `value`, without `getText()`'s full join —
      *  O(1) for the hot per-keystroke probes against short single-line values. */
     textEquals(value: string): boolean;

package/dist/types/components/image.d.ts

@@ -121,11 +121,8 @@ export declare class ImageBudget {
      * Restart every placement epoch after a destructive history clear (`CSI 3 J`
      * full paint). The clear destroys all placement cells — scrollback rows are
      * gone and the replay rewrites the viewport — so no archive remains to
-     * protect. Reverting to epoch 1 lets the replay's placements replace the
-     * terminal's stale registry entries; the returned list names every image
-     * and the highest epoch it reached so the caller can delete all of its
-     * registry entries explicitly (`d=i` keeps the transmitted data) — an image
-     * absent from the replay never re-places, so even its epoch-1 entry must go.
+     * protect. Reverting to epoch 1 lets the replay recreate every visible
+     * placement after the terminal-wide cleanup.
      */
     resetPlacementEpochs(): ReadonlyArray<{
         imageId: number;

package/dist/types/components/markdown.d.ts

@@ -1,5 +1,5 @@
 import type { SymbolTheme } from "../symbols.js";
-import type { Component, NativeScrollbackCommittedRows, NativeScrollbackReplay, NativeScrollbackWidthEpoch } from "../tui.js";
+import type { Component } from "../tui.js";
 /** @internal exported for tests — must stay index-identical to the old regex scan. */
 export declare function mathStartIndex(src: string): number | undefined;
 /** @internal exported for tests — must stay index-identical to the old regex scan. */
@@ -69,37 +69,14 @@ export interface MarkdownTheme {
     resolveMermaidAscii?: (source: string, maxWidth?: number) => string | null;
     symbols: SymbolTheme;
 }
-export declare class Markdown implements Component, NativeScrollbackCommittedRows, NativeScrollbackReplay, NativeScrollbackWidthEpoch {
+export declare class Markdown implements Component {
     #private;
     setIgnoreTight(ignore: boolean): this;
     constructor(text: string, paddingX: number, paddingY: number, theme: MarkdownTheme, defaultTextStyle?: DefaultTextStyle, codeBlockIndent?: number);
     setText(text: string): boolean;
-    getNativeScrollbackWidthEpochRevision(): number;
     invalidate(): void;
     get transientRenderCache(): boolean;
     set transientRenderCache(value: boolean);
-    /**
-     * Rows at the top of the most recent render() (top padding + rendered
-     * frozen-token prefix) whose bytes are settled: byte-stable at this
-     * width/theme for as long as the text keeps growing append-only. Hosts
-     * feed this to transcript commit gating (see the coding agent's
-     * `FinalizableBlock.getTranscriptBlockSettledRows`). 0 outside streaming
-     * (`transientRenderCache`) mode, after a text rewind (re-earned on the new
-     * lineage), and on cache-served non-streaming renders.
-     */
-    getLastRenderSettledRows(): number;
-    captureNativeScrollbackWidthEpoch(): unknown;
-    resolveNativeScrollbackWidthEpoch(boundary: unknown): number | undefined;
-    getNativeScrollbackWidthEpochRows(): number | undefined;
-    isNativeScrollbackWidthEpochAppendOnly(boundary: unknown): boolean;
-    /**
-     * Freeze every table whose first physical row is already part of the native
-     * scrollback prefix. The recorded widths came from the exact frame that was
-     * just emitted, so the next streamed delta cannot retroactively widen it.
-     */
-    setNativeScrollbackCommittedRows(rows: number): void;
-    /** A destructive replay removes the immutable tape this layout was guarding. */
-    prepareNativeScrollbackReplay(): void;
     render(width: number): readonly string[];
 }
 /**

package/dist/types/components/text.d.ts

@@ -14,7 +14,6 @@ export declare class Text implements Component {
     constructor(text?: string, paddingX?: number, paddingY?: number, customBgFn?: (text: string) => string);
     getText(): string;
     setText(text: string): boolean;
-    getNativeScrollbackWidthEpochRevision(): number;
     setCustomBgFn(customBgFn?: (text: string) => string): void;
     /**
      * Supply a foreground styler applied to the text at render time (e.g. a

package/dist/types/terminal-capabilities.d.ts

@@ -21,7 +21,7 @@ export declare class TerminalInfo {
     readonly deccara: boolean;
     readonly supportsScreenToScrollback: boolean;
     /** Renders the Kitty OSC 66 text-sizing protocol (scaled spans). Kitty only. */
-    readonly textSizing: boolean;
+    readonly supportsTextSizing: boolean;
     /**
      * Hangul Compatibility Jamo (U+3131..=U+318E) cell width. Ghostty follows
      * UAX#11 (2 cells); Warp paints 1; "platform" keeps the OS default
@@ -30,7 +30,7 @@ export declare class TerminalInfo {
     readonly hangulJamoWidth: HangulCompatibilityJamoWidth;
     constructor(id: TerminalId, imageProtocol: ImageProtocol | null, trueColor: boolean, hyperlinks: boolean, notifyProtocol?: NotifyProtocol, deccara?: boolean, supportsScreenToScrollback?: boolean, 
     /** Renders the Kitty OSC 66 text-sizing protocol (scaled spans). Kitty only. */
-    textSizing?: boolean, 
+    supportsTextSizing?: boolean, 
     /**
      * Hangul Compatibility Jamo (U+3131..=U+318E) cell width. Ghostty follows
      * UAX#11 (2 cells); Warp paints 1; "platform" keeps the OS default
@@ -167,6 +167,7 @@ export interface RuntimeTerminal extends TerminalInfo {
     hyperlinks: boolean;
     deccara: boolean;
     supportsScreenToScrollback: boolean;
+    /** Whether OSC 66 text sizing is currently enabled. */
     textSizing: boolean;
 }
 export declare const TERMINAL: RuntimeTerminal;
@@ -184,7 +185,7 @@ export declare function setTerminalDeccara(enabled: boolean): void;
 export declare function setTerminalScreenToScrollback(enabled: boolean): void;
 /**
  * Enable/disable OSC 66 text-sizing at runtime. The coding-agent calls this from
- * the `tui.textSizing` setting (gated on the terminal's static `textSizing`
+ * the `tui.textSizing` setting (gated on the terminal's static `supportsTextSizing`
  * capability); tests flip it directly to exercise the scaled-heading path.
  */
 export declare function setTerminalTextSizing(enabled: boolean): void;
@@ -282,6 +283,12 @@ export declare function encodeKittyPlacementLine(options: {
  * this is the only way to actually purge a placed image.
  */
 export declare function encodeKittyDeleteImage(imageId: number): string;
+/**
+ * Delete every Kitty image and placement in the terminal. Used only by an
+ * explicit destructive display reset: text erases leave untracked placements
+ * painted, so per-image bookkeeping cannot guarantee a clean viewport.
+ */
+export declare function encodeKittyDeleteAllImages(): string;
 /**
  * Delete a single placement of an image (`d=i`, lowercase): removes its cells
  * and registry entry but keeps the transmitted data, so a later `a=p` under a

package/dist/types/terminal.d.ts

@@ -51,6 +51,16 @@ export declare class OutputBacklogGuard {
 }
 /** Record alternate-screen state (called by the TUI on `?1049h`/`?1049l` writes). */
 export declare function setAltScreenActive(active: boolean): void;
+/**
+ * Route an out-of-band escape sequence (e.g. an OSC title update) through the
+ * active terminal's output path. While a TUI owns stdout, frame paints go
+ * through the off-thread write pump and can split across multiple write(2)
+ * calls; a direct main-thread `process.stdout.write` can land between two of
+ * them — mid escape sequence — and the host terminal then prints the payload
+ * as literal text at the cursor position. Returns false when no terminal has
+ * started, in which case the caller owns stdout and may write directly.
+ */
+export declare function writeThroughActiveTerminal(data: string): boolean;
 /**
  * Emergency terminal restore - call this from signal/crash handlers
  * Resets terminal state without requiring access to the ProcessTerminal instance

package/dist/types/tui.d.ts

@@ -18,6 +18,30 @@ export interface RenderScheduler {
 export interface TUIOptions {
     renderScheduler?: RenderScheduler;
 }
+/** Physical terminal dimensions supplied to a frame provider. */
+export interface ViewportSize {
+    readonly columns: number;
+    readonly rows: number;
+}
+/** Immutable finalized rows offered until the terminal accepts this identifier. */
+export interface HistoryBatch {
+    readonly id: number;
+    readonly rows: readonly string[];
+}
+/** One history append and the complete mutable viewport for a terminal frame. */
+export interface TerminalFramePlan {
+    readonly history?: HistoryBatch;
+    readonly viewport: readonly string[];
+}
+/** Produces bounded terminal frames and retires acknowledged history batches. */
+export interface TerminalFrameProvider {
+    renderFrame(viewport: ViewportSize): TerminalFramePlan;
+    acknowledgeHistory(id: number): void;
+    /** Full semantic viewport used only on the transient resize buffer. */
+    renderResizeFrame?(viewport: ViewportSize): readonly string[];
+    /** Re-offer finalized history after a display reset or resize replay. */
+    resetHistory?(): void;
+}
 export interface TUIStartOptions {
     /** Clear saved native scrollback before the first paint. */
     clearScrollback?: boolean;
@@ -81,109 +105,6 @@ export interface OverlayFocusOwner {
     /** Returns true when `component` is a focus target inside this overlay. */
     ownsOverlayFocusTarget(component: Component): boolean;
 }
-/**
- * Component seam for append-only native-scrollback commits. A component whose
- * rendered rows can still change reports, after each render, the local line
- * index where that mutable suffix begins. Rows above the boundary are declared
- * FINAL — byte-stable at the current width for the component's lifetime — and
- * commit to native scrollback as exact, audited content. Rows at/after the
- * boundary repaint in place inside the visible window; when they scroll above
- * the window top they normally commit as frozen visual snapshots.
- *
- * A viewport-pinned region opts out of those mutable snapshot commits. Its
- * offscreen mutable rows are virtually clipped until the boundary advances;
- * use this for fixed-height dashboards whose frames replace each other rather
- * than append. A root that reports no seam commits everything that scrolls as
- * final (shell semantics).
- *
- * When several root children report a seam in the same frame, the topmost one
- * defines the boundary and pinning policy: commits are prefix-only, so
- * everything below the first seam is already excluded.
- */
-export interface NativeScrollbackLiveRegion {
-    getNativeScrollbackLiveRegionStart(): number | undefined;
-    /** Keeps the mutable suffix viewport-local instead of recording frozen snapshots. */
-    isNativeScrollbackLiveRegionPinned?(): boolean;
-    /**
-     * Local row where viewport pinning begins. When omitted, pinning (if
-     * reported) starts at {@link getNativeScrollbackLiveRegionStart}. A nested
-     * transcript uses this to keep an earlier unpinned live seam while still
-     * capping commits at a later pinned dashboard (hub wait, todo snapshot).
-     */
-    getNativeScrollbackLiveRegionPinnedStart?(): number | undefined;
-}
-export interface NativeScrollbackCommittedRows {
-    setNativeScrollbackCommittedRows(rows: number): void;
-}
-/**
- * Width-independent source boundary for multiplexer resize epochs. Capture
- * reads the last rendered source state; resolve maps that same logical boundary
- * into the most recent render's physical rows at its new width. The current
- * boundary identifies the source tail after updates queued during the resize.
- */
-export interface NativeScrollbackWidthEpoch {
-    captureNativeScrollbackWidthEpoch(): unknown;
-    resolveNativeScrollbackWidthEpoch(boundary: unknown): number | undefined;
-    getNativeScrollbackWidthEpochRows(): number | undefined;
-    /** False when updates can insert before captured trailing rows. */
-    isNativeScrollbackWidthEpochAppendOnly?(boundary: unknown): boolean;
-    /** Changes when child structure mutates independently of width reflow. */
-    getNativeScrollbackWidthEpochRevision?(): number;
-}
-/**
- * A component that discards rows after they enter native scrollback implements
- * this hook so a destructive full replay can rehydrate its complete frame.
- */
-export interface NativeScrollbackReplay {
-    prepareNativeScrollbackReplay(): void;
-}
-/**
- * Opt-in stability report for components that mutate their returned render
- * array in place across frames (instead of returning a fresh array per
- * change). The engine reads it right after the component's `render()` returns:
- * the report counts the leading rows of the just-returned array that are
- * byte-identical to the array state the reader last observed. The engine uses
- * it to reuse the composed frame's prefix — skipping marker extraction, line
- * preparation, and the committed-prefix audit for those rows.
- *
- * Contract:
- * - Reading CONSUMES the report: it re-bases the baseline to the current
- *   array state. The accumulated count therefore covers every render since
- *   the previous read, so out-of-band `render()` calls between engine frames
- *   (an exporter walking the tree) can only lower the report, never inflate
- *   it past what the engine actually has.
- * - An implementer that cannot prove stability for a frame must lower the
- *   accumulated count to 0 for that render.
- * - Rows at or beyond the report may have been mutated in place; rows before
- *   it must be the identical string values at the identical indices.
- */
-export interface RenderStablePrefix {
-    getRenderStablePrefixRows(): number;
-}
-/**
- * Opt-in fast path for composing only the visible tail of a tall component
- * during a terminal resize. A drag emits a SIGWINCH burst, and the width
- * changes on every event: a full compose re-lays-out (and, for markdown,
- * re-lexes) the entire transcript per event — O(history) work that is
- * discarded the instant the next event arrives. While the resize is in flight
- * the engine paints only the viewport, so it asks each tall root child for at
- * most `maxRows` rows from the bottom of its render at `width` and skips
- * composing everything above the fold. The authoritative full paint replays
- * once the drag settles (see {@link TUI} resize handling).
- *
- * Contract:
- * - Returns the BOTTOM rows of the component's full render at `width`, in
- *   top-to-bottom order, capped at `maxRows` (fewer when the component is
- *   shorter). The rows MUST be byte-identical to the corresponding tail of
- *   what `render(width)` would have returned, modulo a one-row separator at
- *   the very top edge (a transient frame the settle paint overwrites).
- * - MUST NOT mutate any persistent full-compose state: the next `render()`
- *   (the settle paint) has to reconcile exactly as if the tail render never
- *   happened. Warming pure per-width render caches is fine and desirable.
- */
-export interface ViewportTailProvider {
-    renderViewportTail(width: number, maxRows: number): readonly string[];
-}
 /**
  * Interface for components that can receive focus and display a cursor.
  * When focused, the component should emit CURSOR_MARKER at the cursor position
@@ -207,25 +128,12 @@ export interface RenderRequestOptions {
     clearScrollback?: boolean;
 }
 /**
- * What a settled in-place width resize (multiplexer pane or an in-place-latched
- * direct terminal) does to native scrollback, which the host rewrapped at the
- * old width:
- * - `append`: replay the transcript at the current width below the old-wrap
- *   history — one fresh copy per settled resize, nothing destroyed.
- * - `rebuild`: clear native history first (ED3) and replay — history holds the
- *   transcript exactly once at the current width. Requires a host that honors
- *   an inner ED3 (tmux does; GNU screen ignores it, degrading to `append`),
- *   and erases pre-session pane history.
- * - `preserve`: repaint the viewport only — zero history growth; scrollback
- *   keeps the old-width wrap until content next scrolls off.
+ * Controls how a settled terminal resize refreshes native history.
  *
- * The raw engine defaults to `preserve` (append-only native scrollback, the
- * engine's baseline contract); `PI_TUI_RESIZE_SCROLLBACK` overrides that
- * initial value. The coding agent applies its `tui.resizeScrollback` setting
- * (default `append`) on top at startup, so interactive sessions refresh
- * stale-width history out of the box.
+ * `append` replays the current transcript below retained history, `rebuild`
+ * clears history before replaying it, and `preserve` repaints only the viewport.
  */
-export type ResizeScrollbackMode = "rebuild" | "append" | "preserve";
+export type ResizeScrollbackMode = "append" | "rebuild" | "preserve";
 /** Type guard to check if a component implements Focusable */
 export declare function isFocusable(component: Component | null): component is Component & Focusable;
 /**
@@ -309,7 +217,7 @@ export interface OverlayHandle {
 /**
  * Container - a component that contains other components
  */
-export declare class Container implements Component, NativeScrollbackCommittedRows, NativeScrollbackReplay, NativeScrollbackWidthEpoch {
+export declare class Container implements Component {
     #private;
     children: Component[];
     setIgnoreTight(ignore: boolean): this;
@@ -325,21 +233,6 @@ export declare class Container implements Component, NativeScrollbackCommittedRo
      * {@link clear} for that). Idempotent per child via each child's own dispose.
      */
     dispose(): void;
-    /**
-     * Split the committed prefix from the container's most recently rendered
-     * rows across its children. The memoized child arrays are the exact geometry
-     * that produced that frame; when the child list was invalidated or rebuilt,
-     * there is no safe old-to-new coordinate mapping, so propagation waits for
-     * the next render/post-emit publication.
-     */
-    setNativeScrollbackCommittedRows(rows: number): void;
-    /** Recursively discard layout locks that are meaningful only to the old tape. */
-    prepareNativeScrollbackReplay(): void;
-    captureNativeScrollbackWidthEpoch(): unknown;
-    resolveNativeScrollbackWidthEpoch(boundary: unknown): number | undefined;
-    getNativeScrollbackWidthEpochRows(): number | undefined;
-    isNativeScrollbackWidthEpochAppendOnly(boundary: unknown): boolean;
-    getNativeScrollbackWidthEpochRevision(): number;
     render(width: number): readonly string[];
 }
 /**
@@ -349,41 +242,6 @@ export declare class Container implements Component, NativeScrollbackCommittedRo
  * merges, so SGR-light lines incur only a single `indexOf` scan.
  */
 export declare function coalesceAdjacentSgr(line: string): string;
-/**
- * Decide whether `frame` still aligns with the committed prefix, and where to
- * re-anchor the commit index when it does not. Returns the resync row index,
- * or -1 when no resync is needed.
- *
- * Zones (verifiedTo ≤ finalTo ≤ prefix.length):
- *   [0, verifiedTo)         VERIFIED exact rows — sampled with tolerance.
- *   [verifiedTo, finalTo)   NEWLY-FINAL rows — frozen visual snapshots whose
- *       source just became declared-final (the block finalized / a barrier
- *       cleared). Hard-scanned in FULL with no tolerance: any content change
- *       (a pending header settling, a preview replaced by its result, a tail
- *       shifting up after a barrier removal) re-anchors so the engine can
- *       erase-and-replay history with the final content exactly once (or, on
- *       ED3-unsafe multiplexers, recommit it below the frozen snapshot —
- *       duplication, never loss) instead of committing it nowhere and
- *       painting it nowhere.
- *   [finalTo, prefix.length) FROZEN visual snapshots of still-live rows —
- *       exempt: their drift is expected (a collapsing preview, a ticking
- *       progress tree) and must never spray re-anchors mid-run.
- *
- * The verified zone's sampled check exploits the asymmetry between the two
- * mutation classes: an in-place edit/restyle disturbs only the touched rows
- * (alignment below stays intact; the stale copy in history is the accepted
- * artifact), while an insertion/deletion shifts EVERY row below it. Up to 8
- * non-blank rows within the last 24 verified rows are compared SGR-stripped
- * (theme changes stay quiet), tolerating a SINGLE mismatch. The tolerance is
- * load-bearing for roots that report NO seam: an animated row already in
- * history would otherwise re-anchor on every glyph tick.
- *
- * Highly repetitive tails (identical filler rows) can mask a shift in the tail
- * sample, in which case the skipped rows are content-identical to the committed
- * ones — observationally harmless. Exported for the render-stress harness, whose
- * shadow commit ledger must mirror the engine's law exactly.
- */
-export declare function findCommittedPrefixResync(frame: readonly string[], prefix: readonly string[], verifiedTo?: number, finalTo?: number): number;
 /**
  * TUI - Main class for managing terminal UI with differential rendering
  */
@@ -399,19 +257,9 @@ export declare class TUI extends Container {
         hidden: boolean;
     }[];
     constructor(terminal: Terminal, showHardwareCursor?: boolean, options?: TUIOptions);
-    captureNativeScrollbackWidthEpoch(): unknown;
-    resolveNativeScrollbackWidthEpoch(boundary: unknown): number | undefined;
-    getNativeScrollbackWidthEpochRows(): number | undefined;
-    render(width: number): readonly string[];
+    /** Install the product-owned bounded frame provider. */
+    setFrameProvider(provider: TerminalFrameProvider | undefined): void;
     get fullRedraws(): number;
-    /**
-     * Transient viewport-only paints emitted by the non-multiplexer resize fast
-     * path. These never touch native scrollback or the commit ledger, so they
-     * are counted apart from {@link fullRedraws}.
-     */
-    get resizeViewportPaints(): number;
-    /** Whether a non-multiplexer resize drag is currently in flight. */
-    get resizeViewportActive(): boolean;
     /** Shared budget that caps how many inline images render as live graphics. */
     get imageBudget(): ImageBudget;
     /**
@@ -420,29 +268,12 @@ export declare class TUI extends Container {
      * plus a full redraw on the frame after a new image exceeds the cap.
      */
     setMaxInlineImages(cap: number): void;
-    /** Delete every tracked Kitty image from the terminal graphics store. */
-    clearInlineImages(): void;
-    /**
-     * Get whether scrollback divergence rebuild is enabled.
-     */
-    getScrollbackRebuild(): boolean;
-    /**
-     * Enable or disable scrollback divergence rebuild (default off).
-     * When enabled, the engine will erase and replay the terminal's
-     * scrollback (using ED3 / alt buffer / scrollback replay) to avoid
-     * duplicate blocks when a block's final form replaces its live preview.
-     */
-    setScrollbackRebuild(enabled: boolean): void;
-    /**
-     * Get how a settled in-place width resize refreshes native scrollback.
-     */
+    /** Return how settled resizes refresh native scrollback. */
     getResizeScrollback(): ResizeScrollbackMode;
-    /**
-     * Set how a settled in-place width resize refreshes native scrollback
-     * (see {@link ResizeScrollbackMode}; engine default `preserve` — the coding
-     * agent applies its `tui.resizeScrollback` setting, default `append`).
-     */
+    /** Set how settled resizes refresh native scrollback. */
     setResizeScrollback(mode: ResizeScrollbackMode): void;
+    /** Delete every tracked Kitty image from the terminal graphics store. */
+    clearInlineImages(): void;
     getShowHardwareCursor(): boolean;
     setShowHardwareCursor(enabled: boolean): void;
     /**
@@ -478,53 +309,24 @@ export declare class TUI extends Container {
     removeInputListener(listener: InputListener): void;
     stop(): void;
     /**
-     * Force an immediate full replay of the current frame, including native
-     * scrollback. This is the keyboard-accessible equivalent of the resize reset:
-     * no queued diff frame or terminal scrollback probe can downgrade it to a
-     * viewport-only repaint.
-     *
-     * Invalidates every component first so the replay reflects current state. A
-     * geometry-driven reset thaws frozen scrollback snapshots implicitly (the new
-     * width misses every cached snapshot), but a same-width reset would otherwise
-     * replay stale snapshots — leaving host-frozen blocks (e.g. a transcript whose
-     * committed rows are immutable on ED3-risk terminals) showing pre-mutation
-     * content. Invalidation is the generic signal those containers use to retire
-     * their snapshots, which is exactly what a user-driven display reset wants.
+     * Destructive user-gesture reset: invalidate every component, erase native
+     * history, then repaint from row zero. Reachable only from explicit gestures (session
+     * replace, /tree, an explicit clear) — never from ordinary rendering,
+     * animation, resize, or finalization.
      */
     resetDisplay(): void;
     requestRender(force?: boolean, options?: RenderRequestOptions): void;
     /**
-     * Opt `component` into subtree-only renders when input leaves focus stable.
-     *
-     * The host must explicitly request renders for every sibling mutated by the
-     * component's input callbacks. Components without this opt-in retain the
-     * legacy full-root render after input.
+     * Paint a forced frame synchronously when startup must hand off an already
+     * visible component tree before further async initialization. Same as
+     * {@link requestRender} minus the `setImmediate` hop.
      */
-    enableScopedInputRender(component: Component): void;
+    renderNow(options?: RenderRequestOptions): void;
     /**
      * Schedule a render on behalf of `component` after a self-contained change
-     * (spinner frame, blink) that cannot have affected any other component.
-     *
-     * When every request since the last frame is component-scoped and the
-     * frame is otherwise quiet — no resize or geometry change, no overlays, no
-     * live inline images, no forced repaint, unchanged root child list — the
-     * next compose re-renders only the root subtrees containing the requesting
-     * components and reuses the previous frame's rows (and seam reports) for
-     * every other root child, skipping the full component-tree walk that makes
-     * long transcripts expensive to repaint at animation rate. Any concurrent
-     * full request or unsafe condition downgrades the frame to a normal full
-     * compose, so this is never less correct than `requestRender()` — only
-     * cheaper.
-     */
-    requestComponentRender(component: Component): void;
-    /**
-     * Rewrite a quiet, visible component segment directly.
-     *
-     * Loader-style animation changes one already-positioned segment at a fixed
-     * size. When the current frame geometry is still valid, rewrite just those
-     * rows and update the diff baseline instead of scheduling a full render
-     * cycle. Unsafe states fall back to `requestComponentRender()`, preserving
-     * the ordinary renderer as the correctness path.
+     * (spinner frame, blink). Frames always compose the bounded viewport from
+     * scratch — retired blocks no longer render — so a scoped request is simply
+     * an ordinary render.
      */
-    requestDirectWrite(component: Component): void;
+    requestComponentRender(_component: Component): void;
 }

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-tui",
-	"version": "18.0.0",
+	"version": "18.0.3",
 	"description": "Terminal User Interface library with differential rendering for efficient text-based applications",
 	"homepage": "https://omp.sh",
 	"author": "Stencil Labs, Inc.",
@@ -37,8 +37,8 @@
 		"fmt": "biome format --write ."
 	},
 	"dependencies": {
-		"@oh-my-pi/pi-natives": "18.0.0",
-		"@oh-my-pi/pi-utils": "18.0.0"
+		"@oh-my-pi/pi-natives": "18.0.3",
+		"@oh-my-pi/pi-utils": "18.0.3"
 	},
 	"devDependencies": {
 		"kitty-vt-wasm": "^0.2.0"