@qilin-agent/client-ui-primitives 3.1.5 → 3.1.6

package/lib/types/InlineEditor.d.ts

@@ -0,0 +1,23 @@
+/** 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;
+//# sourceMappingURL=InlineEditor.d.ts.map

package/lib/types/Menu.d.ts

@@ -77,17 +77,17 @@ export declare function MenuItemButton({ children, shortcut, icon, disabled, dan
  * @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 rows and optional separators.
+ * @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 - row click callback (not called for disabled rows or submenu parents that only open children).
+ * @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
- * from the anchor rect (repositions on scroll/resize while open). Use when an
+ * 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.
  * @param props.closeOnPointerLeave - close the list once the pointer has left
@@ -100,25 +100,34 @@ 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 and on every
- * scroll/resize; return null to skip placement for that frame.
+ * 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.
  * @param props.footer - rows pinned below the scrolling items area, separated
  * by a hairline; they 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, selectedId, selectedIds, onSelect, onClose, align, side, portal, closeOnPointerLeave, dense, compact, autoFocus, selection, getAnchorRect, footer, className }: {
+export declare function Menu({ open, anchor, items, children, selectedId, selectedIds, onSelect, onClose, align, side, portal, closeOnPointerLeave, dense, compact, autoFocus, selection, getAnchorRect, footer, className, listClassName }: {
     open: boolean;
     autoFocus?: boolean;
     anchor: ReactNode;
-    items: readonly MenuEntry[];
+    items?: readonly MenuEntry[];
+    children?: ReactNode;
     footer?: readonly MenuEntry[];
     selectedId?: string | undefined;
     selectedIds?: readonly string[] | undefined;
-    onSelect: (id: string) => void;
+    onSelect?: (id: string) => void;
     onClose: () => void;
     align?: 'start' | 'end';
     side?: 'bottom' | 'top' | 'right';
@@ -129,5 +138,6 @@ export declare function Menu({ open, anchor, items, selectedId, selectedIds, onS
     selection?: 'check' | 'fill';
     getAnchorRect?: () => DOMRect | null;
     className?: string | undefined;
+    listClassName?: string | undefined;
 }): import("react").JSX.Element;
 //# sourceMappingURL=Menu.d.ts.map

package/lib/types/SecretText.d.ts

@@ -0,0 +1,25 @@
+/** Copy for the control that reveals one masked credential. */
+export interface SecretTextLabels {
+    /** Name while the value stays masked. */
+    readonly reveal: string;
+    /** Name while the value is shown. */
+    readonly hide: string;
+}
+/** Props of one masked credential. */
+export interface SecretTextProps {
+    /** Display form of the range; line breaks stay in place. */
+    readonly masked: string;
+    /** Original spelling, revealed on demand, and the identity that re-masks a different value. */
+    readonly raw: string;
+    /** Reveal-control copy; absent in text that offers no reveal control. */
+    readonly labels?: SecretTextLabels | undefined;
+}
+/**
+ * Draw one credential masked. Interactive text adds a control that reveals or
+ * hides this value; every mount, and every different original value at the same
+ * position, starts masked.
+ * @param props - the masked form, the original spelling, and optional control copy.
+ * @returns the masked run, with the reveal control when copy is supplied.
+ */
+export declare function SecretText({ masked, raw, labels }: SecretTextProps): import("react").JSX.Element;
+//# sourceMappingURL=SecretText.d.ts.map

package/lib/types/SegmentedTabs.d.ts

@@ -0,0 +1,26 @@
+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.
+ * @returns the tab list, without its panels.
+ */
+export declare function SegmentedTabs<Value extends string>({ items, value, onChange, label, className }: {
+    items: readonly [SegmentedTab<Value>, ...SegmentedTab<Value>[]];
+    value: Value;
+    onChange: (value: Value) => void;
+    label: string;
+    className?: string | undefined;
+}): ReactNode;
+//# sourceMappingURL=SegmentedTabs.d.ts.map

package/lib/types/TerminalBlock.d.ts

@@ -52,6 +52,12 @@ export interface TerminalBlockProps {
      * output printed so far when there is any, with no copy control until it settles.
      */
     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.
+     */
+    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;
     /** Extra class merged onto the wrapper (callers position; this component draws). */
@@ -64,5 +70,5 @@ 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, className, labels, }: TerminalBlockProps): import("react").JSX.Element;
+export declare function TerminalBlock({ command, cwd, home, output, exitCode, signal, running, background, maxLines, className, labels, }: TerminalBlockProps): import("react").JSX.Element;
 //# sourceMappingURL=TerminalBlock.d.ts.map

package/lib/types/Tooltip.d.ts

@@ -8,9 +8,11 @@ export type TooltipSide = 'right' | 'bottom' | 'top';
 export declare const TooltipSuppression: import("react").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;
+    onClick?: MouseEventHandler | undefined;
     onFocus?: FocusEventHandler | undefined;
     onBlur?: FocusEventHandler | undefined;
 }
@@ -20,25 +22,32 @@ type TooltipLabel = string | (() => string);
  * @param props.label - bubble text, or a resolver evaluated only while the bubble is visible.
  * @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.delayMs - hover delay in milliseconds; keyboard focus remains immediate.
+ * @param props.delayMs - hover delay in milliseconds (default 0).
+ * @param props.focusDelayMs - keyboard focus delay in milliseconds (default 0); blur, mouse
+ * leave, disabling, and unmount cancel a pending show.
  * @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.portal - render the bubble under document.body, so an ancestor's clipping or its
  * stacking context can neither clip the bubble nor paint over it.
  * @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,
+ * Tab, or an outside pointerdown dismisses it. Defaults to false, leaving an ordinary action
+ * tooltip to hover and focus alone.
  * @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 while hovered/focused.
  */
-export declare function Tooltip({ label, shortcutKeys, side, delayMs, disabled, portal, maxWidth, children }: {
+export declare function Tooltip({ label, shortcutKeys, side, delayMs, focusDelayMs, disabled, portal, maxWidth, openOnClick, children }: {
     label: TooltipLabel;
     shortcutKeys?: readonly string[] | undefined;
     side?: TooltipSide;
     delayMs?: number;
+    focusDelayMs?: number;
     disabled?: boolean;
     portal?: boolean;
     maxWidth?: number;
+    openOnClick?: boolean;
     children: ReactElement<AnchorProps>;
 }): import("react").JSX.Element;
 export {};

package/lib/types/credential-formats.d.ts

@@ -0,0 +1,63 @@
+/**
+ * The credential formats the scanner recognizes, as data: the literal each
+ * format begins with, how its candidate is validated, and the ASCII character
+ * classes those checks use. [format-tables.ts](./format-tables.ts) derives
+ * lookup tables from this list on first use.
+ */
+/** `[A-Za-z0-9_-]` */
+export declare const KEY = 1;
+/** `[A-Za-z0-9]` */
+export declare const ALNUM = 2;
+/** `\w` */
+export declare const WORD = 4;
+/** `[A-Za-z0-9-]` */
+export declare const ALNUM_DASH = 8;
+/** `[A-Z0-9]` */
+export declare const UPPER_ALNUM = 16;
+/** `[A-Z0-9 ]` */
+export declare const LABEL = 32;
+/** `[a-z0-9+.-]` */
+export declare const SCHEME = 64;
+/** `[a-z]` */
+export declare const LOWER = 128;
+/** `[^\s/:@?#]` */
+export declare const USER = 256;
+/** `[^\s/@?#]` */
+export declare const PASSWORD = 512;
+/** A private key block from its `-----BEGIN` line. */
+export declare const KEY_BLOCK = 0;
+/** The password of an address that carries credentials. */
+export declare const ADDRESS = 1;
+/** A provider key or token after its fixed prefix. */
+export declare const PREFIXED = 2;
+/** The whole run, at least `min`. */
+export declare const RUN = 0;
+/** `min` to `max`, then `\b`. */
+export declare const BOUNDED = 1;
+/** At least `min`, with a digit among the first 256. */
+export declare const SK = 2;
+/** Exactly `min`. */
+export declare const GOOGLE = 3;
+/** Three runs joined by `.eyJ` and `.`. */
+export declare const JWT = 4;
+/** One recognized format. */
+export interface CredentialFormat {
+    /** ASCII literal the candidate begins with; no literal occurs inside another. */
+    readonly literal: string;
+    /** Which kind of candidate the literal heads. */
+    readonly kind: typeof KEY_BLOCK | typeof ADDRESS | typeof PREFIXED;
+    /** Prefixed formats only: how the run after the literal is validated. */
+    readonly check: number;
+    /** Prefixed formats only: the class bit of the run after the literal. */
+    readonly run: number;
+    /** Prefixed formats only: run length below which a candidate is not this format. */
+    readonly min: number;
+    /** Prefixed formats only: longest accepted run for `BOUNDED` and `JWT`. */
+    readonly max: number;
+}
+/**
+ * Every prefixed format matches more than the eight characters a mask leaves
+ * readable, so a near miss never exposes a whole value.
+ */
+export declare const CREDENTIAL_FORMATS: readonly CredentialFormat[];
+//# sourceMappingURL=credential-formats.d.ts.map

package/lib/types/credential-masks.d.ts

@@ -0,0 +1,60 @@
+/** Character that replaces each hidden credential character. */
+export declare const MASK = "*";
+/** Builds masks; owns the shared mark strings and its sticky run pattern. */
+export declare class CredentialMasks {
+    private readonly marksOnly;
+    private readonly marksLf;
+    private readonly marksCr;
+    /** Code units that `lines` counts without inspection: neither line breaks nor surrogates. Set `lastIndex` before each test. */
+    private readonly ordinary;
+    /**
+     * The display form of `text[start, end)`, whose earliest candidate has `kind`.
+     * @param text - the queried text.
+     * @param kind - the literal kind of the range's earliest candidate.
+     * @param plain - the range holds only prefixed-format characters: ASCII without line breaks.
+     * @param start - first offset of the range.
+     * @param end - offset after the range.
+     * @returns the mask; line breaks stay in place, one mark per code point.
+     */
+    masked(text: string, kind: number, plain: boolean, start: number, end: number): string;
+    /**
+     * Marks for a run of hidden characters.
+     * @param count - how many marks.
+     * @returns `count` marks, one slice of the shared string where it reaches.
+     */
+    private marks;
+    /**
+     * Marks, then one line break, in a single slice.
+     * @param count - how many marks.
+     * @param code - the line break's code unit, 10 or 13.
+     * @returns `count` marks and that line break.
+     */
+    private marksThen;
+    /**
+     * Keep the `BEGIN` line, the `END` line when present, and every line break; a block written on
+     * one line is masked whole. Both searches stay inside the range, so they cost what the mask costs.
+     * @param text - the queried text.
+     * @param start - first offset of the range.
+     * @param end - offset after the range.
+     * @returns the masked block.
+     */
+    private keyBlock;
+    /**
+     * Replace every character except line breaks; a surrogate pair is one character,
+     * as `[^\r\n]` with the `u` flag counts it. A character loop: a native run could read far past `end`.
+     * @param text - the queried text.
+     * @param start - first offset of the range.
+     * @param end - offset after the range.
+     * @returns the masked range.
+     */
+    private range;
+    /**
+     * `range` for a body that ends at a line break or the end of the text, where native runs stop.
+     * @param text - the queried text.
+     * @param start - first offset of the range.
+     * @param end - offset after the range.
+     * @returns the masked body.
+     */
+    private lines;
+}
+//# sourceMappingURL=credential-masks.d.ts.map

package/lib/types/credential-scanner.d.ts

@@ -0,0 +1,146 @@
+import { type FormatTables } from './format-tables.ts';
+/** One recognized credential range, with the display form that masks it. */
+export interface SecretRange {
+    readonly start: number;
+    readonly end: number;
+    /** Display form of the original range; line breaks stay in place. */
+    readonly masked: string;
+}
+/**
+ * One scanner's state: the tables, its own patterns, and a memo of the last
+ * queried text, which it keeps until a query for another text. Queries are
+ * synchronous and never re-enter, so the patterns' cursors are never shared.
+ */
+export declare class CredentialScanner {
+    private readonly classes;
+    private readonly literals;
+    private readonly literalLength;
+    private readonly literalKind;
+    private readonly literalCheck;
+    private readonly literalMin;
+    private readonly literalMax;
+    private readonly literalOverlap;
+    private readonly ending;
+    private readonly sharedEndings;
+    /** Memo slot of each prefixed format's run class; 0 for `[A-Za-z0-9_-]`, which has four. */
+    private readonly literalSlot;
+    private readonly literalPattern;
+    private readonly prefixes;
+    private readonly keyRun;
+    private readonly userRun;
+    private readonly passwordRun;
+    private readonly nonDigits;
+    private readonly masks;
+    private readonly memo;
+    private text;
+    /**
+     * Build one scanner over shared tables.
+     * @param tables - the tables every scanner shares.
+     */
+    constructor(tables: FormatTables);
+    /**
+     * The nearest credential at or after `from`. Overlapping candidates of any format join the earliest
+     * one and take its mask, so no credential is drawn half masked. Candidates arrive in start order;
+     * an address password waits until the scan passes its start, and no other `://` can occur before
+     * then, because a user name and a password exclude `/`. A password that starts inside a range also
+     * ends inside it: the range holds the `:` before the password, so it is a key block, whose `END`
+     * line has spaces, or one that runs to the end of the text.
+     * @param text - the complete original text.
+     * @param from - the query offset.
+     * @returns the nearest credential range, or undefined when none starts at or after `from`.
+     */
+    match(text: string, from: number): SecretRange | undefined;
+    /**
+     * Memo entry at `index`; the layout keeps every index inside the array.
+     * @param index - the memo index.
+     * @returns the stored offset.
+     */
+    private slot;
+    /**
+     * `\w` at one offset; out of range is not a word character.
+     * @param index - the offset to read.
+     * @returns whether the code unit is a word character.
+     */
+    private isWordAt;
+    /**
+     * `[^\s/:@?#]` for one UTF-16 code unit; NaN, read out of range, is not one.
+     * @param code - the code unit.
+     * @returns whether the code unit may appear in an address user name.
+     */
+    private isUserCode;
+    /**
+     * Index of the literal the prefix scan matched ending at `end`; one literal sharing the ending matches, so the last needs no check.
+     * @param end - the offset after the matched literal.
+     * @returns the literal's index.
+     */
+    private literalEndingAt;
+    /**
+     * End of the `[A-Za-z0-9_-]*` run at `start`, through four memo pairs replaced in turn.
+     * @param start - the run's first offset.
+     * @returns the offset after the run.
+     */
+    private keyRunEnd;
+    /**
+     * End of the run `pattern` matches at `start`, through the memo pair at `slot`.
+     * @param pattern - the sticky run pattern.
+     * @param start - the run's first offset.
+     * @param slot - the memo pair to fill.
+     * @returns the offset after the run.
+     */
+    private memoRunEnd;
+    /**
+     * Offset of the first digit at or after `start`, or the text length.
+     * @param start - the offset to search from.
+     * @returns the digit's offset.
+     */
+    private nextDigit;
+    /**
+     * Offset after `[A-Z0-9 ]{0,40}PRIVATE KEY-----` at `start`, or -1; reads at most 52 characters.
+     * @param start - the offset the label starts at.
+     * @returns the offset after the header label, or -1.
+     */
+    private labelEnd;
+    /**
+     * End of the `-----BEGIN [A-Z0-9 ]{0,40}PRIVATE KEY-----` block at `at`: after its first complete
+     * `END` line, or the end of the text; -1 for an invalid header.
+     * @param at - the offset of the `-----BEGIN ` literal.
+     * @returns the offset after the block, or -1.
+     */
+    private keyBlockEnd;
+    /**
+     * Whether `\b[a-z][a-z0-9+.-]{1,15}` ends at `at`; reads at most 17 characters back.
+     * @param at - the offset after the scheme.
+     * @returns whether a scheme ends there.
+     */
+    private schemeBefore;
+    /**
+     * The password in `\b[a-z][a-z0-9+.-]{1,15}://[^\s/:@?#]{0,256}:[^\s/@?#]+@` for the `://` at
+     * `at`; neither part crosses `?` or `#`, where the authority ends. Callers pass a `://` at or after
+     * the query offset, or one whose user name reaches it, so the password never starts before it.
+     * @param at - the offset of the `://` literal.
+     * @returns the password end with its start in the memo, or -1.
+     */
+    private addressPassword;
+    /**
+     * The address password at or after `from` whose `://` starts before `from`, as `addressPassword`
+     * returns it. The walk back over the user name runs only when a `:`, a password, and `@` follow.
+     * @param from - the query offset.
+     * @returns the password end with its start in the memo, or -1.
+     */
+    private addressBefore;
+    /**
+     * End of the prefixed credential whose literal starts at `at`, or -1.
+     * @param literal - the literal's index.
+     * @param at - the offset of the literal.
+     * @returns the offset after the credential, or -1.
+     */
+    private prefixedEnd;
+}
+/**
+ * Every credential in `text`, in start order, each with the display form that
+ * masks it.
+ * @param text - the original user text.
+ * @returns the masked ranges; empty when the text holds no recognized credential.
+ */
+export declare function scanSecrets(text: string): readonly SecretRange[];
+//# sourceMappingURL=credential-scanner.d.ts.map

package/lib/types/format-tables.d.ts

@@ -0,0 +1,29 @@
+/** Tables indexed by format position in `CREDENTIAL_FORMATS`, by ASCII code unit, or by a literal's last two code units. */
+export interface FormatTables {
+    /** Class bits per ASCII code unit. */
+    readonly classes: Uint16Array;
+    readonly literals: readonly string[];
+    readonly literalLength: Uint8Array;
+    readonly literalKind: Uint8Array;
+    readonly literalCheck: Uint8Array;
+    readonly literalRun: Uint16Array;
+    readonly literalMin: Int32Array;
+    readonly literalMax: Int32Array;
+    /**
+     * Length of the longest proper suffix of each literal that begins a literal.
+     * The scan resumes there, so a key block whose first dash ends `sk-` is still seen.
+     */
+    readonly literalOverlap: Uint8Array;
+    /** Literal-only alternation of every literal, grouped by shared leading characters; no quantifier. */
+    readonly prefixSource: string;
+    /** Per key `code[-2] * 128 + code[-1]`: the literal with that ending plus one, or -1 where several share it. */
+    readonly ending: Int8Array;
+    /** Literals sharing an ending, by the same key. */
+    readonly sharedEndings: readonly (readonly number[] | undefined)[];
+}
+/**
+ * The tables for `CREDENTIAL_FORMATS`; the first call builds them.
+ * @returns the shared, read-only tables.
+ */
+export declare function formatTables(): FormatTables;
+//# sourceMappingURL=format-tables.d.ts.map

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

@@ -208,7 +208,13 @@ export declare const IconMicrophoneOutline16: ({ size, className }: IconProps) =
 export declare const IconPinOutlineRegular: ({ size, className }: IconProps) => import("react").JSX.Element;
 /** Filled twin of {@link IconPinOutlineRegular}: the pinned-row marker. */
 export declare const IconPinFillRegular: ({ size, className }: IconProps) => import("react").JSX.Element;
+/** Circle-and-tick glyph the plugin page marks shipped rows with; upstream artwork. */
+export declare const IconCheckCircleFillRegular: ({ size, className }: IconProps) => import("react").JSX.Element;
 export declare const IconUsersOutlineRegular: ({ size, className }: IconProps) => import("react").JSX.Element;
 export declare const IconWorkspaceTreeOutlineRegular: ({ size, className }: IconProps) => import("react").JSX.Element;
-export { IconBranchOutline16 as IconBranchOutlineRegular, IconCheckOutline16 as IconCheckOutlineRegular, IconChecklistOutline14 as IconChecklistOutlineRegular, IconChevronDownOutline14 as IconChevronDownOutlineMedium, IconChevronUpOutline14 as IconChevronUpOutlineMedium, IconCloseOutline16 as IconCloseOutlineRegular, IconCopyOutline16 as IconCopyOutlineRegular, IconPlusOutline16 as IconPlusOutlineRegular, IconSearchOutline16 as IconSearchOutlineRegular, IconSendOutline16 as IconSendOutlineRegular, IconSettingsOutline14 as IconSettingsOutlineMedium, IconUserOutline16 as IconUserOutlineRegular, };
+/** Regular one-pixel IconSlidersTwoOutline artwork (Filters and Labels menu rows). */
+export declare const IconSlidersTwoOutlineRegular: ({ size, className }: IconProps) => import("react").JSX.Element;
+/** Medium IconSlidersTwoOutline artwork with a 1.3px stroke. */
+export declare const IconSlidersTwoOutlineMedium: ({ size, className }: IconProps) => import("react").JSX.Element;
+export { IconBranchOutline16 as IconBranchOutlineRegular, IconCheckOutline16 as IconCheckOutlineRegular, IconChecklistOutline14 as IconChecklistOutlineRegular, IconChevronDownOutline14 as IconChevronDownOutlineRegular, IconChevronLeftOutline14 as IconChevronLeftOutlineMedium, IconChevronRightOutline14 as IconChevronRightOutlineRegular, IconChevronDownOutline14 as IconChevronDownOutlineMedium, IconChevronUpOutline14 as IconChevronUpOutlineMedium, IconCloseOutline16 as IconCloseOutlineMedium, IconCloseOutline16 as IconCloseOutlineRegular, IconCopyOutline16 as IconCopyOutlineRegular, IconDownloadOutline16 as IconDownloadOutlineRegular, IconInfoOutline14 as IconInfoOutlineRegular, IconPluginPinwheelOutline16 as IconPluginPinwheelOutlineRegular, IconPlusOutline16 as IconPlusOutlineRegular, IconRefreshOutline14 as IconRefreshOutlineRegular, IconSearchOutline16 as IconSearchOutlineRegular, IconSendOutline16 as IconSendOutlineRegular, IconTrashOutline16 as IconTrashOutlineRegular, IconSettingsOutline14 as IconSettingsOutlineMedium, IconUserOutline16 as IconUserOutlineRegular, IconWarningOutline16 as IconWarningOutlineRegular, };
 //# sourceMappingURL=index.d.ts.map

package/lib/types/index.d.ts

@@ -18,11 +18,15 @@ export type { ButtonVariant } from './Button.tsx';
 export { Pill } from './Pill.tsx';
 export { SegmentedControl } from './SegmentedControl.tsx';
 export type { SegmentedControlOption } from './SegmentedControl.tsx';
+export { SegmentedTabs } from './SegmentedTabs.tsx';
+export type { SegmentedTab } from './SegmentedTabs.tsx';
+export * from './plugin-artwork.tsx';
 export { Tag } from './Tag.tsx';
 export type { TagTone } from './Tag.tsx';
 export { Switch } from './Switch.tsx';
 export { Checkbox } from './Checkbox.tsx';
 export { Input } from './Input.tsx';
+export { InlineEditor } from './InlineEditor.tsx';
 export { Menu, MenuItemButton } from './Menu.tsx';
 export type { MenuItemButtonProps, MenuEntry, MenuItem, MenuSeparator, MenuLabel } from './Menu.tsx';
 export { ShortcutKeys } from './ShortcutKeys.tsx';
@@ -48,9 +52,10 @@ export type { LinkIconKind, LinkIconProps } from './LinkIcon.tsx';
 export { FileTypeIcon, classifyFileType, fileExtension } from './FileTypeIcon.tsx';
 export type { CodeFileType, FileType, FileTypeIconProps, FileTypeKind, FileTypeProjectContext, } from './FileTypeIcon.tsx';
 export { PathLabel } from './PathLabel.tsx';
-export { projectUserText, type UserTextReferences } from './user-text.tsx';
+export { projectUserText, type UserTextReferences, type UserTextSecretLabels } from './user-text.tsx';
 export { Tooltip } from './Tooltip.tsx';
 export type { TooltipSide } from './Tooltip.tsx';
+export { pointerModality } from './input-modality.ts';
 export { focusWithoutRing } from './focus.ts';
 export { observeComposition } from './keyboard-composition.ts';
 export { closeTopModal, isBehindModal, modalSelector, useModalLayer } from './useModalLayer.ts';

package/lib/types/plugin-artwork.d.ts

@@ -0,0 +1,17 @@
+import type { IconProps } from './icons/props.ts';
+/** Light-blue terminal artwork shared by plugin cards and sidebar guide entries. */
+export declare const PluginArtworkTerminal: ({ size, className }: IconProps) => import("react").JSX.Element;
+/** Agent-loop plugin artwork (four leaves circling a center). */
+export declare const PluginArtworkLoop: ({ size, className }: IconProps) => import("react").JSX.Element;
+/** Subagent plugin artwork (two stacked rounded squares); also marks every row inside a bundle. */
+export declare const PluginArtworkSubagent: ({ size, className }: IconProps) => import("react").JSX.Element;
+/**
+ * Web-search plugin artwork (conic-gradient ring and handle). SVG has no
+ * native conic gradient, so the ring clips an HTML div painted with CSS
+ * `conic-gradient` — the same emulation Figma exports; it renders inline in
+ * the browser UI but would stay empty in an `<img>` or mask context.
+ */
+export declare const PluginArtworkSearch: ({ size, className }: IconProps) => import("react").JSX.Element;
+/** Default plugin artwork for plugins without one of their own (connector blocks and a node). */
+export declare const PluginArtworkDefault: ({ size, className }: IconProps) => import("react").JSX.Element;
+//# sourceMappingURL=plugin-artwork.d.ts.map

package/lib/types/useAnchoredPosition.d.ts

@@ -20,6 +20,8 @@ export interface AnchoredPositionOptions {
     panelRef: RefObject<HTMLElement | null>;
     /** Which anchor edge the panel hangs from: below it (`bottom`, the default) or above it (`top`). */
     side?: 'top' | 'bottom';
+    /** Which anchor edge the panel lines up with: its left edge (`start`, the default) or its right edge (`end`). */
+    align?: 'start' | 'end';
     /** Distance kept between the anchor edge named by `side` and the panel. */
     gap: number;
     /** Distance kept between the panel and each viewport edge. */
@@ -27,7 +29,7 @@ export interface AnchoredPositionOptions {
 }
 /**
  * Track an anchor and return the panel's fixed coordinates.
- * @param options - the open state, the two refs, the placement side, and the gap/margin distances.
+ * @param options - the open state, the two refs, the placement side and alignment, and the gap/margin distances.
  * @returns `left`/`top` for the panel, or `null` before the first measurement.
  */
 export declare function useAnchoredPosition(options: AnchoredPositionOptions): CSSProperties | null;

package/lib/types/user-text.d.ts

@@ -12,7 +12,10 @@
  * stray `/word` stays plain text. A `/name` token is whitespace-bounded like
  * the host skill gesture (`qilin-tool-skill`): it ends at whitespace or the
  * text end, so slash paths (`/nfs-hg/xxx`, `/plan.md`) and punctuation-glued
- * tokens (`/plan。`) stay plain even for a loaded name.
+ * tokens (`/plan。`) stay plain even for a loaded name. A recognized credential
+ * always draws masked, ahead of every reference decoration, and only the display
+ * changes: the logged text, the copied text, and the model input keep the original
+ * characters.
  */
 import type { ReactNode } from 'react';
 /** Optional navigation supplied by consumers that can preview references. */
@@ -22,6 +25,13 @@ export interface UserTextReferences {
     /** Open the source of a skill loaded for this message. */
     openSkill: (name: string) => void;
 }
+/** Accessible names of the control that reveals one masked credential. */
+export interface UserTextSecretLabels {
+    /** Name while the value stays masked. */
+    readonly reveal: string;
+    /** Name while the value is shown. */
+    readonly hide: string;
+}
 /**
  * Split one sent text into inline plain runs and reference chips.
  * @param text - the logged model text of the message or queue row.
@@ -31,7 +41,8 @@ export interface UserTextReferences {
  * (unsent queue rows pass none).
  * @param slashKind - the chip kind those tokens render as.
  * @param references - optional file and skill preview actions; session and command tokens stay labels.
+ * @param secretLabels - reveal-control copy for credentials; absent in text that stays masked.
  * @returns inline nodes covering the whole text.
  */
-export declare function projectUserText(text: string, sessionLabels: readonly string[], slashNames?: readonly string[], slashKind?: 'skill' | 'command', references?: UserTextReferences): ReactNode;
+export declare function projectUserText(text: string, sessionLabels: readonly string[], slashNames?: readonly string[], slashKind?: 'skill' | 'command', references?: UserTextReferences, secretLabels?: UserTextSecretLabels): ReactNode;
 //# sourceMappingURL=user-text.d.ts.map