@seekbuddy/dsh-ui 0.2.0-beta.0 → 0.2.0-beta.1

package/dist/types/DetailDocument.d.ts

@@ -0,0 +1,77 @@
+import { type ReactNode } from 'react';
+import { type MarkdownLabels, type MarkdownPathImages } from './markdown/MarkdownText.js';
+/** 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;
+    readonly codeBlock: string;
+    readonly wrap: string;
+    readonly unwrap: 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;

package/dist/types/DisclosureRow.d.ts

@@ -8,13 +8,15 @@ export interface DisclosureRowProps {
     onToggle: () => void;
     /** Animate the complete header while its owning operation is running. */
     running?: boolean | undefined;
-    /** Makes the complete title row the disclosure target. */
+    /** Makes the title row the disclosure target; with an accessory, it shrinks to its content width. */
     expandOnRowClick?: boolean | undefined;
     /** Replaces the collapsed icon with a chevron while the row is hovered. */
     previewChevron?: boolean | undefined;
     /** Keeps `collapsedContent` inline while open. */
     keepContentWhenOpen?: boolean | undefined;
     collapsedContent?: ReactNode;
+    /** Independent action beside the title, outside the disclosure target and shimmer. */
+    headerAccessory?: ReactNode;
     children?: ReactNode;
     className?: string | undefined;
     rowClassName?: string | undefined;
@@ -32,4 +34,4 @@ export interface DisclosureRowProps {
  * @param props - Visual content, controlled state, and interaction policy.
  * @returns the disclosure row.
  */
-export declare const DisclosureRow: import("react").MemoExoticComponent<({ icon, title, open, expandable, onToggle, running, expandOnRowClick, previewChevron, keepContentWhenOpen, collapsedContent, children, className, rowClassName, contentClassName, contentLayoutClassName, leadingClassName, chevronClassName, titleClassName, }: DisclosureRowProps) => import("react").JSX.Element>;
+export declare const DisclosureRow: import("react").MemoExoticComponent<({ icon, title, open, expandable, onToggle, running, expandOnRowClick, previewChevron, keepContentWhenOpen, collapsedContent, headerAccessory, children, className, rowClassName, contentClassName, contentLayoutClassName, leadingClassName, chevronClassName, titleClassName, }: DisclosureRowProps) => import("react").JSX.Element>;

package/dist/types/DraggableImage.d.ts

@@ -0,0 +1,18 @@
+/** Original-image drag gestures owned by a presentation primitive. */
+import { type ImgHTMLAttributes } from 'react';
+import type { FileDragActions } from './file-drag-actions.js';
+/** Image presentation plus original content and explicit file preparation callbacks. */
+export interface DraggableImageProps extends Omit<ImgHTMLAttributes<HTMLImageElement>, 'src' | 'draggable' | 'onDragStart' | 'onDragEnd' | 'onPointerEnter' | 'onPointerLeave' | 'onPointerDown' | 'onPointerUp' | 'onClickCapture'> {
+    readonly fileDrag: FileDragActions;
+    readonly src: string;
+    readonly name: string;
+    readonly resourceAddress?: string | undefined;
+    readonly original?: File | undefined;
+}
+/**
+ * Render an image with original-file dragging; using explicit application-owned callbacks.
+ * @param props - image attributes, original filename and file preparation callbacks.
+ * @param ref - image element for measurement and pointer-mode bindings.
+ * @returns a draggable image that suppresses only the mouse click following its drag.
+ */
+export declare const DraggableImage: import("react").ForwardRefExoticComponent<DraggableImageProps & import("react").RefAttributes<HTMLImageElement>>;

package/dist/types/HoverCard.d.ts

@@ -1,28 +1,36 @@
 import type { ReactNode, RefObject } from 'react';
 /**
- * Render an anchor with a hover-triggered preview card, hidden while a tooltip within the anchor is visible.
+ * Render an anchor with a hover-triggered preview card independently of nested tooltips.
+ * Touch entry does not open a preview or intercept the anchor's action.
  * @param props.anchor - the hover target (rendered in place inside a wrapper span).
  * @param props.content - card content; the pointer may rest on it, so it is
  * readable and selectable, but it carries no dismissal affordance of its own.
  * @param props.openDelayMs - hover dwell before the card shows (default 500).
  * @param props.variant - compact card beside the anchor, or a preview above/below it
- * with 24px side insets, a 420px height cap, frame-top clearance, and 100ms opacity transitions.
+ * with 24px side insets, a 420px height cap, the frame-top clearance (capped below an anchor inside the top strip),
+ * and 100ms opacity transitions.
  * @param props.widthAnchorRef - optional element whose width and horizontal position size the preview.
  * @param props.inline - keep the anchor in prose; show a contained preview on hover or keyboard focus.
+ * Its hover region connects the anchor and preview across the visual gap.
+ * @param props.fitContent - size an inline card to its content within the usual width cap.
  * @param props.disabled - suppress opening; turning true dismisses an open card.
+ * @param props.grouped - share first-display dwell across the surrounding list and active portal.
+ * Group replacement removes the previous card immediately, including a fading preview.
  * @param props.copyText - optional primary value copied by activation and
  * included in the card's accessible name.
  * @param props.copyLabel - localized accessible activation-label prefix.
  * @param props.copiedLabel - localized visible success label.
  * @returns anchor wrapper with the conditional portaled card.
  */
-export declare function HoverCard({ anchor, content, openDelayMs, disabled, copyText, copyLabel, copiedLabel, variant, widthAnchorRef, inline, }: {
+export declare function HoverCard({ anchor, content, openDelayMs, disabled, grouped, copyText, copyLabel, copiedLabel, variant, widthAnchorRef, inline, fitContent, }: {
     anchor: ReactNode;
     /** Inline media preview using the shared menu material and keyboard focus. */
     inline?: boolean;
+    fitContent?: boolean;
     content: ReactNode;
     openDelayMs?: number;
     disabled?: boolean;
+    grouped?: boolean;
     variant?: 'compact' | 'preview';
     widthAnchorRef?: RefObject<HTMLElement | null>;
 } & ({

package/dist/types/HoverCardGroup.d.ts

@@ -0,0 +1,24 @@
+import { type ReactNode } from 'react';
+interface GroupState {
+    isWarm: () => boolean;
+    enter: (overCard: boolean) => void;
+    leave: () => void;
+    containsCard: (target: EventTarget | null) => boolean;
+    shown: (owner: symbol, dismiss: () => void, element: HTMLElement) => void;
+    release: (owner: symbol) => void;
+}
+/** Private coordination shared only by opted-in HoverCards inside one mounted group. */
+export declare const HoverCardGroupContext: import("react").Context<GroupState | null>;
+/**
+ * Share first-display dwell across a list and its active portal, including the card's existing pointer grace.
+ * @param props.children - list contents, including opted-in HoverCards.
+ * @param props.className - classes for the physical list container.
+ * @param props.as - physical container tag; use span to preserve inline text layout.
+ * @returns the list container and its private hover coordinator.
+ */
+export declare function HoverCardGroup({ children, className, as: Container, }: {
+    children: ReactNode;
+    className?: string | undefined;
+    as?: 'div' | 'span';
+}): import("react").JSX.Element;
+export {};

package/dist/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. */
@@ -15,12 +16,14 @@ export interface ImageLightboxLabels {
  * @param props.src - the original image URL.
  * @param props.alt - the image's alt text.
  * @param props.labels - dialog and close-control strings.
+ * @param props.contextMenuProps - optional original-image gesture bindings.
  * @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;

package/dist/types/InlineEditor.d.ts

@@ -0,0 +1,22 @@
+/** Multi-line inline editor for short saved-on-Enter drafts such as queued messages and goals. */
+/**
+ * Render an autofocused textarea that grows with its text up to six lines, then scrolls.
+ * A textarea rather than an input: HTML strips newlines from single-line input values.
+ * Enter saves, Shift+Enter breaks the line, Enter during IME composition does nothing,
+ * and Escape cancels.
+ * @param props.value - current draft text.
+ * @param props.label - localized accessible name.
+ * @param props.onChange - receives the edited text.
+ * @param props.onSave - called for a plain Enter.
+ * @param props.onCancel - called for Escape.
+ * @param props.className - extra class for the editor's placement.
+ * @returns the textarea.
+ */
+export declare function InlineEditor({ value, label, onChange, onSave, onCancel, className, }: {
+    value: string;
+    label: string;
+    onChange: (value: string) => void;
+    onSave: () => void;
+    onCancel: () => void;
+    className?: string;
+}): import("react").JSX.Element;

package/dist/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 {
@@ -37,8 +37,16 @@ export interface MenuItemButtonProps {
     shortcut?: MenuItem['shortcut'];
     /** Leading icon (figma .Menu_cell gap 8). */
     icon?: ReactNode;
+    /** Whether this row identifies the currently displayed page or view. */
+    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;
     /**
@@ -60,13 +68,15 @@ export interface MenuItemButtonProps {
  * @param props.children - visible row label.
  * @param props.shortcut - effective key labels and accessible combination.
  * @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, 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
@@ -74,6 +84,9 @@ export declare function MenuItemButton({ children, shortcut, icon, disabled, dan
  * 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).
@@ -87,9 +100,9 @@ export declare function MenuItemButton({ children, shortcut, icon, disabled, dan
  * @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
@@ -100,10 +113,11 @@ export declare function MenuItemButton({ children, shortcut, icon, disabled, dan
  * 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
@@ -118,8 +132,14 @@ export declare function MenuItemButton({ children, shortcut, icon, disabled, dan
  * 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, 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[];
@@ -137,6 +157,7 @@ export declare function Menu({ open, anchor, items, children, selectedId, select
     compact?: boolean;
     selection?: 'check' | 'fill';
     getAnchorRect?: () => DOMRect | null;
+    minWidthFromAnchor?: boolean;
     className?: string | undefined;
     listClassName?: string | undefined;
 }): import("react").JSX.Element;

package/dist/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/dist/types/PermissionIcon.d.ts

@@ -36,3 +36,15 @@ export declare function PermissionIconFullAccessRegular(props: IconProps): React
  * @returns The medium decorative permission glyph.
  */
 export declare function PermissionIconFullAccessMedium(props: IconProps): ReactNode;
+/**
+ * Render the auto-review permission icon with a one-pixel stroke.
+ * @param props - Size and optional class.
+ * @returns The regular decorative permission glyph.
+ */
+export declare function PermissionIconAutoReviewRegular(props: IconProps): ReactNode;
+/**
+ * Render the auto-review permission icon with a 1.3px stroke.
+ * @param props - Size and optional class.
+ * @returns The medium decorative permission glyph.
+ */
+export declare function PermissionIconAutoReviewMedium(props: IconProps): ReactNode;

package/dist/types/QuotePreview.d.ts

@@ -0,0 +1,23 @@
+/** Shared compact presentation for draft and sent text quotes. */
+import type { JSX } from 'react';
+/** Optional whole-quote removal control supplied by an editable owner. */
+export interface QuotePreviewRemoval {
+    /** Localized accessible name for the removal button. */
+    readonly label: string;
+    /** Remove the complete owning quote node. */
+    readonly onRemove: () => void;
+}
+/** Presentation inputs for one compact quote excerpt. */
+export interface QuotePreviewProps {
+    /** Exact selected text rendered inline and exposed in a popover while clipped. */
+    readonly text: string;
+    /** Composer-only removal action; omit for inert sent quotes. */
+    readonly removal?: QuotePreviewRemoval | undefined;
+}
+/**
+ * Render one width-capped quote preview shared by editable drafts and sent messages.
+ * Clipped excerpts open a content-sized, scrollable popover that fits within the viewport.
+ * @param props - selected text and optional localized removal action.
+ * @returns a non-navigating quote preview with a full-text popover only while clipped.
+ */
+export declare function QuotePreview({ text, removal }: QuotePreviewProps): JSX.Element;

package/dist/types/SegmentedTabs.d.ts

@@ -14,12 +14,14 @@ 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;

package/dist/types/TerminalBlock.d.ts

@@ -5,6 +5,8 @@ export declare const DEFAULT_TERMINAL_MAX_LINES = 16;
  * (this package is cordis-free, so copy arrives via props).
  */
 export interface TerminalBlockLabels {
+    /** Accessible name for an overflowing authored command line, numbered from one. */
+    commandLine: (line: number) => string;
     /** Status pill text for a signal-terminated command. */
     signal: (signal: string) => string;
     /** Status pill text for a non-zero exit code. */
@@ -33,7 +35,7 @@ export interface TerminalBlockLabels {
     expand: (hidden: number) => string;
 }
 export interface TerminalBlockProps {
-    /** The command line, rendered verbatim after the prompt label. */
+    /** The command, rendered verbatim after the prompt label; long lines scroll horizontally unless the host enables wrapping. */
     command: string;
     /** Working directory for the prompt label; absent renders a plain `$`. */
     cwd?: string | undefined;
@@ -50,6 +52,12 @@ export interface TerminalBlockProps {
      * line alone; with output it renders the live text under the running state.
      */
     running?: boolean | undefined;
+    /**
+     * The call launches background work (default false). `running` describes the
+     * launch call only; after it returns, retain the command without job status
+     * or output. An explicit `copyText` override remains available.
+     */
+    background?: boolean | undefined;
     /** Height cap in output lines before the middle collapses (default {@link DEFAULT_TERMINAL_MAX_LINES}); Infinity disables the cap. */
     maxLines?: number | undefined;
     /**
@@ -74,4 +82,4 @@ export interface TerminalBlockProps {
  * @param props - see {@link TerminalBlockProps}.
  * @returns the terminal block element.
  */
-export declare function TerminalBlock({ command, cwd, home, output, exitCode, signal, running, maxLines, copyText, runStateDot, className, labels, }: TerminalBlockProps): import("react").JSX.Element;
+export declare function TerminalBlock({ command, cwd, home, output, exitCode, signal, running, background, maxLines, copyText, runStateDot, className, labels, }: TerminalBlockProps): import("react").JSX.Element;

package/dist/types/Tooltip.d.ts

@@ -1,19 +1,20 @@
 /** Anchor-preserving tooltips; an optional body portal escapes clipping containers and stacking contexts that cap the bubble's z-index. */
 import * as React from 'react';
-import type { Context, FocusEventHandler, MouseEventHandler, ReactElement, Ref } from 'react';
-/** Bubble placement relative to the anchor. */
-export type TooltipSide = 'right' | 'bottom' | 'top';
+import type { Context, FocusEventHandler, MouseEventHandler, PointerEventHandler, ReactElement, Ref } from 'react';
+import { type TooltipSide } from './tooltip-placement.js';
+export type { TooltipSide } from './tooltip-placement.js';
 /**
- * Suppression channel for enclosing tooltip and hover-card anchors: a visible
- * tooltip within an anchor withdraws the enclosing preview while its bubble is shown.
+ * Suppression channel for nested tooltips: a visible descendant tooltip
+ * withdraws the enclosing tooltip while its bubble is shown.
  */
 export declare const TooltipSuppression: Context<((suppressed: boolean) => void) | null>;
 /** Props Tooltip injects into its anchor child; the child's own handlers are chained ahead of the tooltip's. */
 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;
@@ -23,30 +24,35 @@ type TooltipLabel = string | (() => string);
  * Attach a hover/focus tooltip to an anchor element.
  * @param props.label - bubble text, or a resolver evaluated only while visible; an empty string shows only shortcut keys.
  * @param props.shortcutKeys - effective key labels rendered as platform-formatted keycaps after optional text.
- * @param props.side - placement relative to the anchor (default 'right').
+ * @param props.side - preferred placement (default 'right'); fitting tries the opposite then perpendicular sides.
  * @param props.align - horizontal anchor-edge alignment for 'bottom'/'top' bubbles: 'end' pins
  * the bubble's right edge to the anchor's (for anchors beside other hover surfaces the centered
- * bubble would overlap); default 'center'. Ignored for side 'right'.
+ * bubble would overlap); default 'center'. Horizontal placements ignore it.
  * @param props.portal - render the bubble under document.body, so an ancestor's clipping or its
  * stacking context (which confines the bubble's z-index to that context) cannot hide it.
  * @param props.delayMs - hover delay in milliseconds (default 0).
  * @param props.focusDelayMs - keyboard focus delay in milliseconds (default 0); blur, click,
  * mouse leave, disabling, and unmount cancel a pending show.
  * @param props.gap - anchor-to-bubble distance in pixels for 'bottom'/'top' bubbles (default 8);
- * ignored for side 'right'.
+ * horizontal placements use 10px, including after a flip.
  * @param props.disabled - suppress the bubble while true; the anchor renders identically so
  * 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.
- * @param props.openOnClick - clicking also pins the bubble for reading; another click, Escape,
+ * half-viewport cap would render a slab wider than the surface the anchor sits on; always bounded by viewport margins.
+ * @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.
  * @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.
+ * 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;
@@ -58,6 +64,6 @@ export declare function Tooltip({ label, shortcutKeys, side, align, delayMs, foc
     portal?: boolean;
     maxWidth?: number;
     openOnClick?: boolean;
+    onlyWhenClipped?: boolean;
     children: ReactElement<AnchorProps>;
 }): React.JSX.Element;
-export {};

package/dist/types/UserMessageBubble.d.ts

@@ -0,0 +1,10 @@
+/** 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;

package/dist/types/ZoomControls.d.ts

@@ -0,0 +1,26 @@
+import { type DocumentZoomLabels } from './document-zoom.js';
+/** Live percentage display updated independently from the document tree. */
+export interface ZoomControlsHandle {
+    /** @param zoom - current gesture scale multiplier. */
+    showZoom: (zoom: number) => void;
+}
+/**
+ * Present optional fitting, fixed presets, and incremental controls.
+ * @param props - committed `zoom`, optional `fit` row (omitted: no fitting row), localized labels, `visible`, optional
+ *   owner `className`, and zoom and activity callbacks.
+ * @param ref - `showZoom` displays a transient scale until `zoom` changes.
+ * @returns a localized zoom toolbar.
+ */
+export declare const ZoomControls: import("react").ForwardRefExoticComponent<{
+    readonly zoom: number;
+    readonly fit?: {
+        readonly label: string;
+        readonly selected: boolean;
+        readonly onSelect: () => void;
+    } | undefined;
+    readonly className?: string | undefined;
+    readonly labels: DocumentZoomLabels;
+    readonly visible: boolean;
+    readonly onZoom: (zoom: number) => void;
+    readonly onActiveChange: (active: boolean) => void;
+} & import("react").RefAttributes<ZoomControlsHandle>>;

package/dist/types/blocks.d.ts

@@ -2,6 +2,8 @@ export { JsonTree } from './JsonTree.js';
 export type { JsonTreeProps, JsonTreeLabels } from './JsonTree.js';
 export { TerminalBlock, DEFAULT_TERMINAL_MAX_LINES } from './TerminalBlock.js';
 export type { TerminalBlockProps, TerminalBlockLabels } from './TerminalBlock.js';
+export { CommandText } from './CommandText.js';
+export type { CommandTextProps } from './CommandText.js';
 export { ReadBlock, DEFAULT_READ_MAX_LINES } from './ReadBlock.js';
 export type { ReadBlockProps, ReadBlockLine, ReadBlockLabels } from './ReadBlock.js';
 export { DiffBlock, DEFAULT_DIFF_MAX_LINES, diffTotals } from './DiffBlock.js';

package/dist/types/document-zoom.d.ts

@@ -0,0 +1,16 @@
+/** Shared fixed document scales used by preview surfaces and their controls. */
+/** Fixed scale limits, incremental step, and menu choices. */
+export declare const DOCUMENT_ZOOM: {
+    readonly minimum: 0.25;
+    readonly maximum: 4;
+    readonly step: 0.25;
+    readonly presets: readonly [0.25, 0.5, 1, 1.5, 2];
+};
+/** Localized labels supplied by the document renderer. */
+export interface DocumentZoomLabels {
+    readonly controls: string;
+    readonly menu: string;
+    readonly out: string;
+    readonly into: string;
+    readonly value: (percent: number) => string;
+}

package/dist/types/file-drag-actions.d.ts

@@ -0,0 +1,36 @@
+/** Stable file preparation callbacks supplied by a transfer-owning plugin. */
+/** Caller-supplied export naming, shared by Web and Desktop (`@deepseek-ai/dsh-util-file-drag`). */
+export interface DragFileName {
+    readonly name?: string | undefined;
+    readonly mediaType: string;
+    readonly outputExtension?: string | undefined;
+}
+/** Content source and optional Host-verifiable identity of its unmodified local original. */
+export type FileDragSource = DragFileName & {
+    readonly resourceAddress?: string | undefined;
+} & ({
+    readonly kind: 'blob';
+    readonly blob: Blob;
+} | {
+    readonly kind: 'url';
+    readonly url: string;
+});
+/** Prepared operation; release cancels unused resources without ending an active browser transfer. */
+export interface PreparedFileDrag {
+    /**
+     * Start the prepared transfer while the browser payload is writable.
+     * @param transfer - writable dragstart payload.
+     * @param source - native source node, retained through drag end.
+     * @returns true for browser dragging; false when native dragging takes over.
+     */
+    start(transfer: DataTransfer, source: HTMLElement): boolean;
+    /** Release this preparation once the pointer leaves or the source unmounts. */
+    release(): void;
+}
+/** Presentation sees preparation and feedback; transport selection belongs to the plugin. */
+export interface FileDragActions {
+    /** @param source - file content and export name. @param signal - preparation cancellation. @returns the ready start/release operation. */
+    prepare(source: FileDragSource, signal: AbortSignal): Promise<PreparedFileDrag>;
+    /** Display the plugin's localized retry message, independently of the originating component. */
+    reportFailure(): void;
+}