@qilin-agent/client-ui-primitives 3.1.7 → 3.1.8

package/lib/markdown/CodeBlock.module.css

@@ -104,6 +104,29 @@
   color: var(--qilin-alias-label-primary);
 }
 
+/* Line-level hover: the source line under the pointer takes the interactive
+   wash so a reader can follow one line across a wide block. The rule paints a
+   background only — selection, the copy button's textContent read, and the
+   gutter's counters are untouched. Shiki, the plain arm, and the streaming arm
+   all emit one `span.line` per source line, so the selector covers every arm. */
+.block :where(pre) code > :global(.line) {
+  border-radius: 4px;
+  transition: background-color 120ms ease;
+}
+
+@media (hover: hover) {
+  .block :where(pre) code > :global(.line):hover {
+    background-color: var(--qilin-alias-interactive-bg-hover);
+  }
+}
+
+/* A reader who asked for less motion gets the wash without the fade. */
+@media (prefers-reduced-motion: reduce) {
+  .block :where(pre) code > :global(.line) {
+    transition: none;
+  }
+}
+
 .numbered :where(pre) code {
   display: block;
   counter-reset: source-line;

package/lib/markdown/JsonBlock.module.css

@@ -23,7 +23,7 @@
   max-height: 200px;
   overflow: auto;
   background: var(--qilin-alias-markdown-code-block);
-  border: 0.5px solid var(--qilin-alias-border-l1);
+  border: 1px solid var(--qilin-alias-border-l1);
   border-radius: 6px;
   font-family: var(--ds-font-family-code);
   font-size: 11px;

package/lib/markdown/MarkdownText.module.css

@@ -143,7 +143,7 @@
 .markdown hr {
   display: block;
   border: none;
-  height: 0.5px;
+  height: 1px;
   margin: 32px 0;
   background: var(--qilin-alias-border-l2);
 }
@@ -168,7 +168,7 @@
   font-family: var(--ds-font-family-code);
   font-size: 0.875em !important;
   background-color: var(--qilin-alias-markdown-inline-code);
-  border: 0.5px solid var(--qilin-alias-border-l1);
+  border: 1px solid var(--qilin-alias-border-l1);
   border-radius: 6px;
   padding: 0 5px;
 }
@@ -244,7 +244,7 @@
 .tableScroll th {
   text-align: start;
   padding: 10px 16px;
-  border-bottom: 0.5px solid var(--qilin-alias-border-l3);
+  border-bottom: 1px solid var(--qilin-alias-border-l3);
   border-top: none;
   font: var(--qilin-font-markdown-table-head);
   max-width: 320px;
@@ -254,7 +254,7 @@
 
 .tableScroll td {
   padding: 10px 16px;
-  border-bottom: 0.5px solid var(--qilin-alias-border-l2);
+  border-bottom: 1px solid var(--qilin-alias-border-l2);
   font: var(--qilin-font-markdown-table);
   max-width: 320px;
   max-width: min(30vw, 320px);
@@ -305,10 +305,14 @@
    on hover/focus. An underline at rest reads badly inside the code chip, where
    it collides with monospace descenders and the pill background. */
 .fileMention {
-  margin: 0;
-  padding: 0;
+  /* A mention of a file the agent produced highlights its code chip: the
+     negative margins fill the chip's own padding so the accent pill covers
+     the whole chip rather than nesting inside it. */
+  margin: 0 -5px;
+  padding: 0 5px;
   border: none;
-  background: none;
+  border-radius: 6px;
+  background: var(--qilin-specific-bubble-highlight);
   font: inherit;
   font-weight: 500;
   color: var(--qilin-alias-link);

package/lib/settings-form/fields.module.css

@@ -8,7 +8,7 @@
 }
 
 .field + .field {
-  border-top: 0.5px solid var(--qilin-alias-border-l2);
+  border-top: 1px solid var(--qilin-alias-border-l2);
 }
 
 .head {
@@ -107,7 +107,7 @@
 .input {
   height: 34px;
   padding: 0 12px;
-  border: 0.5px solid var(--qilin-alias-border-l4);
+  border: 1px solid var(--qilin-alias-border-l4);
   border-radius: var(--qilin-radius-md);
   background: var(--qilin-alias-bg-layer-3);
   font: inherit;

package/lib/types/AnimatedRows.d.ts

@@ -0,0 +1,46 @@
+/** React-commit-driven movement and entry/exit fades for keyed rows. */
+import { Component, type AriaRole, type ReactNode } from 'react';
+/** Keyed row content, list semantics, and animation readiness. */
+export interface AnimatedRowsProps {
+    children: ReactNode;
+    className: string;
+    role?: AriaRole;
+    label?: string;
+    /** Unique DOM-order keys matching the rendered data-row-key attributes. */
+    rowKeys: readonly string[];
+    ready: boolean;
+    /** Changes that replace the view or reveal hidden rows settle immediately. */
+    resetKey: string;
+}
+interface RowPosition {
+    element: HTMLElement;
+    rect: DOMRect;
+    opacity: number;
+}
+interface RowSnapshot {
+    positions: Map<string, RowPosition>;
+    removed: Map<string, RowPosition>;
+}
+/**
+ * Animates keyed rows only when their rendered membership or order changes.
+ * Motion starts after the first pointer or keyboard input inside the mounted list.
+ * The parent supplies a positioned container for the inert exit overlay.
+ */
+export declare class AnimatedRows extends Component<AnimatedRowsProps> {
+    private armed;
+    private readonly list;
+    private readonly overlay;
+    private readonly movements;
+    private readonly exits;
+    getSnapshotBeforeUpdate(previous: AnimatedRowsProps): RowSnapshot | null;
+    componentDidUpdate(previous: AnimatedRowsProps, _state: unknown, snapshot: RowSnapshot | null): void;
+    componentWillUnmount(): void;
+    private readPositions;
+    private move;
+    private cancelMovements;
+    private removeExit;
+    private clear;
+    render(): ReactNode;
+}
+export {};
+//# sourceMappingURL=AnimatedRows.d.ts.map

package/lib/types/Button.d.ts

@@ -1,18 +1,27 @@
-import type { ButtonHTMLAttributes, ReactNode } from 'react';
+import { type ButtonHTMLAttributes, type ReactNode } from 'react';
 /** Visual variant, each backed by its --qilin-alias-button-* token family. */
 export type ButtonVariant = 'primary' | 'ghost' | 'outline' | 'toolbar';
+/** Props accepted by {@link Button}. */
+export type ButtonProps = {
+    variant?: ButtonVariant;
+    size?: 'md' | 'sm';
+    icon?: ReactNode;
+    className?: string | undefined;
+    children?: ReactNode;
+} & ButtonHTMLAttributes<HTMLButtonElement>;
 /**
  * Render a button.
  * @param props.variant - visual family (default 'ghost').
  * @param props.size - 'md' 36px capsule (figma Button) or 'sm' 28px compact.
  * @param props.icon - optional leading 16px icon node.
+ * @param ref - native button for focus management and overlay anchors.
  * @returns the button element; native button attributes pass through.
  */
-export declare function Button({ variant, size, icon, className, children, ...rest }: {
+export declare const Button: import("react").ForwardRefExoticComponent<{
     variant?: ButtonVariant;
-    size?: 'md' | 'sm';
+    size?: "md" | "sm";
     icon?: ReactNode;
     className?: string | undefined;
     children?: ReactNode;
-} & ButtonHTMLAttributes<HTMLButtonElement>): import("react").JSX.Element;
+} & ButtonHTMLAttributes<HTMLButtonElement> & import("react").RefAttributes<HTMLButtonElement>>;
 //# sourceMappingURL=Button.d.ts.map

package/lib/types/DetailDocument.d.ts

@@ -0,0 +1,79 @@
+import { type ReactNode } from 'react';
+import { type MarkdownLabels, type MarkdownPathImages } from './markdown/MarkdownText.tsx';
+/** One read of a long Markdown description, such as a plugin's detail document. */
+export type DetailDocumentState = {
+    readonly status: 'loading';
+} | {
+    readonly status: 'found';
+    readonly markdown: string;
+} | {
+    readonly status: 'none';
+} | {
+    readonly status: 'error';
+    readonly message: string;
+};
+/** A read as owners track it: in flight, settled with a document or none, or failed with a localized message. */
+export type DetailDocumentRead = undefined | {
+    readonly status: 'loading';
+} | {
+    readonly status: 'ready';
+    readonly markdown: string | undefined;
+} | {
+    readonly status: 'error';
+    readonly message: string;
+};
+/**
+ * The state {@link DetailDocument} shows for an owner's read: loading until it settles, then the document, none, or the
+ * failure.
+ * @param read - the owner's read; undefined before it starts.
+ * @returns the state to show.
+ */
+export declare function detailDocumentState(read: DetailDocumentRead): DetailDocumentState;
+/** Translated strings of a detail document's chrome, as an owner's dictionary supplies them. */
+export interface DetailDocumentCopy {
+    readonly title: string;
+    readonly loading: string;
+    readonly retry: string;
+    readonly copy: string;
+    readonly copied: string;
+    /** Alt text naming an on-page Mermaid diagram. */
+    readonly diagram: string;
+    /** Alt text naming an enlarged Mermaid diagram. */
+    readonly enlarged: string;
+    readonly footnotes: string;
+}
+/**
+ * Assemble reference-stable labels for {@link DetailDocument} from translated strings.
+ * @param copy - the translated strings.
+ * @returns labels that keep their identity while the strings stay equal.
+ */
+export declare function useDetailDocumentLabels(copy: DetailDocumentCopy): DetailDocumentLabels;
+/** Localized chrome of a detail document. */
+export interface DetailDocumentLabels {
+    /** Accessible name of the scrollable document region; the section shows no heading of its own. */
+    readonly title: string;
+    /** Accessible name of the loading placeholder. */
+    readonly loading: string;
+    /** Retry button text. */
+    readonly retry: string;
+    readonly markdown: MarkdownLabels;
+}
+/**
+ * A section showing a long Markdown description, without a heading of its own: three skeleton lines while it loads, the
+ * document once found, or the owner's failure message with a retry. Nothing renders for `none`. A document taller than
+ * the section's height limit scrolls inside it, and the scroll region, named by `labels.title`, takes keyboard focus.
+ * Raw HTML is omitted, relative links stay text, and only images the owner's `images` resolver accepts, or absolute
+ * HTTP(S) images, load.
+ * @param props.state - the read to show.
+ * @param props.labels - localized region name, placeholder name, retry text, and Markdown chrome; keep `markdown` reference-stable.
+ * @param props.images - resolves the document's relative image destinations to displayable URLs.
+ * @param props.onRetry - reads the document again after a failure.
+ * @returns the section, or null.
+ */
+export declare function DetailDocument({ state, labels, images, onRetry }: {
+    readonly state: DetailDocumentState;
+    readonly labels: DetailDocumentLabels;
+    readonly images?: MarkdownPathImages | undefined;
+    readonly onRetry: () => void;
+}): ReactNode;
+//# sourceMappingURL=DetailDocument.d.ts.map

package/lib/types/ImageLightbox.d.ts

@@ -1,3 +1,4 @@
+import type { HTMLAttributes } from 'react';
 /** Lightbox strings the owner resolves from its own locale namespace. */
 export interface ImageLightboxLabels {
     /** Accessible name of the preview dialog. */
@@ -18,10 +19,11 @@ export interface ImageLightboxLabels {
  * @param props.onClose - dismiss callback owned by the opener.
  * @returns the modal preview dialog.
  */
-export declare function ImageLightbox({ src, alt, labels, onClose }: {
+export declare function ImageLightbox({ src, alt, labels, onClose, contextMenuProps }: {
     src: string;
     alt: string;
     labels: ImageLightboxLabels;
     onClose: () => void;
+    contextMenuProps?: Pick<HTMLAttributes<HTMLElement>, 'onContextMenu' | 'onKeyDown' | 'tabIndex'> | undefined;
 }): import("react").ReactPortal;
 //# sourceMappingURL=ImageLightbox.d.ts.map

package/lib/types/Menu.d.ts

@@ -14,7 +14,7 @@ export interface MenuItem {
     /** Destructive row: error-colored text/icon and danger hover fill. */
     danger?: boolean;
     /** Nested card opened to the right on hover/focus. */
-    submenu?: readonly MenuItem[];
+    submenu?: readonly MenuEntry[];
 }
 /** Hairline between item groups (not selectable). */
 export interface MenuSeparator {
@@ -41,6 +41,12 @@ export interface MenuItemButtonProps {
     current?: boolean;
     /** Whether the row cannot be activated. */
     disabled?: boolean;
+    /**
+     * Why the disabled row cannot be activated. The row then stays hoverable and
+     * focusable, shows the reason in a tooltip, and exposes it as the row's
+     * description; an enabled row ignores it.
+     */
+    disabledReason?: string | undefined;
     /** Destructive row: error-colored text/icon and danger hover fill. */
     danger?: boolean;
     /**
@@ -64,12 +70,13 @@ export interface MenuItemButtonProps {
  * @param props.icon - optional leading icon.
  * @param props.current - whether the row identifies the currently displayed page or view.
  * @param props.disabled - whether the row cannot be activated.
+ * @param props.disabledReason - why a disabled row cannot be activated, shown in a tooltip and read as its description.
  * @param props.danger - whether to use the destructive row colors.
  * @param props.separatorBefore - whether this row starts a new group (hairline above it).
  * @param props.onSelect - row activation callback.
  * @returns one menu-item row.
  */
-export declare function MenuItemButton({ children, shortcut, icon, current, disabled, danger, separatorBefore, onSelect, }: MenuItemButtonProps): import("react").JSX.Element;
+export declare function MenuItemButton({ children, shortcut, icon, current, disabled, disabledReason, danger, separatorBefore, onSelect, }: MenuItemButtonProps): import("react").JSX.Element;
 /**
  * Render an anchored dropdown menu. While the list is open its keys mirror the
  * composer's: Tab settles the focused row — from the trigger, Tab enters the
@@ -77,6 +84,9 @@ export declare function MenuItemButton({ children, shortcut, icon, current, disa
  * anchor's first button, and selecting a row does the same — the rows unmount
  * with the list. Only a keyboard on the trigger or inside the list is
  * intercepted; Tab presses elsewhere on the page stay the browser's.
+ * @param props.contextual - cursor positioning, context dismissal, and per-divider icon alignment.
+ * @param props.exiting - retain an inert popup during dismissal or replacement fade.
+ * @param props.returnFocus - original control captured before asynchronous menu preparation.
  * @param props.autoFocus - focus the first item on open; the arrow keys walk the list either way.
  * @param props.open - whether the list is showing (owner-controlled).
  * @param props.anchor - the trigger element (rendered in place).
@@ -90,9 +100,9 @@ export declare function MenuItemButton({ children, shortcut, icon, current, disa
  * @param props.align - list alignment against the anchor (default 'start').
  * @param props.side - open below (`bottom`, default) or above (`top`) the anchor.
  * @param props.portal - render the list into document.body, fixed-positioned
- * from the anchor rect (follows movement and resizing while open). Use when an
- * ancestor's overflow clipping would crop the in-place list; default false
- * keeps the pure-CSS in-place behavior.
+ * synchronously (follows movement, resizing, and browser zoom while open)
+ * and clamped inside the visual viewport. Use when an ancestor's overflow clipping would crop the
+ * in-place list; default false keeps the pure-CSS in-place behavior.
  * @param props.closeOnPointerLeave - close the list once the pointer has left
  * both trigger and list for the pointer grace (default false keeps it open
  * until outside click/Escape/selection). The grace makes the 4px trigger->list
@@ -103,11 +113,11 @@ export declare function MenuItemButton({ children, shortcut, icon, current, disa
  * directly (e.g. from a host-owned trigger button) instead of measuring the
  * Menu's own wrapper span. Required when the wrapper isn't itself laid out at
  * the trigger (render-prop anchors, effect-positioned proxies — measuring the
- * wrapper there races the host's layout effects). Called on open, each animation
- * frame, and scroll/resize; return null to skip placement for that frame.
+ * wrapper there races the host's layout effects). Called while tracking the
+ * anchor and on scroll/resize; return null to defer placement.
  * @param props.minWidthFromAnchor - in portal mode, keep the menu at least as wide as its anchor, bounded by viewport margins.
  * @param props.footer - rows pinned below the scrolling items area, separated
- * by a hairline; they stay visible while the items above scroll.
+ * by a hairline; contextual menus reuse an explicit leading separator. These rows stay visible while the items above scroll.
  * @param props.children - component rows rendered after `items` in the same
  * list, each a `role="menuitem"` button such as {@link MenuItemButton}; they
  * share the keyboard walk, the submenu exclusivity, and the post-selection
@@ -122,8 +132,14 @@ export declare function MenuItemButton({ children, shortcut, icon, current, disa
  * document.body outside the owner's DOM subtree.
  * @returns anchor wrapper with the conditional list.
  */
-export declare function Menu({ open, anchor, items, children, selectedId, selectedIds, onSelect, onClose, align, side, portal, closeOnPointerLeave, dense, compact, autoFocus, selection, getAnchorRect, minWidthFromAnchor, footer, className, listClassName }: {
+export declare function Menu({ open, anchor, items, children, selectedId, selectedIds, onSelect, onClose, align, side, portal, closeOnPointerLeave, dense, compact, autoFocus, selection, getAnchorRect, minWidthFromAnchor, footer, className, listClassName, contextual, exiting, returnFocus }: {
     open: boolean;
+    /** Pointer-positioned popup: cursor clearance, grouped icons, and context gestures. */
+    contextual?: boolean;
+    /** Resolve the original control for focus restoration and inert/hidden dismissal. */
+    returnFocus?: (() => HTMLElement | null) | undefined;
+    /** Retain a dismissed context popup during its short fade. */
+    exiting?: 'dismiss' | 'replace' | undefined;
     autoFocus?: boolean;
     anchor: ReactNode;
     items?: readonly MenuEntry[];

package/lib/types/MenuSurface.d.ts

@@ -1,9 +1,18 @@
 /** Shared menu material and the macOS backing that lets Chromium blur transparent windows. */
 import { type ComponentPropsWithoutRef } from 'react';
+/** Context-menu transition durations in milliseconds, shared with its lifecycle owner. */
+export declare const MENU_TRANSITION_MS: Readonly<{
+    enter: 40;
+    dismiss: 80;
+    replace: 10;
+    prepare: 20;
+}>;
 /** Menu containers preserve native div props and refs. */
 export interface MenuSurfaceProps extends ComponentPropsWithoutRef<'div'> {
     /** Match the shared compact menu's smaller outer radius. */
     compact?: boolean;
+    /** Fade direct content, material, and native backing without isolating the material's backdrop. */
+    phase?: 'enter' | 'dismiss' | 'replace' | undefined;
 }
 /**
  * Paint a menu and, on macOS, an opaque backing behind the page content within its bounds.

package/lib/types/QuotePreview.d.ts

@@ -0,0 +1,26 @@
+import type { JSX } from 'react';
+/** Localized names of the quote controls; a caller owns every string. */
+export interface QuotePreviewLabels {
+    /** Accessible name of the copy control. */
+    readonly copy: string;
+    /** Accessible name after an accepted copy. */
+    readonly copied: string;
+    /** Accessible name of the jump control. */
+    readonly jump: string;
+}
+/** Presentation inputs for one quoted excerpt. */
+export interface QuotePreviewProps {
+    /** Excerpt text as decoded from the message, without its source marker line. */
+    readonly text: string;
+    /** Localized control names. */
+    readonly labels: QuotePreviewLabels;
+    /** Reveal the quoted source; omission hides the jump control. */
+    readonly onJump?: (() => void) | undefined;
+}
+/**
+ * Render one quoted excerpt with its copy and optional jump controls.
+ * @param props - excerpt text, control names, and the reveal action.
+ * @returns the quote surface, with the full text on hover while clipped.
+ */
+export declare function QuotePreview({ text, labels, onJump }: QuotePreviewProps): JSX.Element;
+//# sourceMappingURL=QuotePreview.d.ts.map

package/lib/types/SegmentedTabs.d.ts

@@ -14,13 +14,15 @@ export interface SegmentedTab<Value extends string = string> {
  * Keyboard selection also moves focus; only the selected tab is a tab stop.
  * @param props.label - localized accessible name for the tab list.
  * @param props.className - layout placement; panels remain caller-owned.
+ * @param props.size - `sm` draws 30px tabs with a 2px inset (34px tall); the default `md` draws 34px tabs with a 4px inset (42px tall).
  * @returns the tab list, without its panels.
  */
-export declare function SegmentedTabs<Value extends string>({ items, value, onChange, label, className }: {
+export declare function SegmentedTabs<Value extends string>({ items, value, onChange, label, className, size }: {
     items: readonly [SegmentedTab<Value>, ...SegmentedTab<Value>[]];
     value: Value;
     onChange: (value: Value) => void;
     label: string;
     className?: string | undefined;
+    size?: 'sm' | 'md' | undefined;
 }): ReactNode;
 //# sourceMappingURL=SegmentedTabs.d.ts.map

package/lib/types/Toast.d.ts

@@ -7,6 +7,16 @@ import type { ReactNode } from 'react';
  * transformed or filtered ancestor cannot trap the fixed banner in that
  * ancestor's box.
  *
+ * Actions extend the sentence with inline choices: each renders its plain-text
+ * `prefix` (a connective such as "or") followed by its localized `label` as
+ * clickable text inside the banner. Each press is the owner's to handle (undo
+ * the reported change, then unmount the toast). The banner surface stays
+ * click-through — only the action text takes the pointer — and a fully faded
+ * banner takes no input at all.
+ *
+ * With an unchanged holdMs, a parent rerender does not extend the lifetime:
+ * the completion call reaches the latest onDone handler.
+ *
  * The hold is the owner's to set, because how long a banner has to stay
  * depends on how much there is to read: a one-line limit lands in the default
  * window, while a failure that names what broke does not. One value drives
@@ -18,6 +28,9 @@ import type { ReactNode } from 'react';
  * under `tone="success"`, which brings its own glyph.
  * @param props.tone - 'success' renders the success check as the leading
  * glyph; omitted, the icon seat keeps its warning tint.
+ * @param props.actions - optional inline actions continuing the sentence;
+ * each renders its plain-text `prefix` followed by its localized `label`
+ * as clickable text flowing after `text` as one sentence.
  * @param props.holdMs - full-opacity hold before the fade; defaults to 3000.
  * @param props.anchor - optional element whose horizontal center the banner
  * follows (e.g. the composer card, so the banner centers over the chat column
@@ -25,12 +38,17 @@ import type { ReactNode } from 'react';
  * @param props.onDone - called once the fade completes; unmount the toast here.
  * @returns the floating banner.
  */
-export declare function Toast({ text, icon, tone, anchor, holdMs, onDone }: {
+export declare function Toast({ text, icon, tone, anchor, holdMs, actions, onDone }: {
     text: string;
     icon?: ReactNode;
     tone?: 'success';
     anchor?: HTMLElement | null;
     holdMs?: number;
+    actions?: readonly {
+        label: string;
+        prefix?: string;
+        onClick: () => void;
+    }[];
     onDone: () => void;
 }): import("react").ReactPortal;
 //# sourceMappingURL=Toast.d.ts.map

package/lib/types/Tooltip.d.ts

@@ -1,5 +1,5 @@
 /** Anchor-preserving tooltips; an optional body portal escapes clipping containers and stacking contexts that cap the bubble's z-index. */
-import type { FocusEventHandler, MouseEventHandler, ReactElement, Ref } from 'react';
+import type { FocusEventHandler, MouseEventHandler, PointerEventHandler, ReactElement, Ref } from 'react';
 import { type TooltipSide } from './tooltip-placement.ts';
 export type { TooltipSide } from './tooltip-placement.ts';
 /**
@@ -11,8 +11,9 @@ export declare const TooltipSuppression: import("react").Context<((suppressed: b
 interface AnchorProps {
     'aria-describedby'?: string | undefined;
     ref?: Ref<HTMLElement> | undefined;
-    onMouseEnter?: MouseEventHandler | undefined;
-    onMouseLeave?: MouseEventHandler | undefined;
+    onPointerEnter?: PointerEventHandler | undefined;
+    onPointerLeave?: PointerEventHandler | undefined;
+    onPointerDown?: PointerEventHandler | undefined;
     onClick?: MouseEventHandler | undefined;
     onFocus?: FocusEventHandler | undefined;
     onBlur?: FocusEventHandler | undefined;
@@ -37,17 +38,20 @@ type TooltipLabel = string | (() => string);
  * toggling never remounts it (which would cut its CSS transitions).
  * @param props.maxWidth - bubble width cap in pixels, for labels long enough that the default
  * half-viewport cap would render a slab wider than the surface the anchor sits on; always bounded by viewport margins.
- * @param props.openOnClick - clicking also pins the bubble for reading; another click, Escape,
+ * @param props.openOnClick - clicking or tapping also pins the bubble for reading; another click, Escape,
  * Tab, or an outside pointerdown dismisses it. Defaults to false for ordinary action tooltips.
+ * @param props.onlyWhenClipped - show the bubble only when the anchor or an HTML element inside it
+ * overflows horizontally, measured when the bubble is about to show; for labels that repeat
+ * text an ellipsis may cut off. Defaults to false.
  * @param props.children - a single anchor element; its own ref (callback or object) is forwarded alongside the tooltip's.
- * An anchor that accepts no ref still positions the bubble: a raise records the element the event ran on.
  * @returns the cloned anchor plus a fixed-position bubble, optionally portaled to the body.
  * The bubble stays hidden until ResizeObserver supplies its size for viewport fitting; clicking the
  * anchor dismisses the bubble unless openOnClick is enabled, and focus arriving after a pointer
- * interaction (a closing menu refocusing its trigger) never raises it. When no side fits, the
- * viewport-bounded fallback may overlap the anchor; oversized content is scrollable when pinned.
+ * interaction (a closing menu refocusing its trigger) never raises it. Touch cannot trigger hover
+ * tooltips; tapping still invokes the child's action and can open an openOnClick explanation.
+ * When no side fits, the viewport-bounded fallback may overlap the anchor; oversized content is scrollable when pinned.
  */
-export declare function Tooltip({ label, shortcutKeys, side, align, delayMs, focusDelayMs, gap, disabled, portal, maxWidth, openOnClick, children }: {
+export declare function Tooltip({ label, shortcutKeys, side, align, delayMs, focusDelayMs, gap, disabled, portal, maxWidth, openOnClick, onlyWhenClipped, children }: {
     label: TooltipLabel;
     shortcutKeys?: readonly string[] | undefined;
     side?: TooltipSide;
@@ -59,6 +63,7 @@ export declare function Tooltip({ label, shortcutKeys, side, align, delayMs, foc
     portal?: boolean;
     maxWidth?: number;
     openOnClick?: boolean;
+    onlyWhenClipped?: boolean;
     children: ReactElement<AnchorProps>;
 }): import("react").JSX.Element;
 //# sourceMappingURL=Tooltip.d.ts.map

package/lib/types/UserMessageBubble.d.ts

@@ -0,0 +1,11 @@
+/** Shared user-message background, typography, and content inset. */
+import type { ComponentPropsWithoutRef } from 'react';
+/** Native div attributes for user-authored message content. */
+export type UserMessageBubbleProps = ComponentPropsWithoutRef<'div'>;
+/**
+ * Render user-style message content without row placement or actions.
+ * @param props - Native div attributes and the caller-owned content.
+ * @returns A theme-aware message surface that wraps its content.
+ */
+export declare function UserMessageBubble({ className, ...props }: UserMessageBubbleProps): import("react").JSX.Element;
+//# sourceMappingURL=UserMessageBubble.d.ts.map

package/lib/types/code-highlighting.d.ts

@@ -0,0 +1,12 @@
+import { type HighlightSpan } from './markdown/highlight.ts';
+export { CODE_HIGHLIGHT_EXTENSIONS, languageForPath } from '@qilin-agent/util-code-language';
+/** Highlight one source fragment into one token list per line. */
+export type CodeHighlighter = (code: string) => HighlightSpan[][] | undefined;
+/**
+ * Bind the shared lazy highlighter to one language and refresh after its grammar loads.
+ * @param language - grammar hint selected from the source filename.
+ * @returns a stable fragment highlighter; unknown and loading grammars return `undefined` for plain-text fallback.
+ */
+export declare function useCodeHighlighter(language: string | undefined): CodeHighlighter;
+export type { HighlightSpan };
+//# sourceMappingURL=code-highlighting.d.ts.map

package/lib/types/focus.d.ts

@@ -6,4 +6,12 @@
  * @param options - browser focus options, including scroll preservation.
  */
 export declare function focusWithoutRing(element: HTMLElement, options?: FocusOptions): void;
+/**
+ * Whether this browser runs on a touch-first mobile device.
+ *
+ * The answer is cached, so a caller must not expect it to follow a viewport
+ * resize. It drives input-shape choices only; layout reacts to container width.
+ * @returns `true` on a mobile browser, `false` on a desktop one.
+ */
+export declare function isMobileDevice(): boolean;
 //# sourceMappingURL=focus.d.ts.map

package/lib/types/icons/index.d.ts

@@ -178,6 +178,10 @@ export declare const IconPaperclipOutlineMedium: (props: IconProps) => import("r
 export declare const IconLoadingOutlineRegular: (props: IconProps) => import("react").JSX.Element;
 /** Medium IconLoadingOutline artwork with a 1.3px stroke. */
 export declare const IconLoadingOutlineMedium: (props: IconProps) => import("react").JSX.Element;
+/** Regular one-pixel IconSaveOutline artwork. */
+export declare const IconSaveOutlineRegular: (props: IconProps) => import("react").JSX.Element;
+/** Medium IconSaveOutline artwork with a 1.3px stroke. */
+export declare const IconSaveOutlineMedium: (props: IconProps) => import("react").JSX.Element;
 /** Regular one-pixel IconDownloadOutline artwork. */
 export declare const IconDownloadOutlineRegular: (props: IconProps) => import("react").JSX.Element;
 /** Medium IconDownloadOutline artwork with a 1.3px stroke. */
@@ -270,6 +274,10 @@ export declare const IconQueueOutlineMedium: (props: IconProps) => import("react
 export declare const IconChecklistOutlineRegular: (props: IconProps) => import("react").JSX.Element;
 /** Medium IconChecklistOutline artwork with a 1.3px stroke. */
 export declare const IconChecklistOutlineMedium: (props: IconProps) => import("react").JSX.Element;
+/** Regular one-pixel IconDragHandleOutline artwork. */
+export declare const IconDragHandleOutlineRegular: (props: IconProps) => import("react").JSX.Element;
+/** Medium IconDragHandleOutline artwork with a 1.3px stroke. */
+export declare const IconDragHandleOutlineMedium: (props: IconProps) => import("react").JSX.Element;
 /** Regular one-pixel IconListPenOutline artwork. */
 export declare const IconListPenOutlineRegular: (props: IconProps) => import("react").JSX.Element;
 /** Medium IconListPenOutline artwork with a 1.3px stroke. */

package/lib/types/icons/shared-artwork.d.ts

@@ -38,6 +38,7 @@ export declare const BrowseOutlineArtwork: ({ size, className, strokeWidth }: We
  * @param props - Size, optional CSS class, and inherited stroke width.
  * @returns The decorative SVG artwork.
  */
+export declare const DragHandleOutlineArtwork: ({ size, className, strokeWidth }: WeightedArtworkProps) => import("react").JSX.Element;
 export declare const FolderCloseArtwork: ({ size, className, strokeWidth }: WeightedArtworkProps) => import("react").JSX.Element;
 export {};
 //# sourceMappingURL=shared-artwork.d.ts.map