@oh-my-pi/pi-tui 18.6.1 → 18.6.3

package/CHANGELOG.md

@@ -2,6 +2,30 @@
 
 ## [Unreleased]
 
+## [18.6.3] - 2026-10-06
+
+### Breaking Changes
+
+- `WorkingRowSpec` no longer takes `rate`: the native working row reads spinner, elapsed time, divider, then the intent, and the tok/s readout moved to the composer bar
+
+### Added
+
+- `ComposerNativeState.rate` shows a tok/s readout in the native composer bar after the effort chip, and `ComposerNativeState.thinkingInModel` draws the thinking level as the model chip's icon instead of a separate chip
+- `formatTooltipKey` formats a key for a native tooltip: unicode keycap glyphs whatever the symbol preset, `esc` for Escape
+- `ImageOptions.requestRender` repaints an image without an image budget once its SIXEL encode lands ([#14529](https://github.com/can1357/oh-my-pi/pull/14529) by [@H4vC](https://github.com/H4vC))
+- `AssistantMessageComponent` can keep finished thinking sections expanded via `setExpandThinkingBlocks()`; sections folded by hand stay folded ([#14519](https://github.com/can1357/oh-my-pi/pull/14519) by [@H4vC](https://github.com/H4vC))
+
+### Changed
+
+- `/hotkeys` shows the effective `app.stt.pushToTalk` binding, including `Disabled` when unbound ([#6592](https://github.com/can1357/oh-my-pi/pull/6592) by [@anatoli-tsinovoy](https://github.com/anatoli-tsinovoy)).
+- SIXEL images are encoded off the main thread, so showing an image no longer stalls the terminal ([#14529](https://github.com/can1357/oh-my-pi/pull/14529) by [@H4vC](https://github.com/H4vC))
+
+### Fixed
+
+- Fixed native tooltips (composer, working row, queue, pause screen, git and extension dashboards) naming keys with Nerd Font icons Tern's UI font lacks, or as raw key ids (`ctrl+g`); they use keycap glyphs (`⇧⇥`, `⌃G`)
+- Fixed Tern's per-turn usage row showing a 24-hour time on a 12-hour terminal clock; the row and its tooltip now follow the terminal's clock, keeping the tooltip's ISO date ([#14565](https://github.com/can1357/oh-my-pi/pull/14565) by [@wolfiesch](https://github.com/wolfiesch))
+- Fixed hold-Space push-to-talk stopping the instant recording began (showing "No speech detected.") when opening the microphone briefly froze the UI ([#14463](https://github.com/can1357/oh-my-pi/pull/14463) by [@pgkt04](https://github.com/pgkt04))
+
 ## [18.6.1] - 2026-10-04
 
 ### Fixed

package/README.md

@@ -455,7 +455,7 @@ const spacer = new Spacer(2); // 2 empty lines (default: 1)
 
 ### Image
 
-Renders images inline for terminals that support the Kitty graphics protocol (Kitty, Ghostty, WezTerm, and Warp on macOS/Linux) or iTerm2 inline images. Falls back to a text placeholder on unsupported terminals.
+Renders images inline for terminals that support the Kitty graphics protocol (Kitty, Ghostty, WezTerm, and Warp on macOS/Linux), iTerm2 inline images or SIXEL. Falls back to a text placeholder on unsupported terminals.
 
 ```typescript
 interface ImageTheme {
@@ -466,17 +466,21 @@ interface ImageOptions {
 	maxWidthCells?: number;
 	maxHeightCells?: number;
 	filename?: string;
+	budget?: ImageBudget; // usually tui.imageBudget
+	requestRender?: () => void; // repaint once a SIXEL encode lands; defaults to the budget's
 }
 
 const image = new Image(
 	base64Data, // base64-encoded image data
 	"image/png", // MIME type
 	theme, // ImageTheme
-	options, // optional ImageOptions
+	{ ...options, budget: tui.imageBudget }, // optional ImageOptions
 );
 tui.addChild(image);
 ```
 
+SIXEL images encode off the JavaScript thread: the first render reserves the image's rows and the image appears on the repaint `budget` or `requestRender` triggers once the encode lands. Without either, it waits for an unrelated repaint.
+
 Supported formats: PNG, JPEG, GIF, WebP. Dimensions are parsed from the image headers automatically.
 
 ## Autocomplete

package/dist/types/app-keybindings.d.ts

@@ -40,6 +40,7 @@ interface AppKeybindings {
     "app.tree.unfoldOrDown": true;
     "app.plan.toggle": true;
     "app.history.search": true;
+    "app.stt.pushToTalk": true;
     "app.stt.toggle": true;
     "app.live.toggle": true;
 }
@@ -329,9 +330,13 @@ export declare const KEYBINDINGS: {
         readonly defaultKeys: "ctrl+r";
         readonly description: "Search history";
     };
+    readonly "app.stt.pushToTalk": {
+        readonly defaultKeys: "space";
+        readonly description: "Hold to record speech-to-text";
+    };
     readonly "app.stt.toggle": {
         readonly defaultKeys: [];
-        readonly description: "Toggle speech-to-text (default gesture: hold Space)";
+        readonly description: "Toggle speech-to-text recording";
     };
     readonly "app.live.toggle": {
         readonly defaultKeys: "ctrl+l";

package/dist/types/chat/assistant-message.d.ts

@@ -38,7 +38,7 @@ export declare class AssistantMessageComponent extends Container {
      * for lack of a target is re-rendered with its reaction stripped.
      */
     pickReactionTarget(transcript: readonly Component[]): void;
-    constructor(message?: AssistantMessage, hideThinkingBlock?: boolean, onImageUpdate?: () => void, thinkingRenderers?: readonly AssistantThinkingRenderer[], imageBudget?: ImageBudget, proseOnlyThinking?: boolean, linkTargets?: ReadonlyMap<string, string>);
+    constructor(message?: AssistantMessage, hideThinkingBlock?: boolean, onImageUpdate?: () => void, thinkingRenderers?: readonly AssistantThinkingRenderer[], imageBudget?: ImageBudget, proseOnlyThinking?: boolean, linkTargets?: ReadonlyMap<string, string>, expandThinkingBlocks?: boolean);
     /**
      * Show or clear the trailing cache-invalidation divider. Set at `message_end`
      * (live) or during rebuild, once the turn's usage is known and compared
@@ -65,6 +65,11 @@ export declare class AssistantMessageComponent extends Container {
      */
     setMidStreamPublication(allowed: boolean): void;
     setProseOnlyThinking(proseOnly: boolean): void;
+    /**
+     * Keep finished thinking sections expanded instead of folding them to "Thought for 12s".
+     * Sections the user folded or unfolded by hand keep that choice.
+     */
+    setExpandThinkingBlocks(expand: boolean): void;
     dispose(): void;
     /**
      * Toggle suppression of the inline `Error: …` line while the same error is

package/dist/types/chat/chat-transcript-builder.d.ts

@@ -25,6 +25,7 @@ export interface ChatTranscriptBuilderDeps {
     cwd: string;
     hideThinkingBlock?: () => boolean;
     proseOnlyThinking?: () => boolean;
+    expandThinkingBlocks?: () => boolean;
     /** Session-scoped resolved destinations for model-authored Markdown links. */
     linkTargets?: ReadonlyMap<string, string>;
     requestRender: () => void;

package/dist/types/chat/user-message.d.ts

@@ -1,7 +1,7 @@
 import { type Component, Container } from "../tui.js";
 import type { ImageContent } from "@oh-my-pi/pi-ai";
 import type { ReactionTarget } from "./reaction.js";
-import { type NativeNode, type NativeUiEvent } from "../native/node.js";
+import { type DescribeContext, type NativeNode, type NativeUiEvent } from "../native/node.js";
 /** How a user bubble styles its prose and chips (see {@link userBubbleColor}). */
 export interface UserBubbleOptions {
     /** Materialized `file://` targets per attached image, indexed by chip number. */
@@ -42,7 +42,7 @@ export declare class UserMessageComponent extends Container implements ReactionT
      * agent's reaction are chips at the bottom-right, so a reaction landing
      * later updates the frame in place, even deep in scrollback.
      */
-    describe(): NativeNode;
+    describe(cx?: DescribeContext): NativeNode;
     /** Hover toolbar clicks: omp's own copy and rewind commands. */
     handleNativeEvent(event: NativeUiEvent): void;
     render(width: number): readonly string[];

package/dist/types/chrome/status-notice.d.ts

@@ -1,14 +1,26 @@
 import type { NativeNode } from "../native/node.js";
 import { Container } from "../tui.js";
+/** How a {@link StatusNotice} shows. */
+export interface StatusNoticeOptions {
+    /** Styles the ANSI line; resolved at render so a theme change re-shapes it. */
+    styleFn?: (text: string) => string;
+    /**
+     * Whether a native terminal toasts it (default). False keeps the notice to
+     * the ANSI transcript: background chatter such as MCP connection progress,
+     * which would otherwise re-toast on every server that connects or fails.
+     */
+    toast?: boolean;
+}
 /**
  * A transient status notice (`showStatus`: "Thinking blocks: hidden", "Copied
  * to clipboard"). The ANSI render appends a blank row and the dim line to the
  * transcript; a native terminal shows it as a toast instead, so notices never
- * pile up in the history. Updating the text re-shows the toast.
+ * pile up in the history. Updating the text re-shows the toast; a notice
+ * with `toast: false` describes nothing natively.
  */
 export declare class StatusNotice extends Container {
     #private;
-    constructor(message: string, styleFn?: (text: string) => string);
-    setMessage(message: string, styleFn?: (text: string) => string): void;
+    constructor(message: string, options?: StatusNoticeOptions);
+    setMessage(message: string, options?: StatusNoticeOptions): void;
     describe(): NativeNode;
 }

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

@@ -330,6 +330,10 @@ export declare class Editor implements Component, Focusable {
      *  {@link getExpandedText}). Hosts that intercept large pastes through {@link onLargePaste} use
      *  this to re-insert a (possibly transformed) paste without re-triggering the interception hook. */
     insertPaste(content: string): void;
+    /** Whether a character-jump hotkey is waiting for its target character. */
+    get isJumpPending(): boolean;
+    /** Type literal text through the character-editing pipeline without keybinding dispatch. */
+    typeCharacter(text: string): void;
     /**
      * Whether an autocomplete popup is on screen. An `@` list narrowed to no match
      * while its refresh is pending stays open internally but is hidden, so it does

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

@@ -16,7 +16,19 @@ export interface ImageOptions {
      * repaint replaces the placement instead of stacking a duplicate.
      */
     imageKey?: string;
+    /**
+     * Schedules a repaint once this image's off-thread SIXEL encode lands.
+     * Defaults to the budget's repaint; a host without a budget must pass one,
+     * or the image's reserved rows stay blank until an unrelated repaint.
+     */
+    requestRender?: () => void;
 }
+/**
+ * Run `render` for rows bound for native scrollback. Those rows are never
+ * repainted, so an image whose off-thread SIXEL encode has not landed encodes
+ * synchronously instead of committing its reserved blank rows.
+ */
+export declare function renderForScrollback<T>(render: () => T): T;
 /** Default count of inline images kept as live graphics before older ones fall back to text. */
 export declare const DEFAULT_MAX_INLINE_IMAGES = 8;
 /**
@@ -52,6 +64,8 @@ export declare class ImageBudget {
     get cap(): number;
     get enabled(): boolean;
     setRequestRender(requestRender: () => void): void;
+    /** Ask for a repaint, e.g. once an image's off-thread encode settles. */
+    requestRender(): void;
     setCap(cap: number): void;
     /**
      * Stable graphics id for a logical image. A non-empty `key` maps to the same

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

@@ -28,6 +28,7 @@ export declare class Input implements Component, Focusable {
     setValue(value: string): void;
     setUseTerminalCursor(useTerminalCursor: boolean): void;
     getUseTerminalCursor(): boolean;
+    capturesInput(data: string): boolean;
     /**
      * Apply one key: the editor's text bindings (motion, deletion, kill ring,
      * undo), pastes and printable text. Returns whether the key was the

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

@@ -1,3 +1,4 @@
+import type { KeyId } from "../keys.js";
 import type { DescribeContext, NativeNode, NativeUiEvent } from "../native/node.js";
 import { type ShimmerPalette } from "../theme/shimmer.js";
 import type { TUI } from "../tui.js";
@@ -23,16 +24,14 @@ export interface WorkingRowSpec {
     readonly variant?: WorkingRowVariant;
     /** Shimmer palette of the label (a session-accented intent). */
     readonly palette?: ShimmerPalette;
-    /** Live tok/s, docked before the stop control. */
-    readonly rate?: number;
     /** Key id that interrupts (`escape`); undefined hides the stop control (Esc would not cancel). */
-    readonly interruptKey?: string;
+    readonly interruptKey?: KeyId;
 }
 /**
  * The dock's working row: `starburst` spinner (or a retry countdown ring),
- * the intent shimmering, `·`, the elapsed time, a grow spacer, then the stop
- * control whose click sends `interrupt`. Compaction adds an indeterminate
- * `progress` before the stop control; a retry says "Cancel".
+ * the elapsed time, the `·` divider, the intent shimmering, a grow spacer,
+ * then the stop control whose click sends `interrupt`. Compaction adds an
+ * indeterminate `progress` before the stop control; a retry says "Cancel".
  */
 export declare function describeWorkingRow(spec: WorkingRowSpec, cx: DescribeContext, now?: number): NativeNode;
 type ColorFn = (str: string) => string;

package/dist/types/key-hint-format.d.ts

@@ -23,6 +23,14 @@ export type KeyName = KeyId | ModifierName;
  * is capitalized. Other keys are capitalized (`f5` → `F5`).
  */
 export declare function formatKeyHint(key: KeyName): string;
+/**
+ * Format one key for a native tooltip (a TSP `title`): unicode keycap glyphs
+ * whatever the theme's symbol preset (`shift+tab` → `⇧⇥`), which Tern's
+ * tooltip splits into keycaps, and `esc` as Tern's own keycaps read. The nerd
+ * preset's icons are missing from Tern's UI font, and its spaced chords would
+ * not parse as keys.
+ */
+export declare function formatTooltipKey(key: KeyName): string;
 /** Format alternative keys as a slash-separated hint (`["f5", "alt+r"]` → `F5/⌥R`). */
 export declare function formatKeyHints(keys: KeyName | readonly KeyName[]): string;
 /** Format a double-tap gesture: `←←` with glyphs, `Left Left` with words. */

package/dist/types/native/backend.d.ts

@@ -83,8 +83,8 @@ export declare class NativeBackend {
      * The terminal's real `hello` reply after an optimistic start: adopt its
      * APC limit, credits, cell size, kinds, appearance and motion preference.
      * A width the terminal already reported in a `resize` event wins over the
-     * reply's. A different vocabulary or motion preference re-describes every
-     * component, so kinds the terminal lacks fall back.
+     * reply's. A different vocabulary, motion preference or clock re-describes
+     * every component, so kinds the terminal lacks fall back.
      */
     confirm(hello: TspHello): void;
     /** SIGWINCH: refresh the width used for `rows` fallback until the terminal reports one. */

package/dist/types/native/node.d.ts

@@ -71,6 +71,12 @@ export interface DescribeContext {
     readonly reduceMotion: boolean;
     /** The terminal's appearance is dark. */
     readonly dark: boolean;
+    /**
+     * The user's system reads a 12-hour clock (`false`: 24-hour); `undefined`
+     * when the terminal doesn't say. Pass it as `hour12` when formatting times:
+     * the process's own default locale may not know.
+     */
+    readonly hour12?: boolean;
     /** Whether the terminal renders `kind` natively (else describe something simpler or let it fall back). */
     supports(kind: TspKind): boolean;
     /**

package/dist/types/native/overlay.d.ts

@@ -7,7 +7,7 @@
  * component's root is a `card` whose `head` carries the title.
  */
 import type { TspProps, TspSpan, TspText } from "@oh-my-pi/pi-wire";
-import type { KeyName } from "../key-hint-format.js";
+import { type KeyName } from "../key-hint-format.js";
 import { type Keybinding } from "../keybindings.js";
 import type { NativeChild, NativeNode } from "./node.js";
 /** One footer hint: the keys that trigger it and what it does. */
@@ -44,10 +44,10 @@ export interface ActionButtonOptions {
     /** Sibling identity key (defaults to the action id); `leafKey(event.key)` reports it back. */
     readonly key?: string;
     /** Key id of the keyboard path the button mirrors, drawn as a keycap inside it (`"r"`, `"ctrl+g"`). */
-    readonly keys?: string;
+    readonly keys?: KeyName;
     /** `accent` = the view's hero action, `error` = destructive. */
     readonly tone?: "accent" | "error";
-    /** Tooltip; defaults to the label plus the keycap (`"Refresh  r"`). */
+    /** Tooltip; defaults to the label plus the keycap (`"Refresh  r"`, see {@link formatTooltipKey}). */
     readonly title?: string;
     /** Target of an `open` action (URL or `file://` path). */
     readonly href?: string;

package/dist/types/overlays/agent-hub.d.ts

@@ -73,6 +73,7 @@ export interface AgentHubDeps<TRecord extends AgentRecordLike = AgentRecordLike>
     /** Mirrors the main transcript's thinking-block visibility. */
     hideThinkingBlock?: () => boolean;
     proseOnlyThinking?: () => boolean;
+    expandThinkingBlocks?: () => boolean;
     /** Keys toggling tool output expansion (app.tools.expand). */
     expandKeys?: KeyId[];
     /** Focus the main view on this agent's live session (ctx.focusAgentSession). When absent (collab guest, tests), Enter opens the in-hub chat view instead. */

package/dist/types/overlays/agent-transcript-viewer.d.ts

@@ -54,6 +54,7 @@ export interface AgentTranscriptViewerDeps {
     cwd: string;
     hideThinkingBlock?: () => boolean;
     proseOnlyThinking?: () => boolean;
+    expandThinkingBlocks?: () => boolean;
     expandKeys: KeyId[];
     /** Keys that toggle the whole hub closed (app.agents.hub + app.session.observe). */
     hubKeys: KeyId[];

package/dist/types/overlays/btw-history-panel.d.ts

@@ -1,6 +1,7 @@
 import { type Component, type Focusable, Input } from "../index.js";
 import { type BtwHistoryRecord } from "./btw-history.js";
 import type { SpaceHoldHandler } from "../space-hold.js";
+import { type KeyId } from "../app-keybindings.js";
 import type { NativeNode, NativeUiEvent } from "../native/node.js";
 interface BtwHistoryPanelOptions {
     records: readonly BtwHistoryRecord[];
@@ -9,7 +10,8 @@ interface BtwHistoryPanelOptions {
     onCancel: (record: BtwHistoryRecord) => void;
     canFollowUp?: (record: BtwHistoryRecord) => boolean;
     onFollowUp?: (record: BtwHistoryRecord, question: string, signal: AbortSignal) => Promise<boolean>;
-    /** Space-bar push-to-talk for a follow-up composer: dictates into `input` while Space is held. */
+    /** Configured push-to-talk keys for a follow-up composer. */
+    spaceHoldKeys?: readonly KeyId[];
     spaceHold?: (input: Input) => SpaceHoldHandler;
     requestRender: () => void;
     getHeight: () => number;
@@ -33,6 +35,8 @@ export declare class BtwHistoryPanel implements Component, Focusable {
     openFollowUp(recordId: string): boolean;
     /** Select a record with its answer pane focused, read from the top (a just-asked /btw). */
     showRecord(recordId: string): void;
+    /** Only an active follow-up composer can claim its configured push-to-talk keys. */
+    capturesInput(data: string): boolean;
     /** Enhanced clipboard pastes belong only to the active composer. */
     pasteText(text: string): void;
     handleInput(data: string): void;

package/dist/types/overlays/copy-selector.d.ts

@@ -31,6 +31,7 @@ export interface CopySelectorDeps {
     cwd: string;
     hideThinkingBlock?: () => boolean;
     proseOnlyThinking?: () => boolean;
+    expandThinkingBlocks?: () => boolean;
     linkTargets?: ReadonlyMap<string, string>;
     requestRender: () => void;
     /** Replaces the "Copy" header when the picker is reused for another purpose. */

package/dist/types/overlays/rewind-selector.d.ts

@@ -48,6 +48,7 @@ export interface RewindSelectorDeps {
     cwd: string;
     hideThinkingBlock?: () => boolean;
     proseOnlyThinking?: () => boolean;
+    expandThinkingBlocks?: () => boolean;
     linkTargets?: ReadonlyMap<string, string>;
     requestRender: () => void;
     /** Sibling branch paths of `entryId`'s turn (excluding the turn itself). */

package/dist/types/overlays/usage-dashboard.d.ts

@@ -121,12 +121,12 @@ export declare class UsageDashboardComponent implements Component {
      * The sheet body (the terminal's `lg` overlay is the frame): a head row
      * (checked ago, Overview/Details tabs, Refresh), then either the provider
      * grid of frames with window meters and the activity heatmap, or the
-     * per-provider detail tables. `meter`/`chart` fall back to
-     * `progress`/`table` on terminals without them. Rebuilt only when its
-     * inputs change.
+     * per-provider detail tables, then Close like the other report sheets.
+     * `meter`/`chart` fall back to `progress`/`table` on terminals without
+     * them. Rebuilt only when its inputs change.
      */
     describe(cx: DescribeContext): NativeNode;
-    /** Tab clicks switch views like Enter/Esc; the Refresh button runs `r`. */
+    /** Tab clicks switch views like Enter/Esc; the Refresh button runs `r`; Close closes from either view. */
     handleNativeEvent(event: NativeUiEvent): void;
     handleInput(data: string): void;
 }

package/dist/types/prompt/custom-editor.d.ts

@@ -18,6 +18,10 @@ export interface ComposerNativeState {
     };
     /** Thinking effort word (`high`, `off`, `auto`); undefined when the model has no thinking. */
     readonly thinking?: string;
+    /** The thinking level draws as the model chip's icon instead of its own chip (where the terminal has `effort`). */
+    readonly thinkingInModel?: boolean;
+    /** Generation tok/s after the thinking level (live while running, else the last reading); undefined hides it. */
+    readonly rate?: number;
     /** A turn is running: the send keycap becomes a Stop button. */
     readonly running: boolean;
     /** The viewed subagent's lineage, outermost first and the viewed agent last; undefined on the main session. */
@@ -229,7 +233,8 @@ export declare class CustomEditor extends Editor {
      * The TSP composer: role `omp.editor[.bash|.python]` (tone `pending` while
      * a turn runs) over the context hairline, the viewing header while a
      * subagent is focused, the attachment chips, a `line` row of the
-     * shell-mode chip and the input, and the `bar`: model chip, effort chip,
+     * shell-mode chip and the input, and the `bar`: model chip, effort chip
+     * (or the effort glyph as the model chip's icon), the generation rate,
      * the other status facts, usage, then send (Stop while a turn runs).
      * Clicks come back as `status.model`, `thinking.cycle`, `submit`,
      * `interrupt` and `focus:<id>` actions.
@@ -271,9 +276,9 @@ export declare class CustomEditor extends Editor {
     onLeftAtStart?: () => void;
     /** Called when the viewing header asks to view agent `id` ({@link MAIN_AGENT_ID}: the main session). */
     onFocusAgent?: (id: string) => void;
-    /** Space-bar push-to-talk; set its `handler` to enable it. It is a text-composition gesture, so it
-     *  stays out of Vim's Normal/Visual modes (where the space bar is the `l` motion) and away from an
-     *  open autocomplete menu. */
+    /** Configurable push-to-talk; set its `handler` to enable it. It is a text-composition gesture, so
+     *  it stays out of Vim's Normal/Visual modes (where the space bar is the `l` motion), away from an
+     *  open autocomplete menu, and out of a pending character jump (whose target may be the key). */
     readonly spaceHold: SpaceHoldGesture;
     setActionKeys(action: ConfigurableEditorAction, keys: KeyId[]): void;
     /**
@@ -288,6 +293,7 @@ export declare class CustomEditor extends Editor {
      * Clear all custom key handlers.
      */
     clearCustomKeyHandlers(): void;
+    capturesInput(data: string): boolean;
     handleInput(data: string): void;
     /**
      * Route a keystroke through the base text-editor pipeline only, skipping the

package/dist/types/prompt/interactive-context-helpers.d.ts

@@ -15,6 +15,7 @@ export interface AssistantMessageHost {
     readonly viewSession: AssistantMessageSession;
     readonly effectiveHideThinkingBlock: boolean;
     readonly proseOnlyThinking: boolean;
+    readonly expandThinkingBlocks: boolean;
     readonly assistantImagesVisible: boolean;
     readonly hideToolActivity: boolean;
     readonly toolOutputExpanded: boolean;

package/dist/types/space-hold.d.ts

@@ -1,45 +1,60 @@
-/** Max gap (ms) between two spaces for the later one to count as OS key auto-repeat rather than a
- *  deliberate press. OS auto-repeat is fast; a deliberate tap (even a fast one) is slower. */
+import { type KeyId } from "./keys.js";
+/** Printable text a push-to-talk candidate key types (plain or shifted single characters and Space),
+ *  or undefined for non-printable keys and chords, which the gesture reserves instead of typing. */
+export declare function getSpaceHoldText(data: string, canonical: string | undefined): string | undefined;
+/** Max gap (ms) between two configured-key presses for a later one to count as OS key auto-repeat
+ *  rather than a deliberate press. OS auto-repeat is fast; a deliberate tap (even a fast one) is slower. */
 export declare const SPACE_REPEAT_MAX_GAP_MS = 120;
-/** Two consecutive inter-space gaps are "mechanical" (machine-driven auto-repeat) when both are
+/** Two consecutive inter-key gaps are "mechanical" (machine-driven auto-repeat) when both are
  *  within {@link SPACE_REPEAT_MAX_GAP_MS} and differ by no more than this — an absolute jitter floor
  *  or, for slower repeat rates, {@link SPACE_REPEAT_JITTER_RATIO} of the smaller gap. OS key-repeat
- *  is metronomic; a human smashing the bar is fast but irregular, so its deltas never stay this
- *  steady. */
+ *  is metronomic; human typing is irregular, so its deltas do not stay this steady. */
 export declare const SPACE_REPEAT_JITTER_MS = 18;
 export declare const SPACE_REPEAT_JITTER_RATIO = 0.35;
-/** Consecutive mechanical (fast + steady) deltas that confirm the space bar is held and start
- *  recording. Needs a sustained metronomic cadence, so jittery smashing and deliberate taps never
+/** Consecutive mechanical (fast + steady) deltas that confirm a configured key is held and start
+ *  recording. Needs a sustained metronomic cadence, so jittery typing and deliberate taps never
  *  reach it. */
 export declare const SPACE_HOLD_MECHANICAL_RUN = 2;
-/** Idle gap (ms) after the last repeated space that counts as the space bar being released, ending
- *  the push-to-talk recording. Must comfortably exceed the OS key-repeat interval. */
+/** Idle gap (ms) after the last repeated configured-key press that counts as release and ends
+ *  push-to-talk. Must comfortably exceed the OS key-repeat interval. */
 export declare const SPACE_HOLD_RELEASE_MS = 250;
-/** What a recognized space-bar hold drives — the push-to-talk start and stop. */
+/** A release timer firing more than this (ms) past its deadline means the event loop stalled (a
+ *  synchronous microphone open, GC, a heavy render) while the bar may still be held: the repeats
+ *  emitted during the stall are queued but unread, so the stall must not read as a release. */
+export declare const SPACE_HOLD_STALL_SLACK_MS = 100;
+/** What a recognized push-to-talk hold drives — the start and stop callbacks. */
 export interface SpaceHoldHandler {
-    /** Gate for the gesture. Returns false to keep the space bar inserting spaces normally, so
-     *  disabling push-to-talk restores plain space behavior. */
+    /** Gate for the gesture. Returns false to let matching keys behave normally. */
     enabled(): boolean;
-    /** A sustained hold was recognized. The optimistically-typed spaces have already been deleted. */
+    /** A sustained hold was recognized; any safely typed candidate text has already been deleted. */
     onStart(): void;
-    /** The held space bar was released (an idle gap with no further repeated spaces, or any other key). */
+    /** The held key was released (an idle gap with no further repeats, or any other key). */
     onEnd(): void;
 }
 /** What the host must do with a keypress after {@link SpaceHoldGesture.process} has seen it:
- *  `"pass"` — handle it normally; `"type"` — insert the space now (it is tracked back out if the run
- *  turns into a hold); `"swallow"` — drop it, the gesture consumed it. */
+ *  `"pass"` — handle it normally; `"type"` — insert its safely decoded printable text now (it is
+ *  tracked back out if the run turns into a hold); `"swallow"` — drop it, the gesture consumed it. */
 export type SpaceHoldStep = "pass" | "type" | "swallow";
-/** Space-hold push-to-talk state machine. A held space bar emits OS auto-repeat: a *steady* stream
- *  of spaces at a fixed fast interval. We watch the inter-space deltas and only recognize a hold once
- *  {@link SPACE_HOLD_MECHANICAL_RUN} consecutive deltas are "mechanical" — both auto-repeat-fast and
- *  near-identical (see {@link gapsAreMechanical}). Smashing the bar is fast but jittery and deliberate
- *  taps are too slow, so neither escalates and both keep typing real spaces; the few spaces typed
- *  before a real hold is recognized are tracked back out of the host input. */
+/** Push-to-talk key-hold state machine. A held key emits OS auto-repeat at a steady fast interval.
+ *  We watch inter-key deltas and only recognize a hold once {@link SPACE_HOLD_MECHANICAL_RUN}
+ *  consecutive deltas are mechanical (see {@link gapsAreMechanical}). Deliberate taps and jittery
+ *  runs stay typed; only text typed during the current steady run is removed on recognition. */
 export declare class SpaceHoldGesture {
     #private;
-    /** Unset (the default) keeps the space bar typing spaces. */
+    /** Configured alternative keys. Alternatives are tracked independently and never combine into one run. */
+    get keys(): readonly KeyId[];
+    set keys(keys: readonly KeyId[]);
+    /** Unset (the default) keeps configured keys behaving normally. */
     handler: SpaceHoldHandler | undefined;
     constructor(deleteTyped: (count: number) => void, allowed?: () => boolean);
-    /** Feed one keypress, `isSpace` when it is a plain space bar press. */
-    process(isSpace: boolean): SpaceHoldStep;
+    /** Pure focused-owner preflight on raw input: whether the key must reach the host before
+     *  TUI-wide input listeners. Only non-printable bindings are claimed — they would otherwise
+     *  trigger app shortcuts mid-hold; printable candidates keep the normal listener path so
+     *  raw-input observers (e.g. extensions) still see typed text, as they did before remapping. */
+    shouldRoute(data: string): boolean;
+    /** Feed one canonical keypress and, when safely printable, its decoded text length. The host
+     *  records the actual inserted length with {@link recordTyped} after applying normal typing. */
+    process(key: string | undefined, insertedCharacterLength?: number): SpaceHoldStep;
+    /** Account for text the host actually inserted for the preceding `"type"` step. */
+    recordTyped(insertedCharacterLength: number): void;
 }

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

@@ -284,6 +284,13 @@ export interface ImageRenderOptions {
     placementId?: number;
     /** When true (Kitty + {@link imageId}), also return the one-time transmit sequence. */
     includeTransmit?: boolean;
+    /**
+     * SIXEL sequence for the target pixel size renderImage computes, so the
+     * caller can encode off the JS thread: answer `undefined` while the encode
+     * is pending (the image's rows stay reserved) and `null` once it failed.
+     * Without a provider, renderImage encodes synchronously.
+     */
+    sixel?: (widthPx: number, heightPx: number) => string | null | undefined;
 }
 export declare function getCellDimensions(): CellDimensions;
 export declare function setCellDimensions(dims: CellDimensions): void;
@@ -381,6 +388,12 @@ export declare function getJpegDimensions(base64Data: string): ImageDimensions |
 export declare function getGifDimensions(base64Data: string): ImageDimensions | null;
 export declare function getWebpDimensions(base64Data: string): ImageDimensions | null;
 export declare function getImageDimensions(base64Data: string, mimeType: string): ImageDimensions | null;
+/**
+ * SIXEL sequence for `base64Data` at the given pixel size, encoded on the JS
+ * thread; `null` when the encode fails. For output that cannot wait for an
+ * off-thread encode.
+ */
+export declare function encodeSixelNow(base64Data: string, widthPx: number, heightPx: number): string | null;
 export declare function renderImage(base64Data: string, imageDimensions: ImageDimensions, options?: ImageRenderOptions): {
     sequence?: string;
     lines?: string[];

package/dist/types/tui.d.ts

@@ -150,6 +150,11 @@ export interface Component {
     describeScreen?(cx: DescribeContext): NativeScreen;
     /** User actions on nodes this component described (toggle, select, activate, custom). */
     handleNativeEvent?(event: NativeUiEvent): void;
+    /**
+     * Pure preflight for focused input that must precede TUI-wide input listeners
+     * and debug shortcuts. A true result routes the event to this component first.
+     */
+    capturesInput?(data: string): boolean;
     /**
      * Optional handler for keyboard input when component has focus
      */

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-tui",
-	"version": "18.6.1",
+	"version": "18.6.3",
 	"description": "Terminal User Interface library with differential rendering for efficient text-based applications",
 	"homepage": "https://omp.sh",
 	"author": {
@@ -41,14 +41,14 @@
 		"gen:glyphs": "bun scripts/gen-glyphs.ts"
 	},
 	"dependencies": {
-		"@oh-my-pi/omptype": "18.6.1",
-		"@oh-my-pi/pi-agent-core": "18.6.1",
-		"@oh-my-pi/pi-ai": "18.6.1",
-		"@oh-my-pi/pi-catalog": "18.6.1",
-		"@oh-my-pi/pi-natives": "18.6.1",
-		"@oh-my-pi/pi-utils": "18.6.1",
-		"@oh-my-pi/pi-wire": "18.6.1",
-		"@oh-my-pi/snapcompact": "18.6.1"
+		"@oh-my-pi/omptype": "18.6.3",
+		"@oh-my-pi/pi-agent-core": "18.6.3",
+		"@oh-my-pi/pi-ai": "18.6.3",
+		"@oh-my-pi/pi-catalog": "18.6.3",
+		"@oh-my-pi/pi-natives": "18.6.3",
+		"@oh-my-pi/pi-utils": "18.6.3",
+		"@oh-my-pi/pi-wire": "18.6.3",
+		"@oh-my-pi/snapcompact": "18.6.3"
 	},
 	"devDependencies": {
 		"kitty-vt-wasm": "^0.2.0"