@seekbuddy/dsh-ui 0.0.0-stage → 0.2.0-beta.1

package/dist/types/JsonTree.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Display copy for the tree's copy affordance; the owner passes localized
+ * labels (this package is cordis-free, so copy arrives via props).
+ */
+export interface JsonTreeLabels {
+    /** Menu item: copy the raw primitive value. */
+    copyValue: string;
+    /** Menu item: copy the value as compact JSON (primitive rows). */
+    copyJson: string;
+    /** Menu item: copy the property path. */
+    copyPath: string;
+    /** Menu item: copy the value as pretty-printed JSON. */
+    copyPrettyJson: string;
+    /** Menu item: copy the value as compact JSON (object rows). */
+    copyCompactJson: string;
+    /** Copy-button state label after a successful copy. */
+    copied: string;
+    /** Copy-button state label after a failed copy. */
+    copyFailed: string;
+    /** Expander aria label while expanded. */
+    collapseNode: string;
+    /** Expander aria label while collapsed. */
+    expandNode: string;
+    /** Copy-button tooltip, given the current action label. */
+    copyButtonTitle: (action: string) => string;
+}
+/** Props for the read-only, token-themed JSON tree. */
+export interface JsonTreeProps {
+    /** Parsed JSON object or array. */
+    data: object | unknown[];
+    /** Accessible label for the tree. */
+    label: string;
+    /** Optional positioning class owned by the caller. */
+    className?: string | undefined;
+    /** Maximum visible lines per collapsed string; defaults to 3. */
+    collapsedStringLines?: number;
+    /** Optional wrap toggle; each expansion reads the shared default without changing other open strings. */
+    stringWrapping?: {
+        /** Localized label for the wrapping toggle. */
+        label: string;
+        /** Read the wrapping preference when a string is expanded. @returns Whether to wrap long lines. */
+        getDefault: () => boolean;
+        /** Remember a user toggle for future expansions. @param wrapped - Whether to wrap long lines. */
+        setDefault: (wrapped: boolean) => void;
+    } | undefined;
+    /** Whether JSON rows expose copy actions. */
+    copyable?: boolean;
+    /** Whether the top-level object or array is always expanded. */
+    expandTopLevel?: boolean;
+    /** Localized display copy supplied by the owning render site. */
+    labels: JsonTreeLabels;
+}
+/**
+ * Render parsed JSON as a compact, keyboard-accessible inspector tree.
+ * @param props - Parsed data, accessible label, and display options.
+ * @returns A read-only JSON tree with an optionally fixed-open top level.
+ */
+export declare function JsonTree({ data, label, className, collapsedStringLines, stringWrapping, copyable, expandTopLevel, labels, }: JsonTreeProps): import("react").JSX.Element;

package/dist/types/LinkIcon.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Leading current-color category glyphs for clickable artifact links. The
+ * public component keeps individual artwork private to the link vocabulary.
+ */
+import type { ReactNode } from 'react';
+import type { IconProps } from './icons/props.js';
+/** Link categories with distinct leading glyphs. */
+export type LinkIconKind = 'url' | 'folder' | 'code' | 'image' | 'document' | 'other';
+/** Props for link icons: the category plus the shared icon sizing seat. */
+export interface LinkIconProps extends IconProps {
+    kind: LinkIconKind;
+    /** Destination of a URL link; known HTTP(S) hosts render their site mark. */
+    href?: string | undefined;
+}
+/**
+ * Derive a file path's link-icon category from its extension. Unknown and
+ * missing extensions fall to `other` (the plain-paper glyph).
+ * @param path - File path as the producing tool spelled it (either separator).
+ * @returns The file's glyph category; never `url` or `folder`.
+ */
+export declare function classifyLinkPath(path: string): LinkIconKind;
+/**
+ * Render a regular one-pixel link icon.
+ * @param props - Link category, size, and optional class.
+ * @returns The regular decorative link glyph.
+ */
+export declare function LinkIconRegular(props: LinkIconProps): ReactNode;
+/**
+ * Render a medium 1.3px link icon.
+ * @param props - Link category, size, and optional class.
+ * @returns The medium decorative link glyph.
+ */
+export declare function LinkIconMedium(props: LinkIconProps): ReactNode;

package/dist/types/Menu.d.ts

@@ -0,0 +1,163 @@
+import type { ReactNode } from 'react';
+/** Selectable row (optionally with a nested submenu). */
+export interface MenuItem {
+    id: string;
+    label: ReactNode;
+    disabled?: boolean;
+    /** Effective binding supplied by the command owner; omitted for unbound actions. */
+    shortcut?: {
+        keys: readonly string[];
+        aria?: string | undefined;
+    };
+    /** Leading icon (figma .Menu_cell gap 8). */
+    icon?: ReactNode;
+    /** Destructive row: error-colored text/icon and danger hover fill. */
+    danger?: boolean;
+    /** Nested card opened to the right on hover/focus. */
+    submenu?: readonly MenuEntry[];
+}
+/** Hairline between item groups (not selectable). */
+export interface MenuSeparator {
+    type: 'separator';
+    id: string;
+}
+/** Non-interactive heading row above a group of items. */
+export interface MenuLabel {
+    type: 'label';
+    id: string;
+    text: string;
+}
+/** One primary-menu entry: a row, a separator, or a heading label. */
+export type MenuEntry = MenuItem | MenuSeparator | MenuLabel;
+/** Props for one component-rendered menu row. */
+export interface MenuItemButtonProps {
+    /** Visible row label. */
+    children: ReactNode;
+    /** Effective binding supplied by the command owner; omitted for unbound actions. */
+    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;
+    /**
+     * Start a new group: a hairline above this row, the same one a
+     * `{ type: 'separator' }` data entry draws. It comes and goes with the row,
+     * so a row that renders nothing leaves no stray line; a data separator
+     * directly before it draws no second line, and the list's first row draws none.
+     */
+    separatorBefore?: boolean;
+    /** Row activation (click, Enter, or Tab on the focused row). */
+    onSelect: () => void;
+}
+/**
+ * Render one `role="menuitem"` row for a {@link Menu} whose rows are
+ * components rather than `items` data: the same markup and styling as a data
+ * row, so it joins the list's keyboard walk and post-selection focus return
+ * without any shared state. Closing the menu stays the owner's decision, as
+ * it is for data rows.
+ * @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, 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
+ * list instead — and Escape or Shift+Tab close it and return focus to the
+ * 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).
+ * @param props.items - selectable data rows and optional separators (default none; with no `children` either, the list is empty).
+ * @param props.selectedId - row shown as selected.
+ * @param props.selectedIds - rows shown as selected when a menu contains independent option groups.
+ * @param props.onSelect - data-row activation callback (not called for disabled rows or submenu parents that only open children).
+ * @param props.onClose - invoked on outside click, Escape, or a window blur
+ * that moved focus into an iframe (the only signal a pointerdown inside a
+ * cross-origin iframe leaves).
+ * @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
+ * 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
+ * gap and a brief overshoot survivable; coming back cancels the close.
+ * @param props.dense - reduce vertical row spacing without changing the standard typography or card width.
+ * @param props.compact - use reduced menu typography and spacing.
+ * @param props.getAnchorRect - portal mode only: supply the anchor rect
+ * 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 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; 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
+ * focus return.
+ * @param props.selection - how a selected row is marked: a trailing check
+ * (`'check'`, default — figma .Menu_cell) or the hover fill held on the row
+ * with no check (`'fill'`, for icon-labelled rows where a trailing glyph
+ * crowds the cell).
+ * @param props.className - extra class on the anchor wrapper span.
+ * @param props.listClassName - extra class on the dropdown card itself; the
+ * only style hook that reaches a portaled list, which renders under
+ * 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, 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[];
+    children?: ReactNode;
+    footer?: readonly MenuEntry[];
+    selectedId?: string | undefined;
+    selectedIds?: readonly string[] | undefined;
+    onSelect?: (id: string) => void;
+    onClose: () => void;
+    align?: 'start' | 'end';
+    side?: 'bottom' | 'top' | 'right';
+    portal?: boolean;
+    closeOnPointerLeave?: boolean;
+    dense?: boolean;
+    compact?: boolean;
+    selection?: 'check' | 'fill';
+    getAnchorRect?: () => DOMRect | null;
+    minWidthFromAnchor?: boolean;
+    className?: string | undefined;
+    listClassName?: string | undefined;
+}): import("react").JSX.Element;

package/dist/types/MenuGroup.d.ts

@@ -0,0 +1,21 @@
+/** Accessible menu groups with shared sticky-heading presentation and viewport observation. */
+import { type ReactNode } from 'react';
+/**
+ * Render a named group with an instance-owned heading id and an inaccessible position sentinel.
+ * @param props - Caller-localized label and optional menu rows.
+ * @returns A section named by its direct heading, followed by the supplied children.
+ */
+export declare function MenuGroup({ label, children }: {
+    label: string;
+    children?: ReactNode;
+}): import("react").JSX.Element;
+/**
+ * Update heading backgrounds asynchronously from native intersection and viewport-size observations.
+ * Headings remain transparent until observations identify a section crossing the viewport top.
+ * Without IntersectionObserver or ResizeObserver, CSS sticky headings remain transparent.
+ * Group membership is captured at setup; dispose before observing changed groups or the same viewport again.
+ * @param viewport - Unpadded, borderless scroll container with direct MenuGroup children.
+ * @returns Cleanup owning both intersection observers and the viewport resize observer; disconnects
+ * them, ignores queued callbacks, and clears managed data-stuck attributes. No valid groups acquires nothing.
+ */
+export declare function observeStickyMenuGroups(viewport: HTMLElement): () => void;

package/dist/types/MenuSurface.d.ts

@@ -0,0 +1,24 @@
+/** 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.
+ * CSS anchors keep each backing aligned during placement, resizing, and nested-menu movement.
+ * @param props - Div content and placement, and compact geometry.
+ * @param ref - The visible menu div, excluding the non-interactive backing.
+ * @returns Menu content plus a backing portal removed with the menu.
+ */
+export declare const MenuSurface: import("react").ForwardRefExoticComponent<MenuSurfaceProps & import("react").RefAttributes<HTMLDivElement>>;

package/dist/types/Modal.d.ts

@@ -0,0 +1,43 @@
+import type { KeyboardEventHandler, ReactNode } from 'react';
+interface ModalBaseProps {
+    open: boolean;
+    onClose: () => void;
+    title: string;
+    description?: string;
+    children?: ReactNode;
+    footer?: ReactNode;
+    className?: string;
+    contentClassName?: string;
+    shortcutModal?: string;
+    onKeyDownCapture?: KeyboardEventHandler<HTMLDivElement>;
+    backdropBlur?: boolean;
+}
+type ModalProps = ModalBaseProps & ({
+    headless: true;
+    closeLabel?: never;
+} | {
+    headless?: false;
+    closeLabel: string;
+});
+/**
+ * Render a centered, body-portaled modal over a blurred page mask.
+ * @param props.open - whether the dialog is showing.
+ * @param props.onClose - application close command, Escape, or mask click; while a menu is open inside the
+ * dialog, Escape belongs to that menu first.
+ * @param props.title - dialog heading (aria-label in every mode).
+ * @param props.closeLabel - localized accessible close-button label.
+ * @param props.description - optional supporting sentence under the title.
+ * @param props.children - dialog body; mark its initial-focus control with
+ * data-modal-autofocus instead of React autoFocus to preserve return focus.
+ * @param props.footer - action row (Cancel / Create).
+ * @param props.contentClassName - optional class for a scrollable content region.
+ * @param props.backdropBlur - disable when the caller already blurs the page; defaults to true.
+ * @param props.shortcutModal - command scope allowed by shortcut owners; unnamed
+ * dialogs block application commands unless their owner allows the "other" scope.
+ * @param props.headless - render children directly in the card (no default
+ * header/close/body chrome); mask, card, Escape, and aria-label remain.
+ * @param props.onKeyDownCapture - handle a nested dialog's keys before the document Escape listeners.
+ * @returns null when closed; otherwise the overlay tree.
+ */
+export declare function Modal({ open, onClose, title, closeLabel, description, children, footer, className, contentClassName, onKeyDownCapture, headless, backdropBlur, shortcutModal, }: ModalProps): import("react").ReactPortal | null;
+export {};

package/dist/types/PermissionIcon.d.ts

@@ -0,0 +1,50 @@
+import type { ReactNode } from 'react';
+import type { IconProps } from './icons/props.js';
+/**
+ * Render the read-only permission icon with a one-pixel stroke.
+ * @param props - Size and optional class.
+ * @returns The regular decorative permission glyph.
+ */
+export declare function PermissionIconReadOnlyRegular(props: IconProps): ReactNode;
+/**
+ * Render the read-only permission icon with a 1.3px stroke.
+ * @param props - Size and optional class.
+ * @returns The medium decorative permission glyph.
+ */
+export declare function PermissionIconReadOnlyMedium(props: IconProps): ReactNode;
+/**
+ * Render the workspace-write permission icon with a one-pixel stroke.
+ * @param props - Size and optional class.
+ * @returns The regular decorative permission glyph.
+ */
+export declare function PermissionIconWorkspaceWriteRegular(props: IconProps): ReactNode;
+/**
+ * Render the workspace-write permission icon with a 1.3px stroke.
+ * @param props - Size and optional class.
+ * @returns The medium decorative permission glyph.
+ */
+export declare function PermissionIconWorkspaceWriteMedium(props: IconProps): ReactNode;
+/**
+ * Render the full-access permission icon with a one-pixel stroke.
+ * @param props - Size and optional class.
+ * @returns The regular decorative permission glyph.
+ */
+export declare function PermissionIconFullAccessRegular(props: IconProps): ReactNode;
+/**
+ * Render the full-access permission icon with a 1.3px stroke.
+ * @param props - Size and optional class.
+ * @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/Pill.d.ts

@@ -0,0 +1,12 @@
+import type { ButtonHTMLAttributes, ReactNode } from 'react';
+/**
+ * Render a pill chip. Interactive when onClick is supplied (renders a button);
+ * otherwise a static span.
+ * @param props.active - selected/active visual state.
+ * @returns pill element.
+ */
+export declare function Pill({ active, className, children, onClick, ...rest }: {
+    active?: boolean;
+    className?: string | undefined;
+    children?: ReactNode;
+} & ButtonHTMLAttributes<HTMLButtonElement>): import("react").JSX.Element;

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/ReadBlock.d.ts

@@ -0,0 +1,47 @@
+import { type CodeToolbarLabels } from './CodeToolbar.js';
+/**
+ * Content lines shown before the height cap collapses the middle. Matches
+ * TerminalBlock's default so a long read and a long command output cut at the
+ * same place in the same flow.
+ */
+export declare const DEFAULT_READ_MAX_LINES = 16;
+/** One line of the read window: its file line number and its text (no trailing newline). */
+export interface ReadBlockLine {
+    /** 1-based line number in the file (a window past an offset keeps the file's own numbering). */
+    number: number;
+    /** The line's text, already truncated to the read tool's per-line cap. */
+    text: string;
+}
+export interface ReadBlockProps {
+    /** Banner label (the file path, or a tool-supplied replacement title); omitted draws no label. */
+    label?: string | undefined;
+    /** The returned window's lines, in file order, each keeping its file line number. */
+    lines: readonly ReadBlockLine[];
+    /** Localized chrome supplied by the owning render site. */
+    labels: ReadBlockLabels;
+    /** Exact total line count in the file, for the "showing N of M" note when the read is a window. */
+    totalLines: number;
+    /** Grammar hint (a file-extension-derived language id); unknown or absent = plain monospace. */
+    lang?: string | undefined;
+    /** Height cap in content lines before the middle collapses (default {@link DEFAULT_READ_MAX_LINES}). */
+    maxLines?: number | undefined;
+    /** Extra class merged onto the wrapper (callers position; this component draws). */
+    className?: string | undefined;
+}
+/** Localized chrome for {@link ReadBlock}. */
+export interface ReadBlockLabels extends CodeToolbarLabels {
+    window: (shown: number, total: number) => string;
+    copy: string;
+    copied: string;
+    collapseAria: string;
+    expandAria: (hidden: number) => string;
+    collapse: string;
+    expand: (hidden: number) => string;
+}
+/**
+ * Render a read tool result as a line-numbered, optionally syntax-highlighted
+ * file view.
+ * @param props - see {@link ReadBlockProps}.
+ * @returns the read block element.
+ */
+export declare function ReadBlock({ label, labels, lines, totalLines, lang, maxLines, className, }: ReadBlockProps): import("react").JSX.Element;

package/dist/types/ReferenceIcon.d.ts

@@ -0,0 +1,20 @@
+import type { ReactNode } from 'react';
+import type { IconProps } from './icons/props.js';
+/** Reference domains with distinct composer and transcript glyphs. */
+export type ReferenceIconKind = 'session' | 'file' | 'folder';
+/** Props shared by inline reference glyphs. */
+export interface ReferenceIconProps extends IconProps {
+    kind: ReferenceIconKind;
+}
+/**
+ * Render a regular one-pixel reference icon.
+ * @param props - Reference kind, size, and optional class.
+ * @returns The regular decorative reference glyph.
+ */
+export declare function ReferenceIconRegular(props: ReferenceIconProps): ReactNode;
+/**
+ * Render a medium 1.3px reference icon.
+ * @param props - Reference kind, size, and optional class.
+ * @returns The medium decorative reference glyph.
+ */
+export declare function ReferenceIconMedium(props: ReferenceIconProps): ReactNode;

package/dist/types/RiskConfirmation.d.ts

@@ -0,0 +1,19 @@
+export interface RiskConfirmationProps {
+    open: boolean;
+    title: string;
+    description: string;
+    acknowledgeLabel: string;
+    cancelLabel: string;
+    closeLabel: string;
+    confirmLabel: string;
+    acknowledged: boolean;
+    disabled?: boolean;
+    onAcknowledgedChange: (acknowledged: boolean) => void;
+    onCancel: () => void;
+    onConfirm: () => void;
+}
+/**
+ * Render one in-page confirmation whose primary action is unavailable until
+ * the caller-controlled acknowledgement is checked.
+ */
+export declare function RiskConfirmation({ open, title, description, acknowledgeLabel, cancelLabel, closeLabel, confirmLabel, acknowledged, disabled, onAcknowledgedChange, onCancel, onConfirm, }: RiskConfirmationProps): import("react").JSX.Element;

package/dist/types/SearchBlock.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Result rows shown before the height cap collapses the middle. Matches
+ * {@link DEFAULT_TERMINAL_MAX_LINES} so a search card and a terminal card cut a
+ * long result at the same place.
+ */
+export declare const DEFAULT_SEARCH_MAX_LINES = 16;
+/** One matched line inside a {@link SearchFileGroup}: its 1-based line number and text. */
+export interface SearchBlockLineMatch {
+    /** 1-based line number of the match within its file. */
+    lineNumber: number;
+    /** The matched line text, as the tool surfaced it. */
+    line: string;
+}
+/** One file's grouped matches, in first-seen file order. */
+export interface SearchFileGroup {
+    /** The file the matches belong to (the display path). */
+    path: string;
+    /** The file's matched lines, in output order. */
+    matches: SearchBlockLineMatch[];
+}
+/** Fields both search shapes carry (the render site positions; this component draws). */
+interface SearchBlockCommon {
+    /** Localized chrome supplied by the owning render site. */
+    labels: SearchBlockLabels;
+    /**
+     * Whether the tool capped the inline result: the shape carries only the
+     * retained results, not every result the search found. The banner summary
+     * folds the pre-cap `total` in (`显示 X / 共 N …`) so the card never presents a
+     * capped result as complete.
+     */
+    truncated: boolean;
+    /** Total results the search found before capping (equals the retained count when not `truncated`). */
+    total: number;
+    /** Height cap in rows before the middle collapses (default {@link DEFAULT_SEARCH_MAX_LINES}). */
+    maxLines?: number | undefined;
+    /** Extra class merged onto the wrapper. */
+    className?: string | undefined;
+}
+/** Localized chrome for {@link SearchBlock}. */
+export interface SearchBlockLabels {
+    pathsSummary: (shown: number, total: number, truncated: boolean) => string;
+    matchesSummary: (shown: number, total: number, files: number, truncated: boolean) => string;
+    copy: string;
+    copied: string;
+    noResults: string;
+    collapseAria: string;
+    expandAria: (hidden: number) => string;
+    collapse: string;
+    expand: (hidden: number) => string;
+}
+/** Props for the grouped-matches (`grep`) shape. */
+export interface SearchMatchesBlockProps extends SearchBlockCommon {
+    kind: 'matches';
+    /** Matched lines grouped by file, in first-seen file order. */
+    files: SearchFileGroup[];
+}
+/** Props for the flat-path (`glob`) shape. */
+export interface SearchPathsBlockProps extends SearchBlockCommon {
+    kind: 'paths';
+    /** The discovered paths, in the tool's result order (the retained page when `truncated`). */
+    paths: string[];
+}
+/** {@link SearchBlock} props: one card, two `kind`-discriminated shapes. */
+export type SearchBlockProps = SearchMatchesBlockProps | SearchPathsBlockProps;
+/**
+ * Render a completed search as a grouped-matches or flat-path card.
+ * @param props - see {@link SearchBlockProps}.
+ * @returns the search block element.
+ */
+export declare function SearchBlock(props: SearchBlockProps): import("react").JSX.Element;
+export {};

package/dist/types/SegmentedControl.d.ts

@@ -0,0 +1,34 @@
+/** One segment of a {@link SegmentedControl}. */
+export interface SegmentedControlOption<Value extends string> {
+    /** The value the owner receives when this segment is chosen. */
+    value: Value;
+    /** Localized segment text. */
+    label: string;
+    /** Whether the segment refuses selection. */
+    disabled?: boolean;
+    /** Localized hover text, typically why the segment is locked. */
+    title?: string;
+}
+/**
+ * Render a segmented control.
+ * @param props.id - the owner's base id: each tab is `<id>-<value>` and names
+ * `<id>-<value>-panel` as the panel it controls.
+ * @param props.value - the selected option's value; the control is fully controlled.
+ * @param props.options - the segments in display order; at least two.
+ * @param props.onChange - called with the value a click or a walk key asks for,
+ * never with the value already selected.
+ * @param props.label - localized accessible name of the tablist.
+ * @param props.disabled - lock every segment, typically while the shown panel
+ * has a write or a fetch in flight that switching would orphan.
+ * @param props.className - extra class for layout placement.
+ * @returns the tablist element.
+ */
+export declare function SegmentedControl<Value extends string>({ id, value, options, onChange, label, disabled, className, }: {
+    id: string;
+    value: Value;
+    options: readonly SegmentedControlOption<Value>[];
+    onChange: (next: Value) => void;
+    label: string;
+    disabled?: boolean;
+    className?: string | undefined;
+}): import("react").JSX.Element;

package/dist/types/SegmentedTabs.d.ts

@@ -0,0 +1,27 @@
+import type { ReactNode } from 'react';
+/** A tab links its localized label to a caller-owned panel. */
+export interface SegmentedTab<Value extends string = string> {
+    value: Value;
+    label: ReactNode;
+    id: string;
+    panelId: string;
+}
+/**
+ * Render equal-width, controlled tabs with a sliding selection indicator.
+ * @param props.items - non-empty ordered tabs with unique values and DOM ids.
+ * @param props.value - selected value, which must belong to items.
+ * @param props.onChange - selection requested by click, Left/Right, or Home/End.
+ * 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, size, }: {
+    items: readonly [SegmentedTab<Value>, ...SegmentedTab<Value>[]];
+    value: Value;
+    onChange: (value: Value) => void;
+    label: string;
+    className?: string | undefined;
+    size?: 'sm' | 'md' | undefined;
+}): ReactNode;