@deepseek-harness-tui/dsh-tui 0.8.7 → 0.9.0

package/lib/types/ink/timeline-rail.d.ts

@@ -0,0 +1,138 @@
+/**
+ * Timeline rail — the pure geometry model behind the fullscreen
+ * transcript's turn navigator (a port of Grok Build's timeline sidebar
+ * semantics onto the dsh Ink tree).
+ *
+ * The rail is a 2-column gutter REPLACING the classic scrollbar: one tick
+ * per user turn, where tick position encodes CONVERSATION ORDER, not
+ * scroll proportion. Geometry is computed into a single frozen structure
+ * consumed by both the renderer and mouse hit-testing, so what you see is
+ * always what you can click ("看得到但点不中" impossible by construction).
+ *
+ * Viewport semantics (all derived from the same turn-top list, mirroring
+ * grok-pager's ScrollbackState):
+ *
+ *  - active: the LAST turn whose prompt top is at-or-above the viewport
+ *    top (the turn whose content owns the top row — "the turn being
+ *    read"). When pre-turn content (logo / loaded-context panel) owns the
+ *    top, the FIRST turn stands in. Never the newest-turn clamp: its
+ *    one-step-off-bottom highlight leap is exactly what this rule avoids.
+ *  - up target: the last turn STRICTLY above the viewport top. From
+ *    mid-turn it first aligns the current turn's own prompt, and it can
+ *    never name a trailing turn no scroll could bring to the top
+ *    (the stuck-▲ bug).
+ *  - down target: the FIRST turn whose prompt top is strictly below the
+ *    viewport top AND reachable (top ≤ maxScroll — the renderer clamps
+ *    scrollTop to maxScroll, so a turn below it could never own the top
+ *    row; naming it would make ▼ repeat itself forever).
+ *
+ * Not ported (deliberately): ratatui Buffer drawing and Rust state
+ * organization — algorithms only, per the reference report.
+ */
+/** Columns the rail reserves (widest tick glyph). */
+export declare const RAIL_WIDTH = 2;
+/** Terminals narrower than this hide the rail (transcript needs the cols). */
+export declare const RAIL_MIN_TERMINAL_WIDTH = 60;
+/** Fewer turns than this and the rail is noise. */
+export declare const RAIL_MIN_TURNS = 2;
+/** Stored preview cap (chars). Render paths re-truncate to card width. */
+export declare const PREVIEW_MAX_CHARS = 120;
+/** One user turn, as the rail sees it. Identity is the row id — never an
+ *  array index (deletion / rewind / loadOlder would mis-target it). */
+export interface TimelineTurn {
+    /** ChatRow id of the user message (jump/preview target). */
+    id: number;
+    /** Content-space top of the prompt TEXT (scrollTo(target) pins it to
+     *  the viewport top). */
+    top: number;
+    /** First non-empty prompt line, char-capped (see clipPreview). */
+    preview: string;
+    /**
+     * True while the row sits BEFORE the fold window (older than the most
+     * recent MAX_RENDERED_ROWS rows): its top is unknown (unmounted since
+     * before the fold; `top` carries −1) and clicking the tick must first
+     * reveal the folded history (Chat: showAll + force-mount + seek) rather
+     * than scrollTo(−1). Rendering a tick for it is still correct — the
+     * turn EXISTS and is navigable, it is just folded away right now
+     * (drawing only window turns read as "the rail covers just 2-3 nodes"
+     * on tool-heavy sessions where 300 rows ≈ a handful of turns).
+     */
+    folded?: boolean;
+}
+/** The per-commit snapshot MessageList reports and the rail + sticky
+ *  header consume — one source so the two can never disagree. */
+export interface TimelineSnapshot {
+    /** Turns in conversation order. */
+    turns: ReadonlyArray<TimelineTurn>;
+    /** Turn owning the viewport top row; first turn while pre-turn content
+     *  owns the top; null only when there are no turns. */
+    activeId: number | null;
+    /** ▲ target (strictly above the top), null at the first turn. */
+    upId: number | null;
+    /** ▼ target (below the top and reachable), null at the end. */
+    downId: number | null;
+}
+/** Per-render rail geometry: where the ticks and chevrons landed. */
+export interface RailGeometry {
+    /** Turn-index window shown as ticks: [windowStart, windowEnd). */
+    windowStart: number;
+    windowEnd: number;
+    /** Row of the ▲ chevron (block-local, within the rail column). */
+    upRow: number;
+    /** Row of the first tick. */
+    tickTop: number;
+    /** Row of the ▼ chevron. */
+    downRow: number;
+}
+/** What a rail row is. */
+export type RailHit = {
+    kind: 'up';
+} | {
+    kind: 'down';
+} | {
+    kind: 'tick';
+    index: number;
+};
+/** Single eligibility policy: setting, terminal width, turn count, and
+ *  geometric feasibility in one place. */
+export declare function railEligible(opts: {
+    turnCount: number;
+    terminalWidth: number;
+    viewportRows: number;
+    /** False when the content fits the viewport (inline mode / fresh
+     *  session): nothing to navigate, the terminal's own scrollback owns
+     *  the wheel. */
+    scrollable: boolean;
+}): boolean;
+/**
+ * Compute rail geometry, or null when the rail must not render.
+ *
+ * Windowing: when turns outnumber tick rows (viewport − 2 chevrons), slide
+ * a window around the ACTIVE turn; at the bottom prefer the tail so the
+ * newest ticks stay visible — but never exclude the active turn, or no
+ * tick would highlight. The chevron+tick block is vertically centered in
+ * the rail column.
+ */
+export declare function computeRailGeometry(turnCount: number, viewportRows: number, activeIndex: number | null, atBottom: boolean): RailGeometry | null;
+/**
+ * Which rail interaction a block-local row lands on. The whole rail width
+ * is the hit target (no pixel-hunting the glyph).
+ */
+export declare function railHit(geo: RailGeometry, row: number): RailHit | null;
+/**
+ * First non-empty line, char-capped with a `…` marker. Bounded work: the
+ * scan stops at the first non-empty line and slices at the cap, so a huge
+ * one-line prompt costs O(cap), not O(line length). Char cap (not display
+ * width) on purpose — this bounds the stored snapshot; the hover card
+ * re-wraps to its own width (wrapPreviewLines).
+ */
+export declare function clipPreview(text: string, maxChars?: number): string;
+/**
+ * Wrap a preview to at most 2 lines by DISPLAY width (CJK-aware — a
+ * terminal cell column budget, not a char count). The last line is
+ * ellipsized when content remains. Char-by-char accumulation keeps
+ * surrogate pairs and (best-effort) combining sequences intact by never
+ * splitting below a low surrogate.
+ */
+export declare function wrapPreviewLines(preview: string, maxWidth: number): string[];
+//# sourceMappingURL=timeline-rail.d.ts.map

package/lib/types/ink/timeline-rail.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"timeline-rail.d.ts","sourceRoot":"","sources":["../../../src/ink/timeline-rail.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AAIH,qDAAqD;AACrD,eAAO,MAAM,UAAU,IAAI,CAAA;AAE3B,8EAA8E;AAC9E,eAAO,MAAM,uBAAuB,KAAK,CAAA;AAEzC,mDAAmD;AACnD,eAAO,MAAM,cAAc,IAAI,CAAA;AAE/B,0EAA0E;AAC1E,eAAO,MAAM,iBAAiB,MAAM,CAAA;AAEpC;uEACuE;AACvE,MAAM,WAAW,YAAY;IAC3B,4DAA4D;IAC5D,EAAE,EAAE,MAAM,CAAA;IACV;6BACyB;IACzB,GAAG,EAAE,MAAM,CAAA;IACX,kEAAkE;IAClE,OAAO,EAAE,MAAM,CAAA;IACf;;;;;;;;;OASG;IACH,MAAM,CAAC,EAAE,OAAO,CAAA;CACjB;AAED;iEACiE;AACjE,MAAM,WAAW,gBAAgB;IAC/B,mCAAmC;IACnC,KAAK,EAAE,aAAa,CAAC,YAAY,CAAC,CAAA;IAClC;2DACuD;IACvD,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAA;IACvB,iEAAiE;IACjE,IAAI,EAAE,MAAM,GAAG,IAAI,CAAA;IACnB,+DAA+D;IAC/D,MAAM,EAAE,MAAM,GAAG,IAAI,CAAA;CACtB;AAED,qEAAqE;AACrE,MAAM,WAAW,YAAY;IAC3B,kEAAkE;IAClE,WAAW,EAAE,MAAM,CAAA;IACnB,SAAS,EAAE,MAAM,CAAA;IACjB,kEAAkE;IAClE,KAAK,EAAE,MAAM,CAAA;IACb,6BAA6B;IAC7B,OAAO,EAAE,MAAM,CAAA;IACf,4BAA4B;IAC5B,OAAO,EAAE,MAAM,CAAA;CAChB;AAED,0BAA0B;AAC1B,MAAM,MAAM,OAAO,GACf;IAAE,IAAI,EAAE,IAAI,CAAA;CAAE,GACd;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,GAChB;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAA;AAEnC;0CAC0C;AAC1C,wBAAgB,YAAY,CAAC,IAAI,EAAE;IACjC,SAAS,EAAE,MAAM,CAAA;IACjB,aAAa,EAAE,MAAM,CAAA;IACrB,YAAY,EAAE,MAAM,CAAA;IACpB;;qBAEiB;IACjB,UAAU,EAAE,OAAO,CAAA;CACpB,GAAG,OAAO,CAOV;AAED;;;;;;;;GAQG;AACH,wBAAgB,mBAAmB,CACjC,SAAS,EAAE,MAAM,EACjB,YAAY,EAAE,MAAM,EACpB,WAAW,EAAE,MAAM,GAAG,IAAI,EAC1B,QAAQ,EAAE,OAAO,GAChB,YAAY,GAAG,IAAI,CAuBrB;AAED;;;GAGG;AACH,wBAAgB,OAAO,CAAC,GAAG,EAAE,YAAY,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,GAAG,IAAI,CAUtE;AAED;;;;;;GAMG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,SAAoB,GAAG,MAAM,CAkB9E;AAED;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,EAAE,CA+B5E"}

package/lib/types/ink/timeline-rail.js

@@ -0,0 +1,179 @@
+/**
+ * Timeline rail — the pure geometry model behind the fullscreen
+ * transcript's turn navigator (a port of Grok Build's timeline sidebar
+ * semantics onto the dsh Ink tree).
+ *
+ * The rail is a 2-column gutter REPLACING the classic scrollbar: one tick
+ * per user turn, where tick position encodes CONVERSATION ORDER, not
+ * scroll proportion. Geometry is computed into a single frozen structure
+ * consumed by both the renderer and mouse hit-testing, so what you see is
+ * always what you can click ("看得到但点不中" impossible by construction).
+ *
+ * Viewport semantics (all derived from the same turn-top list, mirroring
+ * grok-pager's ScrollbackState):
+ *
+ *  - active: the LAST turn whose prompt top is at-or-above the viewport
+ *    top (the turn whose content owns the top row — "the turn being
+ *    read"). When pre-turn content (logo / loaded-context panel) owns the
+ *    top, the FIRST turn stands in. Never the newest-turn clamp: its
+ *    one-step-off-bottom highlight leap is exactly what this rule avoids.
+ *  - up target: the last turn STRICTLY above the viewport top. From
+ *    mid-turn it first aligns the current turn's own prompt, and it can
+ *    never name a trailing turn no scroll could bring to the top
+ *    (the stuck-▲ bug).
+ *  - down target: the FIRST turn whose prompt top is strictly below the
+ *    viewport top AND reachable (top ≤ maxScroll — the renderer clamps
+ *    scrollTop to maxScroll, so a turn below it could never own the top
+ *    row; naming it would make ▼ repeat itself forever).
+ *
+ * Not ported (deliberately): ratatui Buffer drawing and Rust state
+ * organization — algorithms only, per the reference report.
+ */
+import { stringWidth } from './stringWidth.js';
+/** Columns the rail reserves (widest tick glyph). */
+export const RAIL_WIDTH = 2;
+/** Terminals narrower than this hide the rail (transcript needs the cols). */
+export const RAIL_MIN_TERMINAL_WIDTH = 60;
+/** Fewer turns than this and the rail is noise. */
+export const RAIL_MIN_TURNS = 2;
+/** Stored preview cap (chars). Render paths re-truncate to card width. */
+export const PREVIEW_MAX_CHARS = 120;
+/** Single eligibility policy: setting, terminal width, turn count, and
+ *  geometric feasibility in one place. */
+export function railEligible(opts) {
+    return (opts.scrollable &&
+        opts.turnCount >= RAIL_MIN_TURNS &&
+        opts.terminalWidth >= RAIL_MIN_TERMINAL_WIDTH &&
+        opts.viewportRows >= 3);
+}
+/**
+ * Compute rail geometry, or null when the rail must not render.
+ *
+ * Windowing: when turns outnumber tick rows (viewport − 2 chevrons), slide
+ * a window around the ACTIVE turn; at the bottom prefer the tail so the
+ * newest ticks stay visible — but never exclude the active turn, or no
+ * tick would highlight. The chevron+tick block is vertically centered in
+ * the rail column.
+ */
+export function computeRailGeometry(turnCount, viewportRows, activeIndex, atBottom) {
+    if (turnCount < RAIL_MIN_TURNS)
+        return null;
+    const maxTicks = viewportRows - 2;
+    if (maxTicks < 1)
+        return null;
+    let start = 0;
+    if (turnCount > maxTicks) {
+        const tailStart = turnCount - maxTicks;
+        const anchor = activeIndex ?? turnCount - 1;
+        start = atBottom
+            ? Math.min(anchor, tailStart)
+            : Math.min(Math.max(0, anchor - Math.floor(maxTicks / 2)), tailStart);
+    }
+    const shown = Math.min(turnCount, maxTicks);
+    // Vertically center the ▲ + ticks + ▼ stack, like the web rail.
+    const blockTop = Math.max(0, Math.floor((viewportRows - (shown + 2)) / 2));
+    return {
+        windowStart: start,
+        windowEnd: start + shown,
+        upRow: blockTop,
+        tickTop: blockTop + 1,
+        downRow: blockTop + 1 + shown,
+    };
+}
+/**
+ * Which rail interaction a block-local row lands on. The whole rail width
+ * is the hit target (no pixel-hunting the glyph).
+ */
+export function railHit(geo, row) {
+    if (row === geo.upRow)
+        return { kind: 'up' };
+    if (row === geo.downRow)
+        return { kind: 'down' };
+    if (row >= geo.tickTop) {
+        const rel = row - geo.tickTop;
+        if (rel < geo.windowEnd - geo.windowStart) {
+            return { kind: 'tick', index: geo.windowStart + rel };
+        }
+    }
+    return null;
+}
+/**
+ * First non-empty line, char-capped with a `…` marker. Bounded work: the
+ * scan stops at the first non-empty line and slices at the cap, so a huge
+ * one-line prompt costs O(cap), not O(line length). Char cap (not display
+ * width) on purpose — this bounds the stored snapshot; the hover card
+ * re-wraps to its own width (wrapPreviewLines).
+ */
+export function clipPreview(text, maxChars = PREVIEW_MAX_CHARS) {
+    let line = '';
+    let rest = text;
+    while (rest.length > 0) {
+        const nl = rest.indexOf('\n');
+        const head = nl === -1 ? rest : rest.slice(0, nl);
+        rest = nl === -1 ? '' : rest.slice(nl + 1);
+        const trimmed = head.trim();
+        if (trimmed.length > 0) {
+            line = trimmed;
+            break;
+        }
+    }
+    if (line.length <= maxChars)
+        return line;
+    // Keep the cap INCLUDING the ellipsis marker, like grok's preview. Slice
+    // by CODE POINTS, not UTF-16 units — a surrogate pair split mid-pair
+    // would emit a lone surrogate to the terminal.
+    return `${[...line].slice(0, maxChars - 1).join('')}…`;
+}
+/**
+ * Wrap a preview to at most 2 lines by DISPLAY width (CJK-aware — a
+ * terminal cell column budget, not a char count). The last line is
+ * ellipsized when content remains. Char-by-char accumulation keeps
+ * surrogate pairs and (best-effort) combining sequences intact by never
+ * splitting below a low surrogate.
+ */
+export function wrapPreviewLines(preview, maxWidth) {
+    const widthOf = stringWidth;
+    const lines = [];
+    let current = '';
+    let currentW = 0;
+    for (const ch of preview) {
+        const w = widthOf(ch);
+        if (w <= 0) {
+            // Zero-width (combining marks, ZWJ): attach for free.
+            current += ch;
+            continue;
+        }
+        if (currentW + w > maxWidth) {
+            if (lines.length === 1) {
+                // Second line full → ellipsize in place and stop.
+                return [lines[0], ellipsize(current, maxWidth)];
+            }
+            lines.push(current);
+            current = ch;
+            currentW = w;
+            continue;
+        }
+        current += ch;
+        currentW += w;
+    }
+    if (current.length > 0 || lines.length === 0)
+        lines.push(current);
+    if (lines.length > 2) {
+        // Cannot happen (we stop after the second), kept for exhaustiveness.
+        return [lines[0], ellipsize(lines[1], maxWidth)];
+    }
+    return lines.slice(0, 2);
+}
+function ellipsize(line, maxWidth) {
+    // Make room for '…' (1 col) then hard-cut by display width.
+    let out = '';
+    let w = 0;
+    for (const ch of line) {
+        const cw = stringWidth(ch);
+        if (cw > 0 && w + cw > maxWidth - 1)
+            break;
+        out += ch;
+        w += cw;
+    }
+    return `${out}…`;
+}

package/lib/types/ink/wrap-text.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"wrap-text.d.ts","sourceRoot":"","sources":["../../../src/ink/wrap-text.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,aAAa,CAAA;AAqCzC;;;;;;GAMG;AACH,MAAM,CAAC,OAAO,UAAU,QAAQ,CAC9B,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,MAAM,CAAC,UAAU,CAAC,GAC3B,MAAM,CA8BR"}
+{"version":3,"file":"wrap-text.d.ts","sourceRoot":"","sources":["../../../src/ink/wrap-text.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,aAAa,CAAA;AAoFzC;;;;;;GAMG;AACH,MAAM,CAAC,OAAO,UAAU,QAAQ,CAC9B,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,MAAM,CAAC,UAAU,CAAC,GAC3B,MAAM,CAoCR"}

package/lib/types/ink/wrap-text.js

@@ -2,6 +2,48 @@ import sliceAnsi from '../utils/sliceAnsi.js';
 import { stringWidth } from './stringWidth.js';
 import { wrapAnsi } from './wrapAnsi.js';
 const ELLIPSIS = '…';
+// --- cross-mount wrap cache ------------------------------------------------
+// wrapText is pure: (text, maxWidth, wrapType) deterministically maps to one
+// output string. Yet before this cache every consumer re-wrapped from
+// scratch:
+//
+//  - dom.ts measureTextNode seeds its per-NODE incremental cache on first
+//    measure; virtualization unmounts scrolled-away rows, so scrolling back
+//    re-mounts the row's Text nodes and re-runs the FULL wrap (wrap-ansi
+//    tokenizes + string-width-measures every word — 100-300ms single-frame
+//    yoga spikes when a row of large settled text scrolls in, the dominant
+//    long-session scroll stall);
+//  - render-node-to-output.ts wraps every VISIBLE text node on every full
+//    paint pass (no per-node cache at all there).
+//
+// A content-addressed LRU here makes both paths O(1) for immutable settled
+// text (Markdown memo keeps content identity stable for the whole session).
+// The key embeds the raw text, so V8's content-hash Map lookup matches even
+// a rebuilt string. Budget mirrors line-width-cache: whole-cache clear on
+// overflow (repopulates within a frame or two).
+const WRAP_CACHE_MAX_ENTRIES = 2048;
+const WRAP_CACHE_MAX_CHARS = 2_000_000;
+const wrapCache = new Map();
+let wrapCacheChars = 0;
+/** Values below this are not worth a cache entry (key building costs about
+ *  as much as the wrap itself for trivial single-word strings). */
+const WRAP_CACHE_MIN_LENGTH = 24;
+function cachedWrap(text, maxWidth, wrapType, compute) {
+    if (text.length < WRAP_CACHE_MIN_LENGTH)
+        return compute();
+    const key = `${maxWidth}\u0000${wrapType}\u0000${text}`;
+    const hit = wrapCache.get(key);
+    if (hit !== undefined)
+        return hit;
+    const result = compute();
+    if (wrapCache.size >= WRAP_CACHE_MAX_ENTRIES || wrapCacheChars + text.length > WRAP_CACHE_MAX_CHARS) {
+        wrapCache.clear();
+        wrapCacheChars = 0;
+    }
+    wrapCache.set(key, result);
+    wrapCacheChars += text.length;
+    return result;
+}
 // sliceAnsi may include a boundary-spanning wide char (e.g. CJK at position
 // end-1 with width 2 overshoots by 1). Retry with a tighter bound once.
 function sliceFit(text, start, end) {
@@ -36,16 +78,16 @@ function truncate(text, columns, position) {
  */
 export default function wrapText(text, maxWidth, wrapType) {
     if (wrapType === 'wrap') {
-        return wrapAnsi(text, maxWidth, {
+        return cachedWrap(text, maxWidth, wrapType, () => wrapAnsi(text, maxWidth, {
             trim: false,
             hard: true,
-        });
+        }));
     }
     if (wrapType === 'wrap-trim') {
-        return wrapAnsi(text, maxWidth, {
+        return cachedWrap(text, maxWidth, wrapType, () => wrapAnsi(text, maxWidth, {
             trim: true,
             hard: true,
-        });
+        }));
     }
     if (wrapType.startsWith('truncate')) {
         let position = 'end';
@@ -55,7 +97,7 @@ export default function wrapText(text, maxWidth, wrapType) {
         if (wrapType === 'truncate-start') {
             position = 'start';
         }
-        return truncate(text, maxWidth, position);
+        return cachedWrap(text, maxWidth, wrapType, () => truncate(text, maxWidth, position));
     }
     return text;
 }

package/lib/types/screens/Chat.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Chat.d.ts","sourceRoot":"","sources":["../../../src/screens/Chat.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAA;AASzB,OAAO,EAAqB,KAAK,OAAO,EAAsE,MAAM,2BAA2B,CAAA;AAC/I,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAA;AAChE,OAAO,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAA;AAC1D,OAAO,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAA;AACzD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,6BAA6B,CAAA;AAGlE,OAAO,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAA;AA4I3D,wBAAgB,IAAI,CAAC,EACnB,OAAO,EACP,aAAa,EACb,aAAa,EACb,gBAAgB,EAChB,eAAe,EACf,kBAAkB,EAClB,MAAM,EACN,QAAQ,EACR,UAAkB,EAClB,cAAc,EAAE,kBAAkB,GACnC,EAAE;IACD,OAAO,EAAE,OAAO,CAAA;IAChB,aAAa,EAAE,aAAa,CAAA;IAC5B;;;;OAIG;IACH,aAAa,CAAC,EAAE,aAAa,CAAA;IAC7B;;;;OAIG;IACH,gBAAgB,CAAC,EAAE,cAAc,CAAA;IACjC,oEAAoE;IACpE,eAAe,CAAC,EAAE,cAAc,CAAA;IAChC,iDAAiD;IACjD,kBAAkB,CAAC,EAAE,eAAe,CAAA;IACpC,MAAM,EAAE,MAAM,IAAI,CAAA;IAClB,wEAAwE;IACxE,QAAQ,CAAC,EAAE,MAAM,IAAI,CAAA;IACrB;;;;;;OAMG;IACH,UAAU,CAAC,EAAE,OAAO,CAAA;IACpB;;;;;;;OAOG;IACH,cAAc,CAAC,EAAE,OAAO,CAAA;CACzB,4BAisEA"}
+{"version":3,"file":"Chat.d.ts","sourceRoot":"","sources":["../../../src/screens/Chat.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAA;AASzB,OAAO,EAAqB,KAAK,OAAO,EAAsE,MAAM,2BAA2B,CAAA;AAC/I,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAA;AAChE,OAAO,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAA;AAC1D,OAAO,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAA;AACzD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,6BAA6B,CAAA;AAGlE,OAAO,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAA;AA8J3D,wBAAgB,IAAI,CAAC,EACnB,OAAO,EACP,aAAa,EACb,aAAa,EACb,gBAAgB,EAChB,eAAe,EACf,kBAAkB,EAClB,MAAM,EACN,QAAQ,EACR,UAAkB,EAClB,cAAc,EAAE,kBAAkB,GACnC,EAAE;IACD,OAAO,EAAE,OAAO,CAAA;IAChB,aAAa,EAAE,aAAa,CAAA;IAC5B;;;;OAIG;IACH,aAAa,CAAC,EAAE,aAAa,CAAA;IAC7B;;;;OAIG;IACH,gBAAgB,CAAC,EAAE,cAAc,CAAA;IACjC,oEAAoE;IACpE,eAAe,CAAC,EAAE,cAAc,CAAA;IAChC,iDAAiD;IACjD,kBAAkB,CAAC,EAAE,eAAe,CAAA;IACpC,MAAM,EAAE,MAAM,IAAI,CAAA;IAClB,wEAAwE;IACxE,QAAQ,CAAC,EAAE,MAAM,IAAI,CAAA;IACrB;;;;;;OAMG;IACH,UAAU,CAAC,EAAE,OAAO,CAAA;IACpB;;;;;;;OAOG;IACH,cAAc,CAAC,EAAE,OAAO,CAAA;CACzB,4BAusFA"}