@wrongstack/tui 0.284.1 → 0.286.0

package/dist/ink.d.ts

@@ -0,0 +1,20 @@
+import { Box as InkBox, type DOMElement, Text as InkText } from 'ink';
+import { type ComponentProps, type ForwardRefExoticComponent, type ReactElement, type RefAttributes } from 'react';
+type TextOwnProps = Omit<ComponentProps<typeof InkText>, 'color' | 'backgroundColor'> & {
+    color?: string | undefined;
+    backgroundColor?: string | undefined;
+};
+type BoxOwnProps = Omit<ComponentProps<typeof InkBox>, 'ref' | 'borderColor' | 'backgroundColor'> & {
+    borderColor?: string | undefined;
+    backgroundColor?: string | undefined;
+};
+export { Static, measureElement, useApp, useInput, useStdin, useStdout } from 'ink';
+export type { BoxProps, DOMElement, TextProps, Key } from 'ink';
+/** Ink `Text` with `color`/`backgroundColor` remapped to the pastel palette. */
+export declare function Text({ color, backgroundColor, ...rest }: TextOwnProps): ReactElement;
+/**
+ * Ink `Box` with `borderColor`/`backgroundColor` remapped to pastels. Forwards
+ * `ref` so `measureElement` (used by the scrollable history) keeps working.
+ */
+export declare const Box: ForwardRefExoticComponent<BoxOwnProps & RefAttributes<DOMElement>>;
+//# sourceMappingURL=ink.d.ts.map

package/dist/ink.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ink.d.ts","sourceRoot":"","sources":["../src/ink.tsx"],"names":[],"mappings":"AAcA,OAAO,EAAE,GAAG,IAAI,MAAM,EAAE,KAAK,UAAU,EAAE,IAAI,IAAI,OAAO,EAAE,MAAM,KAAK,CAAC;AACtE,OAAO,EACL,KAAK,cAAc,EACnB,KAAK,yBAAyB,EAE9B,KAAK,YAAY,EACjB,KAAK,aAAa,EACnB,MAAM,OAAO,CAAC;AAWf,KAAK,YAAY,GAAG,IAAI,CAAC,cAAc,CAAC,OAAO,OAAO,CAAC,EAAE,OAAO,GAAG,iBAAiB,CAAC,GAAG;IACtF,KAAK,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC3B,eAAe,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CACtC,CAAC;AACF,KAAK,WAAW,GAAG,IAAI,CAAC,cAAc,CAAC,OAAO,MAAM,CAAC,EAAE,KAAK,GAAG,aAAa,GAAG,iBAAiB,CAAC,GAAG;IAClG,WAAW,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACjC,eAAe,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CACtC,CAAC;AAEF,OAAO,EAAE,MAAM,EAAE,cAAc,EAAE,MAAM,EAAE,QAAQ,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,KAAK,CAAC;AACpF,YAAY,EAAE,QAAQ,EAAE,UAAU,EAAE,SAAS,EAAE,GAAG,EAAE,MAAM,KAAK,CAAC;AAUhE,gFAAgF;AAChF,wBAAgB,IAAI,CAAC,EAAE,KAAK,EAAE,eAAe,EAAE,GAAG,IAAI,EAAE,EAAE,YAAY,GAAG,YAAY,CAEpF;AAED;;;GAGG;AACH,eAAO,MAAM,GAAG,EAAE,yBAAyB,CAAC,WAAW,GAAG,aAAa,CAAC,UAAU,CAAC,CAiBjF,CAAC"}

package/dist/input-editing.d.ts

@@ -0,0 +1,76 @@
+/**
+ * Pure input-editing helpers for the TUI prompt.
+ *
+ * Word-boundary semantics, word-jump targets, and word-deletion helpers
+ * used by Ctrl+Left/Right/Backspace/Delete/W. These are buffer-pure — they
+ * take a string and a cursor index and return a number or a new buffer;
+ * no React, no refs, no side effects. This makes them trivial to test
+ * (see tests/input-editing-baseline.test.ts).
+ *
+ * Chip-awareness (attachment tokens like `[pasted #N]`, `[file:path]`,
+ * `[image #N]`) is preserved: a chip is treated as a single atomic word
+ * so Ctrl+Backspace on one deletes the whole chip, not a single character.
+ *
+ * Word-boundary policy (Adım 4 of the TUI input refactor):
+ *   Separators are whitespace and most ASCII punctuation, EXCEPT the
+ *   underscore, which counts as a word character. Rationale:
+ *     - Paths (`src/foo/bar.ts`) break at `/` and `.` so Ctrl+Backspace
+ *       deletes one segment, not the whole path.
+ *     - Kebab-case (`--foo-bar`) breaks at `-`, matching CLI flag habits.
+ *     - Snake_case (`my_var_name`) stays ONE word so a single Ctrl+
+ *       Backspace deletes the whole identifier, matching how identifiers
+ *       read in code.
+ *   Underscore is the lone punctuation char kept as a word character; if
+ *   your editing flow prefers it as a separator, narrow `WORD_SEPARATORS`.
+ */
+/**
+ * Is `ch` a word separator? `undefined` (cursor at a boundary / out of
+ * range) is treated as a separator so the walk loops terminate cleanly.
+ * Whitespace matches `\s`; everything else must be in WORD_SEPARATORS.
+ */
+export declare function isInputWordSeparator(ch: string | undefined): boolean;
+/**
+ * Index of the start of the word immediately before `cursor` — the jump
+ * target for Ctrl+Left and the delete-start for Ctrl+Backspace / Ctrl+W.
+ *
+ * If the cursor sits inside or just after an attachment chip, returns the
+ * chip's start index (whole-chip jump). Otherwise walks left over trailing
+ * separators, then over the preceding word run.
+ */
+export declare function previousInputWordStart(buffer: string, cursor: number): number;
+/**
+ * Index of the start of the word immediately after `cursor` — the jump
+ * target for Ctrl+Right. If the cursor is inside a chip, jumps past it.
+ * Skips any trailing separators so the cursor lands ON the next word,
+ * not in the gap.
+ */
+export declare function nextInputWordStart(buffer: string, cursor: number): number;
+/**
+ * Result of a word-delete operation: the new buffer and where the cursor
+ * should land in it. `null` means there is nothing to delete (cursor at
+ * the relevant boundary).
+ */
+export interface WordDeleteResult {
+    buffer: string;
+    cursor: number;
+}
+/**
+ * Delete the word immediately before the cursor. Used by Ctrl+Backspace
+ * and Ctrl+W (identical behaviour — Ctrl+W is the Unix shell convention,
+ * Ctrl+Backspace is the GUI convention; both delete one word back).
+ *
+ * Chip-aware: if the cursor sits inside an attachment chip, the whole chip
+ * is removed. If the chip ends exactly at the cursor, the whole chip is
+ * removed. Otherwise the previous word run (per `isInputWordSeparator`)
+ * is removed along with any trailing separators.
+ */
+export declare function deleteWordBackward(buffer: string, cursor: number): WordDeleteResult | null;
+/**
+ * Delete the word immediately after the cursor. Used by Ctrl+Delete.
+ *
+ * Chip-aware: if the cursor sits inside a chip, the whole chip is removed.
+ * If a chip starts at the cursor, that chip is removed. Otherwise the
+ * following word run is removed.
+ */
+export declare function deleteWordForward(buffer: string, cursor: number): WordDeleteResult | null;
+//# sourceMappingURL=input-editing.d.ts.map

package/dist/input-editing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"input-editing.d.ts","sourceRoot":"","sources":["../src/input-editing.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAgCH;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,EAAE,EAAE,MAAM,GAAG,SAAS,GAAG,OAAO,CAIpE;AAED;;;;;;;GAOG;AACH,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAgB7E;AAED;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAezE;AAED;;;;GAIG;AACH,MAAM,WAAW,gBAAgB;IAC/B,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;CAChB;AAED;;;;;;;;;GASG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,gBAAgB,GAAG,IAAI,CAa1F;AAED;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,gBAAgB,GAAG,IAAI,CAWzF"}

package/dist/input-tokens.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Inline attachment chip token grammar, shared by the editable input for chip
+ * rendering and whole-token cursor deletion. Kept in sync with the
+ * AttachmentStore placeholder regex in @wrongstack/core. Two shapes:
+ *   - seq-keyed  `[pasted|image|file #N …]`  (a cosmetic suffix after the seq,
+ *     e.g. `, 123 lines`, is tolerated; legacy `[file #N]` is included)
+ *   - path-keyed `[file:<path>]`
+ */
+export declare const INLINE_TOKEN_SRC = "\\[(?:pasted|image|file) #\\d+[^\\]]*\\]|\\[file:[^\\]]+\\]";
+/**
+ * If a whole chip ends immediately before `cursor`, return the buffer and
+ * cursor with that chip removed (so one backspace deletes the entire token,
+ * anywhere in the line). Returns null when there's no chip there — the caller
+ * falls back to a single-character delete.
+ */
+export declare function deleteTokenBackward(buffer: string, cursor: number): {
+    buffer: string;
+    cursor: number;
+} | null;
+/**
+ * Length of a chip that starts exactly at `cursor`, or 0 if none — lets a
+ * forward delete drop the whole token in one keystroke.
+ */
+export declare function tokenLengthForward(buffer: string, cursor: number): number;
+export declare function tokenSpanAt(buffer: string, cursor: number): {
+    start: number;
+    end: number;
+} | null;
+export interface ChipSpan {
+    text: string;
+    /** True for an attachment chip token, false for a plain run. */
+    chip: boolean;
+}
+/** Split a string into chip / plain spans for styled rendering. */
+export declare function splitChips(text: string): ChipSpan[];
+/** One rendered cell of the input row. Exactly one of chip/prompt/cursor may be true. */
+export interface InputCell {
+    ch: string;
+    /** Inside an attachment chip token. */
+    chip: boolean;
+    /** Part of the leading prompt (e.g. "› "). */
+    prompt: boolean;
+    /** The single cursor cell (rendered inverse). */
+    cursor: boolean;
+}
+/**
+ * Lay out `prompt + value` into wrapped rows of at most `width` columns, so the
+ * input area can grow to exactly the number of visual lines its content needs.
+ * Char-wrap (not word-wrap) keeps every cell index aligned with the buffer, so
+ * the cursor lands on the right row/column. A cursor at end-of-buffer gets a
+ * virtual trailing space cell (which may spill onto a fresh row, exactly like a
+ * terminal). Newlines in `value` start a new row.
+ */
+export declare function layoutInputRows(prompt: string, value: string, cursor: number, width: number): InputCell[][];
+/**
+ * Inverse of {@link layoutInputRows}: given a pointer at visual
+ * `(row, col)` (both 0-based; col is the column WITHIN the input area, i.e. the
+ * prompt occupies the first columns of row 0), return the buffer cursor index
+ * to place the caret. Mirrors layoutInputRows' wrapping exactly so the mapping
+ * matches what's on screen. Clicking the prompt → start of buffer; clicking
+ * past a row's last character → just after it; clicking below all rows → end of
+ * buffer. Exported for the TUI input-click handler and unit tests.
+ */
+export declare function inputIndexAtRowCol(prompt: string, value: string, width: number, row: number, col: number): number;
+//# sourceMappingURL=input-tokens.d.ts.map

package/dist/input-tokens.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"input-tokens.d.ts","sourceRoot":"","sources":["../src/input-tokens.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,eAAO,MAAM,gBAAgB,gEAAgE,CAAC;AAM9F;;;;;GAKG;AACH,wBAAgB,mBAAmB,CACjC,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,GACb;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAK3C;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAGzE;AAED,wBAAgB,WAAW,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAQjG;AAED,MAAM,WAAW,QAAQ;IACvB,IAAI,EAAE,MAAM,CAAC;IACb,gEAAgE;IAChE,IAAI,EAAE,OAAO,CAAC;CACf;AAED,mEAAmE;AACnE,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,QAAQ,EAAE,CAYnD;AAED,yFAAyF;AACzF,MAAM,WAAW,SAAS;IACxB,EAAE,EAAE,MAAM,CAAC;IACX,uCAAuC;IACvC,IAAI,EAAE,OAAO,CAAC;IACd,8CAA8C;IAC9C,MAAM,EAAE,OAAO,CAAC;IAChB,iDAAiD;IACjD,MAAM,EAAE,OAAO,CAAC;CACjB;AAED;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAC7B,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,MAAM,GACZ,SAAS,EAAE,EAAE,CAuCf;AAED;;;;;;;;GAQG;AACH,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,MAAM,EACb,GAAG,EAAE,MAAM,EACX,GAAG,EAAE,MAAM,GACV,MAAM,CAmDR"}

package/dist/kill-slash.d.ts

@@ -0,0 +1,3 @@
+import type { SlashCommand } from '@wrongstack/core';
+export declare function createKillSlashCommand(): SlashCommand;
+//# sourceMappingURL=kill-slash.d.ts.map

package/dist/kill-slash.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"kill-slash.d.ts","sourceRoot":"","sources":["../src/kill-slash.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAYrD,wBAAgB,sBAAsB,IAAI,YAAY,CA8CrD"}

package/dist/markdown-table.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Scan a body of prose for GitHub-flavoured markdown tables and replace
+ * each one with a Unicode box-drawing rendering that fits the terminal
+ * width. Cells that overflow their column wrap over multiple lines.
+ *
+ * Non-table prose passes through unchanged.
+ *
+ * Input shape (rest of the doc may surround it):
+ *   | Header A | Header B |
+ *   |----------|---------:|
+ *   | a 1      |       42 |
+ *   | a 2      |        7 |
+ *
+ * Output shape:
+ *   ┌──────────┬──────────┐
+ *   │ Header A │ Header B │
+ *   ├──────────┼──────────┤
+ *   │ a 1      │       42 │
+ *   │ a 2      │        7 │
+ *   └──────────┴──────────┘
+ */
+export declare function renderMarkdownTables(text: string, maxWidth: number): string;
+export declare function detectTable(lines: string[], start: number): number;
+export declare function renderTable(tableLines: string[], maxWidth: number): string;
+/**
+ * Insert zero-width spaces between known ligature-prone character pairs
+ * so that the font renders each character individually. Only applied inside
+ * table cells; code blocks and prose pass through unchanged.
+ */
+export declare function breakLigatures(text: string): string;
+/**
+ * Return the number of terminal columns a string occupies.
+ *
+ * Handles Unicode properly:
+ * - ANSI escape sequences (SGR codes like \x1b[1m, \x1b[0m) are zero-width.
+ * - ZWJ emoji sequences (👨‍👩‍👧, 🧑‍🏫) count as 2 columns total.
+ * - Variation selectors (U+FE0F, U+FE0E) contribute zero width.
+ * - Zero-width characters (ZWJ U+200D, ZWSP U+200B, etc.) contribute zero width.
+ * - Emoji blocks count as 2 columns.
+ * - East Asian Wide/Fullwidth characters count as 2 columns.
+ * - ASCII printable characters count as 1.
+ * - Control characters count as 0.
+ */
+export declare function strWidth(s: string): number;
+//# sourceMappingURL=markdown-table.d.ts.map

package/dist/markdown-table.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"markdown-table.d.ts","sourceRoot":"","sources":["../src/markdown-table.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAgB3E;AAOD,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAUlE;AAkDD,wBAAgB,WAAW,CAAC,UAAU,EAAE,MAAM,EAAE,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CA4B1E;AAyFD;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAgBnD;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAwG1C"}

package/dist/markdown.d.ts

@@ -0,0 +1,47 @@
+import type React from 'react';
+export interface InlineToken {
+    text: string;
+    bold?: boolean | undefined;
+    italic?: boolean | undefined;
+    code?: boolean | undefined;
+    strike?: boolean | undefined;
+}
+/**
+ * Parse one line of prose into inline-emphasis tokens. Markers are stripped
+ * (this is display text, not length-preserving). `_..._` is intentionally NOT
+ * treated as italic so snake_case / file_names aren't mangled. An unterminated
+ * marker is emitted literally so no text is ever lost.
+ *
+ * Results are memoized: repeated calls with the same text return the identical
+ * cached array, eliminating redundant parsing on every TUI re-render.
+ */
+export declare function parseInline(text: string): InlineToken[];
+/**
+ * Render assistant prose with markdown emphasis + block formatting. Tables are
+ * routed through the existing box-drawing renderer; everything else is parsed
+ * line-by-line.
+ *
+ * `contentWidth` is the real inner width of the panel that wraps this view
+ * (the assistant entry's left-border + paddingLeft). When provided, tables
+ * are sized against it so they don't overflow the panel; otherwise we fall
+ * back to `termWidth`, which is correct for callers without a bordered
+ * container. Non-table prose is unaffected — Ink handles its soft wrap.
+ *
+ * `tableWidth` is the width available for tables. When provided, tables are
+ * sized to this value; otherwise falls back to `contentWidth ?? termWidth`.
+ * This allows precise control over table sizing independent of prose width.
+ *
+ * `panelBackground` is the background color of the surrounding panel. When
+ * provided, table rows are padded with trailing spaces colored with this
+ * background so any empty space on the right of a narrow table is filled
+ * with the panel background rather than showing the terminal background.
+ */
+export declare function MarkdownView({ text, termWidth, contentWidth, tableWidth, }: {
+    text: string;
+    termWidth: number;
+    /** Real inner width of the surrounding panel. Defaults to `termWidth`. */
+    contentWidth?: number | undefined;
+    /** Width available for tables. Defaults to `contentWidth ?? termWidth`. */
+    tableWidth?: number | undefined;
+}): React.ReactElement;
+//# sourceMappingURL=markdown.d.ts.map

package/dist/markdown.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"markdown.d.ts","sourceRoot":"","sources":["../src/markdown.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAa/B,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;IAC3B,MAAM,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;IAC7B,IAAI,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;IAC3B,MAAM,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;CAC9B;AAYD;;;;;;;;GAQG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,WAAW,EAAE,CAyEvD;AA2BD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,YAAY,CAAC,EAC3B,IAAI,EACJ,SAAS,EACT,YAAY,EACZ,UAAU,GACX,EAAE;IACD,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;IAClB,0EAA0E;IAC1E,YAAY,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAClC,2EAA2E;IAC3E,UAAU,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CACjC,GAAG,KAAK,CAAC,YAAY,CAwGrB"}

package/dist/mouse.d.ts

@@ -0,0 +1,73 @@
+/**
+ * SGR mouse protocol (xterm DEC private modes). These are INDEPENDENT of the
+ * alternate screen buffer (?1049h): we enable tracking while staying in the
+ * normal buffer so the terminal's native scrollback survives.
+ *
+ *   ?1000h — button press/release tracking (clicks + wheel)
+ *   ?1002h — button-event tracking: adds drag (motion while a button is held)
+ *   ?1003h — any-event tracking: adds hover (motion with no button) — EXPENSIVE,
+ *            one event per cell the cursor crosses; gate behind a setting.
+ *   ?1006h — SGR extended coordinates: `ESC [ < b ; x ; y (M|m)`, no 223-col cap.
+ *
+ * Trade-off: with ANY of these on, the terminal reports the wheel to us as
+ * buttons 64/65 instead of scrolling its own scrollback. Shift+wheel (and
+ * Shift+PgUp) still reach native scrollback in every mainstream terminal, so
+ * users keep a way to scroll history — but plain wheel-scroll of history is
+ * gone while tracking is active. Keep tracking opt-in / overlay-scoped.
+ */
+/** Click + wheel only (mode 1000). Cheapest; no motion events. */
+export declare const MOUSE_CLICK_ON: string;
+/** Click + wheel + drag (motion while a button is held; mode 1002). */
+export declare const MOUSE_DRAG_ON: string;
+/** Click + wheel + free hover (motion with no button; mode 1003). Expensive. */
+export declare const MOUSE_HOVER_ON: string;
+/**
+ * Disable every tracking mode. Disabling a mode that was never set is a no-op,
+ * so this is safe to send unconditionally on cleanup regardless of which
+ * *_ON sequence (if any) was emitted.
+ */
+export declare const MOUSE_OFF: string;
+/**
+ * Enter the alternate screen buffer (DECSET 1049). The normal screen is
+ * saved and restored on exit.
+ */
+export declare const ALT_SCREEN_ON: string;
+/**
+ * Exit the alternate screen buffer (DECRST 1049), restoring the normal screen.
+ */
+export declare const ALT_SCREEN_OFF: string;
+export type MouseEventKind = 'press' | 'release' | 'move' | 'wheel';
+export type MouseButton = 'left' | 'middle' | 'right' | 'none';
+export interface MouseEventInfo {
+    kind: MouseEventKind;
+    button: MouseButton;
+    /** 1-based terminal column (matches the SGR report; column 1 = leftmost). */
+    x: number;
+    /** 1-based terminal row (column 1 = topmost visible row). */
+    y: number;
+    /** Wheel direction: +1 = up (away from user), -1 = down, 0 = not a wheel event. */
+    wheel: number;
+    shift: boolean;
+    /** Alt/Meta modifier. */
+    meta: boolean;
+    ctrl: boolean;
+    /** True for motion events (button-held drag, or free hover). */
+    motion: boolean;
+}
+/**
+ * Parse a single, whole SGR mouse report into a structured event. Returns null
+ * when `data` is not exactly one report.
+ */
+export declare function parseMouseEvent(data: string): MouseEventInfo | null;
+/**
+ * Scan raw stdin data for ALL SGR mouse reports, in order. A fast wheel scroll
+ * coalesces several reports into one chunk; returns an empty array when the
+ * data contains no report.
+ */
+export declare function parseMouseEvents(data: string): MouseEventInfo[];
+/**
+ * True when `input` (Ink's already-ESC-stripped text) is a leaked mouse report.
+ * The input layer drops these so they never land in the buffer as typed text.
+ */
+export declare function isLeakedMouseInput(input: string): boolean;
+//# sourceMappingURL=mouse.d.ts.map

package/dist/mouse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mouse.d.ts","sourceRoot":"","sources":["../src/mouse.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAIH,kEAAkE;AAClE,eAAO,MAAM,cAAc,QAA+B,CAAC;AAC3D,uEAAuE;AACvE,eAAO,MAAM,aAAa,QAA4C,CAAC;AACvE,gFAAgF;AAChF,eAAO,MAAM,cAAc,QAA4C,CAAC;AACxE;;;;GAIG;AACH,eAAO,MAAM,SAAS,QAAyD,CAAC;AAEhF;;;GAGG;AACH,eAAO,MAAM,aAAa,QAAkB,CAAC;AAE7C;;GAEG;AACH,eAAO,MAAM,cAAc,QAAkB,CAAC;AAE9C,MAAM,MAAM,cAAc,GAAG,OAAO,GAAG,SAAS,GAAG,MAAM,GAAG,OAAO,CAAC;AACpE,MAAM,MAAM,WAAW,GAAG,MAAM,GAAG,QAAQ,GAAG,OAAO,GAAG,MAAM,CAAC;AAE/D,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,cAAc,CAAC;IACrB,MAAM,EAAE,WAAW,CAAC;IACpB,6EAA6E;IAC7E,CAAC,EAAE,MAAM,CAAC;IACV,6DAA6D;IAC7D,CAAC,EAAE,MAAM,CAAC;IACV,mFAAmF;IACnF,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,OAAO,CAAC;IACf,yBAAyB;IACzB,IAAI,EAAE,OAAO,CAAC;IACd,IAAI,EAAE,OAAO,CAAC;IACd,gEAAgE;IAChE,MAAM,EAAE,OAAO,CAAC;CACjB;AA8CD;;;GAGG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,cAAc,GAAG,IAAI,CASnE;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,cAAc,EAAE,CAa/D;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAEzD"}

package/dist/on-panel-open.d.ts

@@ -0,0 +1,62 @@
+import type { Action } from './app-reducer.js';
+import type { PluginPickerItem } from './components/plugin-picker.js';
+/**
+ * Action strings that the bridge recognises. Mirrored from the reducer's
+ * `Action` type union but kept as a string allow-list here so an unrecognised
+ * action can return `false` (text fallback) without crashing.
+ */
+export type PanelAction = 'pluginPickerOpen' | 'mcpPickerOpen' | 'toolsPickerOpen' | 'brainOpen' | 'helpOpen' | 'shadowOpen' | 'projectPickerOpen' | 'statuslineOpen' | 'authOpen' | 'authOauthOpen' | 'modePickerOpen' | 'toggleMonitor' | 'toggleAuditPanel' | 'toggleAgentsMonitor' | 'toggleWorktreeMonitor' | 'togglePlanPanel' | 'toggleKanbanPanel' | 'toggleTodosMonitor' | 'toggleQueuePanel' | 'toggleProcessList' | 'toggleGoalPanel' | 'toggleSessionsPanel' | 'toggleCoordinatorMonitor' | (string & {});
+export interface PanelOpenDeps {
+    /**
+     * Reducer dispatcher. For an action that has typed reducer cases the
+     * caller passes a narrowed `Dispatch<Action>`; for the action-typed-aliasing
+     * cases below we widen via `dispatch as (a: Action) => void` internally.
+     */
+    dispatch: (action: Action) => void;
+    /** Async opener for the project picker panel (F1). Fetches items first. */
+    openProjectPicker: () => void | Promise<unknown>;
+    /** Opener for the statusline picker; computes the hiddenItems snapshot. */
+    openStatuslinePicker: () => void;
+    /**
+     * Opener for the interactive auth panel (`/auth`). Returns false when the
+     * CLI didn't provide an auth host — the slash command then falls back to
+     * its plain-text output. Optional so older hosts keep working.
+     */
+    openAuthPanel?: ((view?: 'list' | 'oauth') => boolean) | undefined;
+    /**
+     * Async opener for the mode picker (`/mode`). Fetches all modes + active
+     * mode from the host and dispatches modePickerOpen with the populated list.
+     */
+    openModePicker?: (() => void | Promise<unknown>) | undefined;
+    /**
+     * Async opener for the Brain panel (`/brain`). Fetches current risk level
+     * and decision log from the host, then dispatches brainOpen.
+     */
+    openBrainPanel?: (() => void | Promise<unknown>) | undefined;
+    /**
+     * Async opener for the Shadow Agent panel (`/shadow`). Fetches shadow state
+     * from the host, then dispatches shadowOpen.
+     */
+    openShadowPanel?: (() => void | Promise<unknown>) | undefined;
+    /**
+     * Opener for the Help panel (`/help`). Builds entries from the slash
+     * command registry and dispatches helpOpen with the populated list.
+     */
+    openHelpPanel?: (() => void | Promise<unknown>) | undefined;
+}
+/**
+ * Build the dispatcher that lives at `onPanelOpen.current(action)`.
+ *
+ * Returns `true` when the action was handled (so the slash command suppresses
+ * its text fallback), or `false` when the action is not in the catalogue
+ * (so the slash command can print its plain-text response — the headless /
+ * REPL fallback path).
+ */
+export declare function createPanelOpenDispatcher(deps: PanelOpenDeps): (action: string) => boolean;
+/**
+ * Re-export PluginPickerItem so consumers of the dispatcher can construct
+ * typed items without an extra import. Kept as a re-export rather than a
+ * duplicate so the type lives in one place.
+ */
+export type { PluginPickerItem };
+//# sourceMappingURL=on-panel-open.d.ts.map

package/dist/on-panel-open.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"on-panel-open.d.ts","sourceRoot":"","sources":["../src/on-panel-open.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAC/C,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,+BAA+B,CAAC;AAEtE;;;;GAIG;AACH,MAAM,MAAM,WAAW,GACnB,kBAAkB,GAClB,eAAe,GACf,iBAAiB,GACjB,WAAW,GACX,UAAU,GACV,YAAY,GACZ,mBAAmB,GACnB,gBAAgB,GAChB,UAAU,GACV,eAAe,GACf,gBAAgB,GAChB,eAAe,GACf,kBAAkB,GAClB,qBAAqB,GACrB,uBAAuB,GACvB,iBAAiB,GACjB,mBAAmB,GACnB,oBAAoB,GACpB,kBAAkB,GAClB,mBAAmB,GACnB,iBAAiB,GACjB,qBAAqB,GACrB,0BAA0B,GAC1B,CAAC,MAAM,GAAG,EAAE,CAAC,CAAC;AAElB,MAAM,WAAW,aAAa;IAC5B;;;;OAIG;IACH,QAAQ,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,CAAC;IACnC,2EAA2E;IAC3E,iBAAiB,EAAE,MAAM,IAAI,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IACjD,2EAA2E;IAC3E,oBAAoB,EAAE,MAAM,IAAI,CAAC;IACjC;;;;OAIG;IACH,aAAa,CAAC,EAAE,CAAC,CAAC,IAAI,CAAC,EAAE,MAAM,GAAG,OAAO,KAAK,OAAO,CAAC,GAAG,SAAS,CAAC;IACnE;;;OAGG;IACH,cAAc,CAAC,EAAE,CAAC,MAAM,IAAI,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC,GAAG,SAAS,CAAC;IAC7D;;;OAGG;IACH,cAAc,CAAC,EAAE,CAAC,MAAM,IAAI,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC,GAAG,SAAS,CAAC;IAC7D;;;OAGG;IACH,eAAe,CAAC,EAAE,CAAC,MAAM,IAAI,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC,GAAG,SAAS,CAAC;IAC9D;;;OAGG;IACH,aAAa,CAAC,EAAE,CAAC,MAAM,IAAI,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC,GAAG,SAAS,CAAC;CAC7D;AAED;;;;;;;GAOG;AACH,wBAAgB,yBAAyB,CAAC,IAAI,EAAE,aAAa,GAAG,CAAC,MAAM,EAAE,MAAM,KAAK,OAAO,CAoF1F;AAED;;;;GAIG;AACH,YAAY,EAAE,gBAAgB,EAAE,CAAC"}

package/dist/paste-accumulator.d.ts

@@ -0,0 +1,19 @@
+export interface PasteFeedResult {
+    /** New accumulator state: a string while mid-paste, `null` when idle. */
+    accum: string | null;
+    /**
+     * The fully-assembled paste payload when an end marker closed it, else
+     * `null` (still buffering).
+     */
+    complete: string | null;
+}
+/**
+ * Feed one keypress fragment into the paste accumulator.
+ *
+ * @param accum current accumulator (`null` when not inside a paste)
+ * @param input the raw keypress string for this event
+ * @returns `null` when `input` is not part of a paste (the caller should
+ *   handle it as normal input); otherwise the updated accumulation state.
+ */
+export declare function feedPaste(accum: string | null, input: string): PasteFeedResult | null;
+//# sourceMappingURL=paste-accumulator.d.ts.map

package/dist/paste-accumulator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"paste-accumulator.d.ts","sourceRoot":"","sources":["../src/paste-accumulator.ts"],"names":[],"mappings":"AAqCA,MAAM,WAAW,eAAe;IAC9B,yEAAyE;IACzE,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB;;;OAGG;IACH,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;CACzB;AAED;;;;;;;GAOG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,EAAE,KAAK,EAAE,MAAM,GAAG,eAAe,GAAG,IAAI,CAyBrF"}

package/dist/ps-slash.d.ts

@@ -0,0 +1,7 @@
+import type { SlashCommand } from '@wrongstack/core';
+/**
+ * `/ps` — pure process list, no side effects.
+ * `/kill` handles listing AND killing.
+ */
+export declare function createPsSlashCommand(): SlashCommand;
+//# sourceMappingURL=ps-slash.d.ts.map

package/dist/ps-slash.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ps-slash.d.ts","sourceRoot":"","sources":["../src/ps-slash.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAGrD;;;GAGG;AACH,wBAAgB,oBAAoB,IAAI,YAAY,CAQnD"}

package/dist/queue-slash.d.ts

@@ -0,0 +1,24 @@
+import type { SlashCommand } from '@wrongstack/core';
+import type { QueueItem } from './app.js';
+/**
+ * Dependencies the `/queue` command needs from the App. The TUI registers
+ * the command at mount time with closures over `getQueue` (reads the latest
+ * queue snapshot via a ref) and the three mutators. The command returns
+ * its output as `{ message }` which the App pipes into history as `info`.
+ */
+export interface QueueSlashDeps {
+    getQueue: () => QueueItem[];
+    clear: () => void;
+    deleteAt: (positions: number[]) => void;
+    /** Whether the mid-run send-mode picker is enabled. */
+    getPickerEnabled?: (() => boolean) | undefined;
+    /** Enable/disable the mid-run send-mode picker (persists). */
+    setPickerEnabled?: ((enabled: boolean) => void) | undefined;
+}
+export declare function createQueueSlashCommand(deps: QueueSlashDeps): SlashCommand;
+/**
+ * Pure logic for the /queue command. Exported separately so tests can
+ * drive it without spinning up Ink.
+ */
+export declare function handleQueueCommand(args: string, deps: QueueSlashDeps): string;
+//# sourceMappingURL=queue-slash.d.ts.map

package/dist/queue-slash.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"queue-slash.d.ts","sourceRoot":"","sources":["../src/queue-slash.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AACrD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,UAAU,CAAC;AAE1C;;;;;GAKG;AACH,MAAM,WAAW,cAAc;IAC7B,QAAQ,EAAE,MAAM,SAAS,EAAE,CAAC;IAC5B,KAAK,EAAE,MAAM,IAAI,CAAC;IAClB,QAAQ,EAAE,CAAC,SAAS,EAAE,MAAM,EAAE,KAAK,IAAI,CAAC;IACxC,uDAAuD;IACvD,gBAAgB,CAAC,EAAE,CAAC,MAAM,OAAO,CAAC,GAAG,SAAS,CAAC;IAC/C,8DAA8D;IAC9D,gBAAgB,CAAC,EAAE,CAAC,CAAC,OAAO,EAAE,OAAO,KAAK,IAAI,CAAC,GAAG,SAAS,CAAC;CAC7D;AAWD,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,cAAc,GAAG,YAAY,CAS1E;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,cAAc,GAAG,MAAM,CAuE7E"}

package/dist/reducers/fleet.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Fleet & leader sub-reducer for the TUI.
+ *
+ * Handles all fleetSpawn / fleetToolStart / fleetToolEnd / fleetStart /
+ * fleetDelta / fleetMessage / fleetTool / fleetUsage / fleetDone /
+ * fleetBudgetWarning / fleetBudgetExtended / fleetCtxPct / fleetCost /
+ * fleetConcurrency / fleetSeed / fleetBatch / leaderIterStart /
+ * leaderIterEnd / leaderToolStart / leaderToolEnd / leaderCtxPct /
+ * setFleetChat actions.
+ *
+ * Returns the new state when the action is fleet/leader-related, or
+ * null when the action should fall through to the main reducer.
+ */
+import type { Action, State } from '../app-state.js';
+export declare function reduceFleetState(state: State, action: Action): State | null;
+//# sourceMappingURL=fleet.d.ts.map

package/dist/reducers/fleet.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fleet.d.ts","sourceRoot":"","sources":["../../src/reducers/fleet.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAc,KAAK,EAAE,MAAM,iBAAiB,CAAC;AAajE,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,GAAG,KAAK,GAAG,IAAI,CA+W3E"}

package/dist/reducers/helpers.d.ts

@@ -0,0 +1,38 @@
+import type { State } from '../app-state.js';
+import type { ProjectPickerItem } from '../components/project-picker.js';
+type PanelResetState = Pick<State, 'monitorOpen' | 'agentsMonitorOpen' | 'helpOpen' | 'todosMonitorOpen' | 'queuePanelOpen' | 'processListOpen' | 'auditPanelOpen' | 'planPanelOpen' | 'kanbanPanelOpen' | 'goalPanelOpen' | 'sessionsPanelOpen' | 'settingsPicker' | 'statuslinePicker' | 'pluginPicker' | 'mcpPicker' | 'toolsPicker' | 'brainPanel' | 'helpPanel' | 'shadowPanel' | 'authPanel' | 'projectPicker' | 'fKeyPicker' | 'autoPhase' | 'sddBoard' | 'worktreeMonitorOpen' | 'coordinator'>;
+export declare function closePanels(state: State): PanelResetState;
+export declare function clampContextLoad(load: number): number;
+/** Upper bound on the live tool-stream text retained in state. */
+export declare const MAX_TOOL_STREAM_RETAINED_CHARS = 100000;
+/** Upper bound on the assistant/thinking live tail retained in React state. */
+export declare const MAX_ASSISTANT_STREAM_RETAINED_CHARS = 16384;
+/** Caps applied to tool `input` payloads before retention in history entries. */
+export declare const MAX_RETAINED_INPUT_CHARS = 2048;
+export declare const MAX_RETAINED_INPUT_DEPTH = 4;
+export declare const MAX_RETAINED_INPUT_ITEMS = 64;
+/**
+ * Deep-truncate a tool input for long-term retention in history entries.
+ * Strings are capped per-string, arrays/objects are capped in breadth and
+ * depth. Returns the value unchanged when nothing exceeds a cap.
+ *
+ * @public — exported for unit tests
+ */
+export declare function pruneToolInput(value: unknown, depth?: number): unknown;
+/**
+ * Find the first non-divider index in the list. Returns 0 when the list is
+ * empty or contains only dividers.
+ *
+ * @public — exported for unit tests
+ */
+export declare function firstSelectable(items: ProjectPickerItem[]): number;
+/**
+ * Skip divider items at the given index, moving forward (+1) or backward (-1).
+ * Clamps to [0, items.length - 1]. If every item is a divider the index stays
+ * put — the caller should already know the list has at least one selectable.
+ *
+ * @public — exported for unit tests
+ */
+export declare function skipDivider(items: ProjectPickerItem[], idx: number, dir: 1 | -1): number;
+export {};
+//# sourceMappingURL=helpers.d.ts.map

package/dist/reducers/helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../../src/reducers/helpers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,iBAAiB,CAAC;AAC7C,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,iCAAiC,CAAC;AAIzE,KAAK,eAAe,GAAG,IAAI,CACzB,KAAK,EACH,aAAa,GACb,mBAAmB,GACnB,UAAU,GACV,kBAAkB,GAClB,gBAAgB,GAChB,iBAAiB,GACjB,gBAAgB,GAChB,eAAe,GACf,iBAAiB,GACjB,eAAe,GACf,mBAAmB,GACnB,gBAAgB,GAChB,kBAAkB,GAClB,cAAc,GACd,WAAW,GACX,aAAa,GACb,YAAY,GACZ,WAAW,GACX,aAAa,GACb,WAAW,GACX,eAAe,GACf,YAAY,GACZ,WAAW,GACX,UAAU,GACV,qBAAqB,GACrB,aAAa,CAChB,CAAC;AAEF,wBAAgB,WAAW,CAAC,KAAK,EAAE,KAAK,GAAG,eAAe,CA6BzD;AAED,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAGrD;AAID,kEAAkE;AAClE,eAAO,MAAM,8BAA8B,SAAU,CAAC;AAEtD,+EAA+E;AAC/E,eAAO,MAAM,mCAAmC,QAAS,CAAC;AAE1D,iFAAiF;AACjF,eAAO,MAAM,wBAAwB,OAAQ,CAAC;AAC9C,eAAO,MAAM,wBAAwB,IAAI,CAAC;AAC1C,eAAO,MAAM,wBAAwB,KAAK,CAAC;AAE3C;;;;;;GAMG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,OAAO,EAAE,KAAK,SAAI,GAAG,OAAO,CAyBjE;AAID;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,iBAAiB,EAAE,GAAG,MAAM,CAGlE;AAED;;;;;;GAMG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,iBAAiB,EAAE,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,CAAC,GAAG,CAAC,CAAC,GAAG,MAAM,CAaxF"}

package/dist/rehydrate-history.d.ts

@@ -0,0 +1,40 @@
+import type { Message } from '@wrongstack/core';
+import type { HistoryEntry } from './components/history/types.js';
+export declare function contentBlocksText(content: unknown): string;
+/**
+ * Convert restored session messages into TUI history entries so a resumed
+ * session renders its prior conversation visually, not just in the LLM context.
+ *
+ * Order MUST match what the user saw before the crash — assistant text and
+ * tool executions are interleaved chronologically. The data path makes this
+ * straightforward:
+ *
+ *  - `messages` carries user_input / llm_response / tool_result events in
+ *    JSONL order (see DefaultSessionStore.load).
+ *  - For assistant messages whose `content` is an array, tool_use blocks
+ *    appear in JSONL order. Each has a stable `id`.
+ *  - `toolCalls` is the JSONL-ordered list of `tool_call_end` events, each
+ *    carrying the same `id` as the tool_use block it resolves.
+ *
+ * Algorithm:
+ *  - System messages are skipped (not displayed).
+ *  - User messages → `kind: 'user'`.
+ *  - Assistant messages → `kind: 'assistant'` (text only; tool_use blocks
+ *    are dropped from the body since the tool entry renders the execution).
+ *  - After each assistant message, emit a `kind: 'tool'` entry for each
+ *    tool_use id that appears in that assistant's content, looking up the
+ *    matching tool_call_end by id. If the assistant has multiple tool_use
+ *    blocks, the tool entries appear in the same order as those blocks.
+ *  - Unmatched tool_call_ends (legacy / id drift) are appended at the end
+ *    in their original JSONL order so they aren't silently dropped.
+ */
+export declare function rehydrateHistory(messages: Message[], startId: number, toolCalls?: Array<{
+    name: string;
+    id: string;
+    durationMs: number;
+    ok: boolean;
+    outputBytes?: number | undefined;
+    outputTokens?: number | undefined;
+    outputLines?: number | undefined;
+}> | undefined): HistoryEntry[];
+//# sourceMappingURL=rehydrate-history.d.ts.map

package/dist/rehydrate-history.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rehydrate-history.d.ts","sourceRoot":"","sources":["../src/rehydrate-history.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAgB,OAAO,EAAE,MAAM,kBAAkB,CAAC;AAC9D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,+BAA+B,CAAC;AAElE,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,OAAO,GAAG,MAAM,CAa1D;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,gBAAgB,CAC9B,QAAQ,EAAE,OAAO,EAAE,EACnB,OAAO,EAAE,MAAM,EACf,SAAS,CAAC,EACN,KAAK,CAAC;IACJ,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,EAAE,MAAM,CAAC;IACX,UAAU,EAAE,MAAM,CAAC;IACnB,EAAE,EAAE,OAAO,CAAC;IACZ,WAAW,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACjC,YAAY,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAClC,WAAW,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CAClC,CAAC,GACF,SAAS,GACZ,YAAY,EAAE,CAiFhB"}