@linxiraos/pi-tui 1.1.27 → 1.2.1

package/dist/types/chrome/transcript-container.d.ts

@@ -63,6 +63,12 @@ export interface TranscriptViewportSpan {
 export declare class TranscriptContainer extends Container {
     #private;
     addChild(component: Component): void;
+    /**
+     * `#entries` mirrors `children`; move both together or the next `#syncEntries`
+     * pays a full O(n) rebuild.
+     */
+    insertChildAt(component: Component, index: number): void;
+    /** Removes `component` if {@link canRemoveBlock} allows it; otherwise does nothing. */
     removeChild(component: Component): void;
     clear(): void;
     setToolActivityVisible(visible: boolean): void;

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

@@ -30,6 +30,7 @@ export declare class Box implements Component {
     setBgFn(bgFn?: (text: string) => string): void;
     setBorder(border?: BoxBorder): void;
     invalidate(): void;
+    releaseRenderCaches(): void;
     /**
      * A `card` when the box has a border or background: the background token
      * picks tone/role (user message, tool state, selection), a border colour

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

@@ -36,6 +36,7 @@ export declare class Disclosure implements Component {
     setExpanded(expanded: boolean): void;
     setIgnoreTight(ignore: boolean): this;
     invalidate(): void;
+    releaseRenderCaches(): void;
     dispose(): void;
     debugState(): Record<string, unknown>;
     get debugChildren(): readonly Component[];

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

@@ -1,5 +1,5 @@
 import { type AutocompleteProvider } from "../autocomplete.js";
-import type { TspEditorDecoration, TspTone } from "@linxiraos/pi-wire";
+import type { TspEditorDecoration, TspText, TspTone } from "@linxiraos/pi-wire";
 import { type DescribeContext, type NativeChild, type NativeNode, type NativeTextEdit, type NativeUiEvent } from "../native/node.js";
 import type { SymbolTheme } from "../symbols.js";
 import { type Component, type Focusable } from "../tui.js";
@@ -106,8 +106,11 @@ export declare class Editor implements Component, Focusable {
      * dialog's text field; only the prompt composer claims `zeta.editor`).
      */
     describeLayout: ((input: NativeNode, cx: DescribeContext) => NativeEditorLayout) | undefined;
-    /** TSP placeholder for the empty buffer; natively it replaces the rotating ANSI {@link placeholder} hints. */
-    describePlaceholder: (() => string) | undefined;
+    /**
+     * TSP placeholder for the empty buffer; natively it replaces the rotating ANSI {@link placeholder} hints.
+     * Return a stable value (the same spans array) while it is unchanged: the editor node is reused by identity.
+     */
+    describePlaceholder: (() => TspText) | undefined;
     /** Called with the selected text when Visual mode yanks, so hosts can reach the system
      *  clipboard — `packages/tui` deliberately has no clipboard dependency of its own. */
     onYank?: (text: string) => void;
@@ -146,6 +149,12 @@ export declare class Editor implements Component, Focusable {
      *  cursor. The host styles it (ANSI allowed). Re-evaluated on every render, so hosts can derive
      *  it from live state. */
     placeholder?: () => string | undefined;
+    /** Whole-message prediction for the next prompt, painted as ghost text after the cursor while
+     *  the single-line buffer is a strict prefix of it, the cursor sits at its end, and no
+     *  autocomplete is open. A shown prediction replaces the {@link placeholder}; Tab or Right inserts
+     *  the rest without submitting. Must be a single line. Re-evaluated on every render, so hosts can
+     *  derive it from live state. */
+    prediction?: () => string | undefined;
     constructor(theme: EditorTheme);
     /** Return bounded editor content, cursor, and transient child state for debug inspection. */
     debugState(): Record<string, unknown>;
@@ -250,6 +259,8 @@ export declare class Editor implements Component, Focusable {
     get atoms(): ReadonlyMap<string, string>;
     /** Monotonic buffer-content revision for render caches. Cursor-only movement does not advance it. */
     get textRevision(): number;
+    /** Monotonic atom-table revision for render caches: advances whenever {@link atoms} is mutated or replaced. */
+    get atomsRevision(): 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;
@@ -285,7 +296,7 @@ export declare class Editor implements Component, Focusable {
      *  Mirrors the transient state the key dispatch tears down before this action so the two
      *  cannot diverge: a pending character jump is cancelled by any other key, and an open
      *  spelling-assist popup is dismissed by anything that is not one of its accept keys (its
-     *  debounced refresh skips assist mode, so a surviving list would hang around forever).
+     *  refresh skips assist mode, so a surviving list would hang around forever).
      *  While Vim owns the buffer (Normal or Visual) the operation is Vim's `x` — deleting the
      *  selection and returning to Normal in Visual mode, the grapheme under the cursor
      *  otherwise. Only Insert mode and Vim-off editors delete straight through. */

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

@@ -44,6 +44,7 @@ export declare class FormField implements Component, Focusable, MouseRoutable {
     /** Label, description, details, preview, the control, error, summary, hint and footer as one column. */
     describe(_cx: DescribeContext): NativeNode;
     get focused(): boolean;
+    get hasError(): boolean;
     get debugChildren(): readonly Component[];
     set focused(value: boolean);
     setUseTerminalCursor(useTerminalCursor: boolean): void;

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

@@ -29,6 +29,8 @@ export interface ImageOptions {
  * synchronously instead of committing its reserved blank rows.
  */
 export declare function renderForScrollback<T>(render: () => T): T;
+/** Widest an {@link Image} rendered at `width` columns draws; callers sizing a raster for it (`SvgFigure`) match it. */
+export declare function imageMaxColumns(width: number): number;
 /** Default count of inline images kept as live graphics before older ones fall back to text. */
 export declare const DEFAULT_MAX_INLINE_IMAGES = 8;
 /**
@@ -73,6 +75,13 @@ export declare class ImageBudget {
      * gets a fresh id every call.
      */
     acquireId(key?: string): number;
+    /**
+     * Retire the graphic held under `key` as soon as no frame shows it, instead
+     * of when the residency sweep reaches it. For an owner that replaced the
+     * image for good — a streaming SVG figure's earlier raster — so superseded
+     * revisions never push older images (scrollback included) out of the store.
+     */
+    release(key: string): void;
     /**
      * Start an alternate-buffer lifecycle. Call once per `?1049h`, before the
      * first pass of the fullscreen overlay or resize borrow that owns the buffer.
@@ -140,50 +149,8 @@ export declare class ImageBudget {
      * the image is purged from the terminal store.
      */
     registerPlacementGeometry(imageId: number, widthPx: number, heightPx: number): void;
-    /**
-     * Record this frame's native-scrollback commit target (the frame-row count
-     * that is committed once the frame's writes land). Called once per rendered
-     * frame — including frames that emit no placements — so an epoch whose rows
-     * commit while its line is never rewritten is still flagged before the next
-     * re-emission.
-     */
-    observeCommitWatermark(committedTo: number): void;
-    /**
-     * End the physical-row coordinate epoch after observing its final commit
-     * watermark. Placement ids and latched archive state survive, but attachment
-     * rows do not: the next placement emit records them in the new-width frame.
-     */
-    beginPlacementCoordinateEpoch(): void;
-    /**
-     * Resolve the placement id and geometry for a direct-placement emit whose
-     * topmost attached cell sits at `attachTopFrameRow` — the first frame row
-     * the placement covers, i.e. the block's first *visible* row, not its
-     * origin (-1 when the writer has no frame-space position: alt-screen,
-     * resize, ConPTY-truncated replays). `committedTo` is this frame's commit
-     * target in the same frame-row space (-1 when unknown).
-     *
-     * Invariant: a placement id may be re-used (Kitty replace strips that id's
-     * cells everywhere, scrollback included) only while none of the cells it
-     * attached have entered native scrollback. The epoch — the `p=` id —
-     * advances exactly when the archived flag says otherwise; rewrites with no
-     * commit progression keep replacing the same id in place.
-     */
-    resolvePlacementEmit(imageId: number, attachTopFrameRow: number, committedTo: number): {
-        placementId: number;
-        widthPx: number;
-        heightPx: number;
-    } | null;
-    /**
-     * 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 recreate every visible
-     * placement after the terminal-wide cleanup.
-     */
-    resetPlacementEpochs(): ReadonlyArray<{
-        imageId: number;
-        lastEpoch: number;
-    }>;
+    /** Source dimensions used by the frame writer to clip a direct placement. */
+    getPlacementGeometry(imageId: number): ImageDimensions | undefined;
     /**
      * Queue a one-time transmit for `imageId` on the surface the in-flight pass
      * paints. No-op if that surface already holds the data, so a repeated call
@@ -218,6 +185,7 @@ export declare class Image implements Component {
     /** Return source metadata without exposing the encoded image buffer. */
     debugState(): Record<string, unknown>;
     invalidate(): void;
+    releaseRenderCaches(): void;
     /**
      * A native `image` backed by a content-addressed blob; the terminal fits
      * it. Cell caps become `ch`/`lines` bounds. The inline-image budget and

package/dist/types/components/key-value-list.d.ts

@@ -21,6 +21,7 @@ export declare class KeyValueList implements Component {
     constructor(rows: readonly KeyValueRow[], options: KeyValueListOptions);
     setRows(rows: readonly KeyValueRow[]): boolean;
     invalidate(): void;
+    releaseRenderCaches(): void;
     /** An aligned `kv` grid; label width and value wrapping are the terminal's. */
     describe(_cx: DescribeContext): NativeNode;
     render(width: number): readonly string[];

package/dist/types/components/layout/row.d.ts

@@ -48,6 +48,7 @@ export declare class Row implements Component, MouseRoutable {
     setDecorations(prefix: LayoutDecoration | undefined, gap: LayoutDecoration | undefined, suffix: LayoutDecoration | undefined): void;
     setIgnoreTight(ignore: boolean): this;
     invalidate(): void;
+    releaseRenderCaches(): void;
     dispose(): void;
     /**
      * A flex `row`: each child sits in a slot carrying its width bounds

package/dist/types/components/layout/stack.d.ts

@@ -43,6 +43,7 @@ export declare class Stack implements Component, MouseRoutable {
     setHeight(height: number | undefined): void;
     setIgnoreTight(ignore: boolean): this;
     invalidate(): void;
+    releaseRenderCaches(): void;
     dispose(): void;
     /**
      * A `col` of slots carrying each child's height bounds (fixed → min = max

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

@@ -1,13 +1,27 @@
+import { type TokensList } from "@linxiraos/pi-utils/marked";
 import type { DescribeContext, NativeNode } from "../native/node.js";
 import type { SymbolTheme } from "../symbols.js";
 import type { Component } from "../tui.js";
 /** @internal exported for tests — the grown-line block-kind gate. */
 export declare function fastLineStartHazard(grownLine: string): boolean;
-/** @internal exported for tests — the windowed lexer's first-probe window size. */
-export declare const LEX_WINDOW_BYTES: number;
+/**
+ * Lex a whole document with the renderer's rules (math, custom rules,
+ * strikethrough). Callers that split a document along its blocks (table
+ * charts) lex through this so they see the blocks Markdown renders.
+ */
+export declare function lexDocument(text: string): TokensList;
+/**
+ * `source` as a fenced code block in `lang`: the fence is one backtick longer
+ * than any backtick run in the source (at least three), so the block always
+ * closes where intended. `open` leaves it unclosed, the source verbatim, for
+ * a body that is still arriving.
+ */
+export declare function fencedCode(lang: string, source: string, options?: {
+    open?: boolean;
+}): string;
 /** A hyperlink as the renderer sees it: inline `[text](href)`, `<autolink>`, bare GFM URL, or reference link. */
 export interface MarkdownLink {
-    /** Visible link text (equals `href` for autolinks and bare URLs). */
+    /** Flattened visible label with whitespace collapsed to one row; falls back to `href` when empty. */
     text: string;
     /** Destination exactly as marked resolved it (references resolved, no normalization). */
     href: string;
@@ -19,6 +33,17 @@ export interface MarkdownLink {
  * Duplicate hrefs are kept; callers decide how to fold them.
  */
 export declare function extractMarkdownLinks(text: string): MarkdownLink[];
+/**
+ * Rewrite the destinations of inline links and link reference definitions in
+ * `text` to `resolve(href)`, leaving everything else byte-for-byte intact.
+ * Hosts that render the Markdown source themselves (a native terminal's `md`
+ * node) resolve relative destinations against their own idea of the working
+ * directory; handing them the session-resolved target keeps links pointing at
+ * what the author meant. Links inside code, images, autolinks and reference
+ * uses (`[x][ref]`, rewritten through their definition) are untouched; a link
+ * whose source cannot be located exactly is left as written.
+ */
+export declare function rewriteMarkdownLinkDestinations(text: string, resolve: (href: string) => string | undefined): string;
 /** Drop all L2 cache entries. Call on theme change to prevent stale styled output. */
 export declare function clearRenderCache(): void;
 /**
@@ -28,6 +53,13 @@ export declare function clearRenderCache(): void;
 export interface DefaultTextStyle {
     /** Foreground color function */
     color?: (text: string) => string;
+    /**
+     * The `color` foreground is prose-level: semantically-themed markdown spans
+     * (headings, links) keep their own `md*` theme colors instead of being
+     * painted over by it, while plain text runs still use `color`. Unset keeps
+     * the historical behavior where `color` paints every run.
+     */
+    proseFg?: boolean;
     /** Background color function */
     bgColor?: (text: string) => string;
     /** Bold text */
@@ -99,6 +131,7 @@ export declare class Markdown implements Component {
     debugState(): Record<string, unknown>;
     setText(text: string): boolean;
     invalidate(): void;
+    releaseRenderCaches(): void;
     /**
      * The unrendered source as an `md` node, `stream` while the streaming
      * (transient) cache is on. Append-only growth yields a fresh node of the

package/dist/types/components/scroll-view.d.ts

@@ -92,6 +92,7 @@ export declare class ScrollView implements Component {
     /** Apply Arrow, Shift+Arrow, Page, Home, and End navigation keys. */
     handleScrollKey(data: string): boolean;
     invalidate(): void;
+    releaseRenderCaches(): void;
     /** Permanently release a wrapped child's timers, subscriptions, and other resources. */
     dispose(): void;
     /**

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

@@ -15,6 +15,7 @@ export declare class Section implements Component {
     #private;
     constructor(options: SectionOptions);
     invalidate(): void;
+    releaseRenderCaches(): void;
     dispose(): void;
     /** A `section` headed by the styled title; the rule is the terminal's. */
     describe(_cx: DescribeContext): NativeNode;

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

@@ -29,6 +29,7 @@ export declare class Table implements Component {
     constructor(rows: readonly (readonly TableCell[])[], columns: readonly TableColumn[], options?: TableOptions);
     setRows(rows: readonly (readonly TableCell[])[]): boolean;
     invalidate(): void;
+    releaseRenderCaches(): void;
     /**
      * A native `table`. Column priorities carry over unchanged (lower gives
      * way first); truncating columns truncate at the end, the rest keep

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

@@ -26,6 +26,7 @@ export declare class Text implements Component {
      */
     setStyleFn(styleFn?: (text: string) => string): this;
     invalidate(): void;
+    releaseRenderCaches(): void;
     /**
      * Wrapped text; styling re-derived from the styled source so a theme swap
      * re-resolves tokens. A background fill becomes the node's tone.

package/dist/types/components/tree-view.d.ts

@@ -34,6 +34,13 @@ export interface FlattenTreeOptions<T, K extends TreeKey> {
     rootDepth?: number;
     /** Override the display depth inherited by direct children. */
     getChildDepth?: (item: T, row: TreeRow<T, K>, children: readonly T[]) => number;
+    /**
+     * Reuse the parent ancestor list when a child keeps the same display depth
+     * and the current item has no siblings (`siblingCount === 1`). Otherwise
+     * retain the current item as an ancestor so connector gutters remain
+     * accurate, including when the item has multiple children.
+     */
+    compactSameDepthAncestors?: boolean;
     /** Stop projection after this many structural items. Omit for no traversal cap. */
     maxItems?: number;
 }

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

@@ -9,6 +9,7 @@ export declare class TruncatedText implements Component {
     /** Return bounded source text and the last-known truncation state. */
     debugState(): Record<string, unknown>;
     invalidate(): void;
+    releaseRenderCaches(): void;
     /** First line only, clamped to one visual line with an end ellipsis. */
     describe(_cx: DescribeContext): NativeNode;
     render(width: number): readonly string[];

package/dist/types/fuzzy.d.ts

@@ -16,6 +16,20 @@ export interface FuzzyFilterResult<T> {
     score: number;
 }
 export declare function fuzzyMatch(query: string, text: string): FuzzyMatch;
+/**
+ * A query normalized and tokenized once for matching against many texts.
+ *
+ * `fuzzyMatch(query, text)` re-normalizes `query` (and rebuilds its
+ * alphanumeric-swap variants) on every call; filters that test one query
+ * against every row should build one `FuzzyQuery` per keystroke instead.
+ * `query.match(text)` returns exactly what `fuzzyMatch(query, text)` returns.
+ */
+export declare class FuzzyQuery {
+    #private;
+    constructor(query: string);
+    /** Same result as `fuzzyMatch(query, text)`; `text` may be a prepared {@link FuzzyText}. */
+    match(text: string | FuzzyText): FuzzyMatch;
+}
 /**
  * A text prepared once for repeated fuzzy matching.
  *
@@ -30,7 +44,21 @@ export declare class FuzzyText {
     #private;
     constructor(text: string);
     /** Match `query` (space-separated tokens; all must match) against the prepared text. */
-    match(query: string): FuzzyMatch;
+    match(query: string | FuzzyQuery): FuzzyMatch;
+}
+/**
+ * Items prepared once for repeated {@link fuzzyRank}-equivalent ranking.
+ *
+ * `fuzzyRank` resolves each candidate's search index through the bounded module
+ * cache, which holds at most {@link INDEX_CACHE_MAX} entries; larger candidate
+ * lists (the full model catalog) rebuild the overflow on every query. Hold one
+ * corpus per stable candidate list and call {@link rank} per keystroke instead.
+ */
+export declare class FuzzyCorpus<T> {
+    #private;
+    constructor(items: readonly T[], getText: (item: T) => string);
+    /** Same results as `fuzzyRank(items, query, getText)` for the prepared items. */
+    rank(query: string): FuzzyFilterResult<T>[];
 }
 /**
  * Filter and sort items by fuzzy match quality (best matches first).

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

@@ -1,6 +1,6 @@
 /**
  * Key-hint formatting, kept free of the native addon: it imports only types
- * plus the theme symbol mirror, so addon-free CLI paths (`omp --version`,
+ * plus the theme symbol mirror, so addon-free CLI paths (`zetacode --version`,
  * help text in cli/command-help.ts) can format keys without loading
  * `@linxiraos/pi-natives` through the keybindings registry.
  */

package/dist/types/keybinding-matchers.d.ts

@@ -1,3 +1,4 @@
+import type { KeyId } from "./app-keybindings.js";
 /**
  * Match the coding-agent interrupt key.
  *
@@ -18,6 +19,8 @@ export declare function matchesSelectDown(data: string): boolean;
 export declare function matchesSelectPageUp(data: string): boolean;
 /** Match the generic selector page-down keybinding. */
 export declare function matchesSelectPageDown(data: string): boolean;
+/** Effective external-editor key: the first bound key, or Ctrl+G when unbound. */
+export declare function appExternalEditorKey(): KeyId;
 /** Match the external-editor keybinding, falling back to Ctrl+G when unbound. */
 export declare function matchesAppExternalEditor(data: string): boolean;
 /**

package/dist/types/keybindings.d.ts

@@ -107,7 +107,7 @@ export declare const TUI_KEYBINDINGS: {
         readonly description: "Delete word backward";
     };
     readonly "tui.editor.deleteWordForward": {
-        readonly defaultKeys: ["alt+delete", "alt+d", "super+alt+delete", "super+alt+d"];
+        readonly defaultKeys: ["alt+delete", "alt+d", "ctrl+delete", "super+alt+delete", "super+alt+d"];
         readonly description: "Delete word forward";
     };
     readonly "tui.editor.deleteToLineStart": {

package/dist/types/kitty-graphics.d.ts

@@ -30,8 +30,8 @@ export interface KittyGraphicsFeatures {
  * cannot use cursor-positioned placements because the outer terminal does not
  * know pane scroll/reflow state. An explicit `PI_FORCE_IMAGE_PROTOCOL=kitty`
  * opts into placeholders under any multiplexer — matching `timg -pk`.
- * Automatic Herdr fallback stays off because its pane marker does not prove
- * that the experimental Kitty renderer is enabled.
+ * Automatic fallback stays off inside multiplexers whose pane marker does not
+ * prove that a Kitty renderer is enabled (Herdr's is experimental).
  *
  * `PI_NO_KITTY_PLACEHOLDERS=1` and `PI_KITTY_PLACEHOLDERS=0` remain hard
  * opt-outs; `PI_KITTY_PLACEHOLDERS=1` explicitly opts in anywhere else.

package/dist/types/loop-watchdog.d.ts

@@ -21,13 +21,14 @@ interface LoopWatchdogTimer {
     cancel?(): void;
 }
 /**
- * Always-on event-loop lag probe. Each tick is scheduled `intervalMs` ahead of
- * a recorded deadline; a tick that fires `thresholdMs` past its deadline means
- * the loop was blocked that long. The overshoot is logged once on the rising
- * edge (one block ⇒ one line, deduped via `#wasBlocked`), tagged with the phase
- * active during the elapsed interval via {@link takeRecentLoopPhase} — which
- * survives the synchronous push/pop the instrumented hot paths do before this
- * delayed tick can run — so the stall names its cause instead of "unknown".
+ * Always-on event-loop lag probe. Each tick is scheduled `intervalMs` ahead,
+ * with that target recorded as its deadline; a tick that fires `thresholdMs`
+ * past its deadline means the loop was blocked that long. The overshoot is
+ * logged once on the rising edge (one block ⇒ one line, deduped via
+ * `#wasBlocked`). Attribution via
+ * {@link takeLoopPhaseAttribution} totals each innermost phase only after the tick's
+ * deadline. A phase is named, with `phaseMs`, only when its total outweighs all
+ * unlabeled time in that late window; otherwise the block remains "unknown".
  *
  * The handle is `unref`'d so the probe never keeps the process alive, and stop()
  * cancels the armed timer when the handle exposes `cancel` (the default

package/dist/types/multiplexers/cmux.d.ts

@@ -0,0 +1,16 @@
+export declare const cmuxMultiplexer: {
+    readonly id: "cmux";
+    readonly precedence: "session";
+    readonly sessionEnvKeys: readonly ["CMUX_WORKSPACE_ID", "CMUX_SURFACE_ID", "CMUX_REMOTE_TRANSPORT"];
+    readonly ownsScreenGrid: true;
+    readonly isInside: (env?: NodeJS.ProcessEnv) => boolean;
+    /**
+     * Workspace/socket state alone is not enough: only the injected surface UUID
+     * identifies the pane that should receive the notification. Without a valid
+     * surface, or without the binary, delivery falls through unchanged.
+     */
+    readonly notifier: {
+        readonly tier: "surface";
+        readonly send: ({ message, env }: import("./types.js").TerminalMultiplexerNotificationRequest) => boolean;
+    };
+};

package/dist/types/multiplexers/herdr.d.ts

@@ -0,0 +1,26 @@
+export declare const herdrMultiplexer: {
+    readonly id: "herdr";
+    readonly precedence: "session";
+    readonly sessionEnvKeys: readonly ["HERDR_ENV", "HERDR_PANE_ID", "HERDR_TAB_ID", "HERDR_WORKSPACE_ID"];
+    readonly ownsScreenGrid: true;
+    readonly isInside: (env?: NodeJS.ProcessEnv) => boolean;
+    /**
+     * Herdr multiplexes panes like tmux but swallows bare OSC 9 / OSC 99 and has
+     * no DCS passthrough envelope, and its bell relay does not flag a
+     * backgrounded tab — so without its CLI a backgrounded pane gets no signal
+     * at all that the agent finished or is waiting for input.
+     *
+     * `sound` maps the notification kind onto what Herdr offers: a question
+     * waiting on the user and a turn that stopped with an error both need the
+     * human and ring `request`, a settled turn rings `done`, anything else stays
+     * silent. The exact pane ID addresses the CLI call; without a valid one, or
+     * without the binary, delivery falls through.
+     */
+    readonly notifier: {
+        readonly tier: "pane";
+        readonly send: ({ message, env }: import("./types.js").TerminalMultiplexerNotificationRequest) => boolean;
+    };
+    readonly hyperlinks: "render";
+    readonly honorsSynchronizedOutput: true;
+    readonly imagesRequireOverride: true;
+};

package/dist/types/multiplexers/notify.d.ts

@@ -0,0 +1,13 @@
+import type { TerminalNotification } from "../terminal-capabilities.js";
+/** Title for out-of-band multiplexer notifications that carry none of their own. */
+export declare const DEFAULT_NOTIFICATION_TITLE = "omp";
+/** Title and body for an out-of-band multiplexer notification (cmux, Herdr). */
+export declare function notificationTitleAndBody(message: string | TerminalNotification): {
+    title: string;
+    body: string;
+};
+/**
+ * Start a notifier CLI without waiting for or pinning it. Returns false when
+ * the binary cannot be spawned, which leaves delivery to the terminal fallback.
+ */
+export declare function spawnNotifier(cmd: string[]): boolean;

package/dist/types/multiplexers/orca.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Orca is an xterm.js-based IDE whose terminals expose paired pane/worktree IDs.
+ * It is recognized for launches, but it ranks below nested multiplexers and keeps
+ * the direct-terminal render path it used before it was recognized.
+ */
+export declare const orcaMultiplexer: {
+    readonly id: "orca";
+    readonly precedence: "outerApp";
+    readonly sessionEnvKeys: readonly ["ORCA_PANE_KEY", "ORCA_WORKTREE_ID"];
+    readonly ownsScreenGrid: false;
+    readonly isInside: (env?: NodeJS.ProcessEnv) => boolean;
+};

package/dist/types/multiplexers/screen.d.ts

@@ -0,0 +1,9 @@
+export declare const screenMultiplexer: {
+    readonly id: "screen";
+    readonly precedence: "session";
+    readonly sessionEnvKeys: readonly ["STY"];
+    readonly termPrefix: "screen";
+    readonly ownsScreenGrid: true;
+    readonly isInside: (env?: NodeJS.ProcessEnv) => boolean;
+    readonly hyperlinks: "drop";
+};

package/dist/types/multiplexers/tmux.d.ts

@@ -0,0 +1,29 @@
+/** Wrap a control sequence in tmux's DCS passthrough envelope. */
+export declare function wrapTmuxPassthrough(payload: string): string;
+export declare const tmuxMultiplexer: {
+    readonly id: "tmux";
+    readonly precedence: "session";
+    readonly sessionEnvKeys: readonly ["TMUX"];
+    readonly termPrefix: "tmux";
+    readonly ownsScreenGrid: true;
+    readonly isInside: (env?: NodeJS.ProcessEnv) => boolean;
+    readonly notifier: {
+        readonly tier: "inBand";
+        readonly send: ({ sequence, write }: import("./types.js").TerminalMultiplexerNotificationRequest) => boolean;
+    };
+    readonly hyperlinks: {
+        readonly forward: {
+            readonly termProgram: "tmux";
+            readonly major: 3;
+            readonly minor: 4;
+        };
+    };
+    readonly backgroundColorCache: {
+        readonly passthrough: typeof wrapTmuxPassthrough;
+        readonly settleMs: 100;
+    };
+    readonly expandsRepPadding: true;
+    readonly expiresSynchronizedOutput: true;
+    readonly altRestoreEndsSynchronizedOutput: true;
+    readonly growsBeforeSigwinch: true;
+};