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

package/dist/types/markdown/windows-path-destinations.d.ts

@@ -0,0 +1,10 @@
+import type { Extension } from 'mdast-util-from-markdown';
+/**
+ * CommonMark reads `\.` or `\_` in a destination as an escaped character, so
+ * `D:\repo\.github` would parse as `D:\repo.github`. For a destination that
+ * is a Windows path, this `fromMarkdown` extension keeps every backslash
+ * literally, including one before punctuation such as `\(`, while character
+ * references such as `&` still decode; other destinations parse unchanged.
+ * @returns The mdast extension.
+ */
+export declare function windowsPathDestinations(): Extension;

package/dist/types/markdown.d.ts

@@ -0,0 +1,12 @@
+export { CodeBlock } from './markdown/CodeBlock.js';
+export type { CodeBlockProps } from './markdown/CodeBlock.js';
+export { JsonBlock } from './markdown/JsonBlock.js';
+export { MarkdownDelegateProvider, useMarkdownDelegate } from './markdown/MarkdownDelegate.js';
+export type { MarkdownMenuTarget, MarkdownDelegate, MarkdownDelegateProviderProps, MarkdownExternalLinkHandler, } from './markdown/MarkdownDelegate.js';
+export { DetailDocument, detailDocumentState, useDetailDocumentLabels } from './DetailDocument.js';
+export type { DetailDocumentCopy, DetailDocumentLabels, DetailDocumentRead, DetailDocumentState, } from './DetailDocument.js';
+export { MarkdownText } from './markdown/MarkdownText.js';
+export type { MarkdownCodeLabels, MarkdownFileMentions, MarkdownLabels, MarkdownPathImages, } from './markdown/MarkdownText.js';
+export { formatQuoteText } from './markdown/quote-text.js';
+export { extractMarkdownPlainText } from './markdown/plain-text.js';
+export type { MarkdownPlainTextMode, MarkdownPlainTextOptions } from './markdown/plain-text.js';

package/dist/types/overlay-top-margin.d.ts

@@ -0,0 +1,14 @@
+/** Shared viewport inset for overlays, derived from the desktop frame's reserved top strip. */
+/**
+ * Resolve the top margin an overlay keeps from the viewport edge.
+ * @param min - the overlay's own viewport margin in px, used as the floor.
+ * @param anchor - the overlay's anchor rect in viewport coordinates. While the anchor's top edge is inside the
+ * viewport, the margin never exceeds `anchor.bottom + gap`, so an overlay opened from a control inside the top strip
+ * stays next to it.
+ * @param gap - the distance the overlay keeps below `anchor`.
+ * @returns the frame clearance plus 20px (20px in fullscreen), capped by a visible `anchor`, but never below `min`.
+ */
+export declare function overlayTopMargin(min: number, anchor?: {
+    readonly top: number;
+    readonly bottom: number;
+}, gap?: number): number;

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

@@ -0,0 +1,16 @@
+import type { IconProps } from './icons/props.js';
+/** 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;

package/dist/types/pointer-grace.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Grace before a pointer-dismissed popup closes. Covers the anchor->popup gap
+ * (8px for HoverCard, 4px for Menu) at a hand's travel speed without leaving a
+ * popup lingering once the pointer has genuinely moved on.
+ */
+export declare const POINTER_GRACE_MS = 200;
+/** Cancelable delayed close for a pointer-dismissed popup. */
+export interface PointerGrace {
+    /** Schedule the close {@link POINTER_GRACE_MS} from now, replacing any pending one. */
+    arm: () => void;
+    /** Abort a pending close (the pointer came back). */
+    cancel: () => void;
+}
+/**
+ * Delay a pointer-dismissed popup's close so the pointer can cross the gap
+ * between anchor and popup. A pending close is dropped on unmount.
+ * @param close - runs when the grace elapses with no re-entry; read at fire
+ * time, so callers may pass a fresh closure each render.
+ * @returns the {@link PointerGrace} handle.
+ */
+export declare function usePointerGrace(close: () => void): PointerGrace;

package/dist/types/rank-by-name.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Shared ranking for `/` menu candidates: the query must be a
+ * case-insensitive ordered subsequence of the candidate name or, when the
+ * candidate carries one, of its display label (a localized title). Prefix
+ * hits rank first, then the strongest alignment score over either key, then
+ * the source order of the input. Decision record:
+ * .agents/notes/archived/feature/2026-08-04-web-slash-command-fuzzy-discovery.md
+ */
+/**
+ * Rank named items by a menu query.
+ * @param items - candidates in source order (a host catalog, then client
+ * contributions); an item's optional `label` is a second search key beside
+ * its name.
+ * @param rawQuery - the text typed after the trigger, matched case-insensitively.
+ * @returns the matching items: prefix hits first, then by alignment score,
+ * then in source order. The input list itself for an empty query.
+ */
+export declare function rankByName<T extends {
+    readonly name: string;
+    readonly label?: string;
+}>(items: readonly T[], rawQuery: string): readonly T[];

package/dist/types/relative-time.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Compact relative-time bucketing shared by every surface that dates a
+ * session. Bucketing is here so two surfaces naming the same session agree;
+ * the words stay in each plugin's own dictionary, per locale-owned copy.
+ *
+ * @module @deepseek-ai/dsh-client-ui-primitives/relative-time
+ */
+/** Relative-time bucket of a dated row's trailing label. */
+export type RelativeTimeUnit = 'now' | 'minutes' | 'hours' | 'days' | 'months' | 'years';
+/** Structured relative time: the bucket plus its magnitude (0 for 'now'). */
+export interface RelativeTime {
+    unit: RelativeTimeUnit;
+    n: number;
+}
+/**
+ * Compact relative time, as a structured bucket the renderer localizes
+ * ("now"/"5min"/"3h"/"2d"/"4mo"/"1y" in en).
+ * @param at - epoch ms of the dated moment.
+ * @param now - current epoch ms (injected for pure rendering).
+ * @returns the row's trailing time bucket and magnitude.
+ */
+export declare function relativeTime(at: number, now: number): RelativeTime;

package/dist/types/seekbuddy/Card.d.ts

@@ -0,0 +1,28 @@
+import type { HTMLAttributes } from 'react';
+/** Inner padding: `none` = 0 (self-laid-out content such as a cover image), `sm` = 14px (dense catalog cards), `md` = 16px (default). */
+export type CardPadding = 'none' | 'sm' | 'md';
+/** Rendered element; pick `li` inside a list so the card needs no wrapper. */
+export type CardElement = 'div' | 'section' | 'article' | 'li';
+export interface CardProps extends HTMLAttributes<HTMLElement> {
+    /** Inner padding; see `CardPadding`. Default `md` (16px). */
+    padding?: CardPadding | undefined;
+    /**
+     * Hover feedback for cards the caller makes clickable: the translucent `--dsw-alias-interactive-bg-hover`
+     * fill upstream's plugin cards use, plus the pointer cursor.
+     * Styling only — clicking is wired by the caller (`onClick` here, or a `<button>` inside).
+     */
+    interactive?: boolean | undefined;
+    /** Element to render; see `CardElement`. Default `div`. */
+    as?: CardElement | undefined;
+}
+/**
+ * Card surface only — background, hairline stroke, radius, elevation, padding — with the content
+ * left entirely to `children`. Upstream primitives ship no card / panel, so hand-rolled cards
+ * tend to drift apart. No header / footer / title slots by design:
+ * business cards do not share an inner structure, so the library does not pretend they do.
+ *
+ * Server-safe (no hooks, no DOM access): a Next.js Server Component may import it from
+ * `@seekbuddy/dsh-ui/seekbuddy/card`. Sets no `role` / `tabIndex` — a fully clickable card is the
+ * caller's accessibility decision (put a `<button>` inside, or wire `role="button"` + keyboard).
+ */
+export declare function Card({ padding, interactive, as: Element, className, ...rest }: CardProps): import("react").JSX.Element;

package/dist/types/seekbuddy/DangerButton.d.ts

@@ -0,0 +1,31 @@
+import { type ComponentPropsWithoutRef } from 'react';
+import { Button } from '@seekbuddy/dsh-ui';
+/** Upstream `Button` props minus `variant`: the shape is fixed to the outline capsule. */
+export type DangerButtonProps = Omit<ComponentPropsWithoutRef<typeof Button>, 'variant' | 'className'> & {
+    /** Extra class on the `<button>`, for layout. */
+    className?: string | undefined;
+};
+/**
+ * Outline capsule in the error tone — red label and stroke — for destructive actions (delete,
+ * disable) and error-state affordances (e.g. a "review failed" chip that opens the reason).
+ *
+ * Upstream `ButtonVariant` has no danger family, and restyling the upstream `Button` through a
+ * consumer `className` tends to cover only the hover state. This owns the whole state set
+ * once — hover, active, focus-visible — while geometry, sizes and the disabled 40 % opacity stay
+ * with the upstream `Button` it wraps.
+ *
+ * Tokens: `--dsw-alias-state-error-primary` (label and stroke; the same token upstream `Menu`
+ * uses for its danger item), `--dsw-alias-interactive-bg-hover-danger` (hover fill), an 18 %
+ * `color-mix` of the error tone (active fill; no dedicated alias token), and the shared focus ring (width and colour from the theme's `focus.css`).
+ * All are theme-aware, so dark mode needs no extra rules.
+ */
+export declare const DangerButton: import("react").ForwardRefExoticComponent<Omit<Omit<{
+    variant?: import("@seekbuddy/dsh-ui").ButtonVariant;
+    size?: 'md' | 'sm';
+    icon?: import("react").ReactNode;
+    className?: string | undefined;
+    children?: import("react").ReactNode;
+} & import("react").ButtonHTMLAttributes<HTMLButtonElement> & import("react").RefAttributes<HTMLButtonElement>, "ref">, "className" | "variant"> & {
+    /** Extra class on the `<button>`, for layout. */
+    className?: string | undefined;
+} & import("react").RefAttributes<HTMLButtonElement>>;

package/dist/types/seekbuddy/Empty.d.ts

@@ -0,0 +1,34 @@
+import type { HTMLAttributes, ReactNode } from 'react';
+/** The three content states a data-driven view has to handle. */
+export type EmptyStatus = 'loading' | 'empty' | 'error';
+export interface EmptyProps extends Omit<HTMLAttributes<HTMLDivElement>, 'title'> {
+    /** Which state to show. Precedence between loading / error / empty is the caller's decision. */
+    status: EmptyStatus;
+    /** Main line; localized by the caller. */
+    title: string;
+    /** Secondary line under the title. */
+    description?: ReactNode | undefined;
+    /**
+     * Leading visual. `undefined` picks the default for the status (spinner / search / warning);
+     * `null` renders no icon at all.
+     */
+    icon?: ReactNode | null | undefined;
+    /** Action row (e.g. a "create" button for the empty state). Rendered before the retry button. */
+    action?: ReactNode | undefined;
+    /** Label of the retry button; rendered only for `status="error"` together with `onRetry`. */
+    retryLabel?: string | undefined;
+    /** Retry handler; rendered only for `status="error"` together with `retryLabel`. */
+    onRetry?: (() => void) | undefined;
+    /** Reserved height so a list that refreshes into a state does not jump. Default 240. */
+    minHeight?: number | string | undefined;
+    /** Dashed frame; turn off for full-screen or already-framed placements. Default `true`. */
+    bordered?: boolean | undefined;
+}
+/**
+ * Placeholder block for the loading / empty / error states of a page or a list region: icon,
+ * title, description and an action row. Text and buttons come from the caller; the component only
+ * fixes structure, tokens and the live-region semantics per state (`status` + polite for loading,
+ * `alert` for error, nothing for empty). server-safe (no hooks); the retry button needs a handler
+ * so it is only usable from Client Components.
+ */
+export declare function Empty({ status, title, description, icon, action, retryLabel, onRetry, minHeight, bordered, className, style, ...rest }: EmptyProps): import("react").JSX.Element;

package/dist/types/seekbuddy/Mark.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Closed set of marks the extension layer knows how to draw. Each kind is one fixed meaning with
+ * its own glyph and colour token; adding a kind means adding an entry to `GLYPHS`, a colour class
+ * in `Mark.module.css` and a story — callers only ever pick a kind.
+ */
+export type MarkKind = 'official';
+/** Pixel edge of the glyph. 14 / 16 next to card titles, 20 / 24 next to detail-page headings. */
+export type MarkSize = 14 | 16 | 18 | 20 | 24;
+export interface MarkProps {
+    /** Which mark to draw; each kind has a fixed glyph and colour. */
+    kind: MarkKind;
+    /** Screen-reader name and tooltip text, e.g. "Official"; localized by the caller. */
+    label: string;
+    /** Default 16. */
+    size?: MarkSize | undefined;
+    /** Wrap in a hover / focus tooltip showing `label`. Default `true`; pass `false` when the meaning is already spelled out next to the mark. */
+    tooltip?: boolean | undefined;
+    /** Extra class on the root element, for layout. */
+    className?: string | undefined;
+}
+/**
+ * Inline status mark: a fixed glyph with one meaning per `kind`, sized to sit on the text
+ * baseline without growing the line. Not a generic badge — no free icon or colour props.
+ * `<span role="img" aria-label tabIndex={0}>` so keyboard users can reach the tooltip; the SVG is
+ * decorative. Uses the upstream `Tooltip`, so it lives in the Client Component aggregate entry only.
+ */
+export declare function Mark({ kind, label, size, tooltip, className }: MarkProps): import("react").JSX.Element;

package/dist/types/seekbuddy/Message.d.ts

@@ -0,0 +1,52 @@
+import { type ReactNode } from 'react';
+export type MessageType = 'success' | 'info' | 'warning' | 'error' | 'loading';
+export interface MessageOptions {
+    /** Default `info`. */
+    type?: MessageType | undefined;
+    /** Message text or nodes. */
+    content: ReactNode;
+    /** Seconds. Default 3; `0` stays until closed. `loading` defaults to 0. */
+    duration?: number | undefined;
+    /** Re-opening with the same key updates that message in place (e.g. loading → success). */
+    key?: string | undefined;
+    /** Replaces the type's default glyph. */
+    icon?: ReactNode | undefined;
+    /** Called after the message has faded out, however it closed: timeout, `close()`, `destroy`, or eviction by `maxCount`. */
+    onClose?: (() => void) | undefined;
+}
+/** Closes the message it was returned for. */
+export type MessageClose = () => void;
+export interface MessageApi {
+    /** Shows a message with full options; returns a function that closes it. */
+    open(options: MessageOptions): MessageClose;
+    /** Shows a success message; `duration` in seconds (default 3, `0` keeps it open). */
+    success(content: ReactNode, duration?: number): MessageClose;
+    /** Shows an info message; `duration` in seconds (default 3, `0` keeps it open). */
+    info(content: ReactNode, duration?: number): MessageClose;
+    /** Shows a warning message; `duration` in seconds (default 3, `0` keeps it open). */
+    warning(content: ReactNode, duration?: number): MessageClose;
+    /** Shows an error message; `duration` in seconds (default 3, `0` keeps it open). */
+    error(content: ReactNode, duration?: number): MessageClose;
+    /** Shows a loading message; it stays until closed unless `duration` is given. */
+    loading(content: ReactNode, duration?: number): MessageClose;
+    /** Without a key closes every message. */
+    destroy(key?: string): void;
+}
+export interface MessageProviderProps {
+    /** Distance from the viewport top in px. Default 120, where the upstream Toast sits. */
+    top?: number | undefined;
+    /** Messages shown at once; the oldest closes when exceeded. Default 3. */
+    maxCount?: number | undefined;
+    /** The subtree that may call `useMessage()`. */
+    children: ReactNode;
+}
+/**
+ * Stacked transient messages: antd's `useMessage` shape on top of the upstream Toast look.
+ * The provider owns the stack and renders it through a body portal only while something is
+ * showing, so server rendering never touches `document`. A provider per page root, not a global
+ * singleton — separately built bundles on one page each include their own copy of this module, so a
+ * module-level store would split across them.
+ */
+export declare function MessageProvider({ top, maxCount, children }: MessageProviderProps): import("react").JSX.Element;
+/** The message API of the nearest `MessageProvider`; stable across renders. Throws outside one. */
+export declare function useMessage(): MessageApi;

package/dist/types/seekbuddy/Pagination.d.ts

@@ -0,0 +1,66 @@
+import { type ReactNode } from 'react';
+/** All user-visible text, localized by the caller. */
+export interface PaginationLabels {
+    /** `aria-label` of the `<nav>`, e.g. "Pagination". */
+    navigation: string;
+    /** `aria-label` of the previous-page button. */
+    previous: string;
+    /** `aria-label` of the next-page button. */
+    next: string;
+    /** `aria-label` of a page button, e.g. `(page) => \`Page ${page}\``. */
+    page: (page: number) => string;
+    /** `aria-label` of the ellipsis that jumps back, e.g. "Previous 5 pages". */
+    jumpPrevious: string;
+    /** `aria-label` of the ellipsis that jumps forward. */
+    jumpNext: string;
+}
+export interface PaginationProps {
+    /** Controlled current page (1-based). Omit for uncontrolled with `defaultCurrent`. */
+    current?: number | undefined;
+    /** Initial page when uncontrolled. Default 1. */
+    defaultCurrent?: number | undefined;
+    /** Items per page; with `total` this yields the page count. */
+    pageSize?: number | undefined;
+    /** Initial page size when `pageSize` is omitted. Default 10. */
+    defaultPageSize?: number | undefined;
+    /** Total item count. */
+    total: number;
+    /** Fired with the target page; `pageSize` rides along so a future size changer keeps the signature. */
+    onChange?: ((page: number, pageSize: number) => void) | undefined;
+    /** Summary rendered at the start, e.g. `(total, [from, to]) => \`${from}–${to} of ${total}\``. */
+    showTotal?: ((total: number, range: [number, number]) => ReactNode) | undefined;
+    /** Render nothing when everything fits on one page. Default `true` (antd defaults to `false`). */
+    hideOnSinglePage?: boolean | undefined;
+    /** Previous / `current / pages` / next only. */
+    simple?: boolean | undefined;
+    /** Middle window of 3 page buttons instead of 5, for narrow rows. */
+    showLessItems?: boolean | undefined;
+    /** Disables every button in the strip. */
+    disabled?: boolean | undefined;
+    /** All visible and screen-reader text; see `PaginationLabels`. */
+    labels: PaginationLabels;
+    /** Extra class on the root `<nav>`, for layout. */
+    className?: string | undefined;
+}
+/** One slot of the page strip: a page button or an ellipsis that jumps by the window size. */
+export type PaginationItem = {
+    type: 'page';
+    page: number;
+} | {
+    type: 'jump-previous' | 'jump-next';
+    page: number;
+};
+/**
+ * antd's page strip: with few pages list them all; otherwise keep page 1 and the last page, a
+ * window of 5 (or 3) around `current`, and an ellipsis on each side that has a gap. Jumps move by
+ * the window size, clamped. Pure, exported for tests.
+ */
+export declare function pageItems(current: number, pages: number, lessItems?: boolean): PaginationItem[];
+/**
+ * Page navigation for catalog lists. Mirrors a subset of antd's Pagination:
+ * controlled or uncontrolled `current`, `total` + `pageSize` → page count, first / last page
+ * always visible with ellipsis jumps, `showTotal`, `simple`, `hideOnSinglePage`. Text comes from
+ * `labels`; the component has no strings of its own. Client Component (state for the
+ * uncontrolled mode), aggregate entry only.
+ */
+export declare function Pagination({ current, defaultCurrent, pageSize, defaultPageSize, total, onChange, showTotal, hideOnSinglePage, simple, showLessItems, disabled, labels, className, }: PaginationProps): import("react").JSX.Element | null;

package/dist/types/seekbuddy/Spinner.d.ts

@@ -0,0 +1,20 @@
+/** `sm` = 0.85rem / 2px ring for buttons and inline text; `md` = 2rem / 3px for page-level waits. */
+export type SpinnerSize = 'sm' | 'md';
+/** `inherit` rides `currentColor` (button foreground); `page` pins `--dsw-alias-label-primary`. */
+export type SpinnerTone = 'inherit' | 'page';
+export interface SpinnerProps {
+    /** Ring size; see `SpinnerSize`. Default `sm`. */
+    size?: SpinnerSize | undefined;
+    /** Ring colour source; see `SpinnerTone`. Default `inherit`. */
+    tone?: SpinnerTone | undefined;
+    /** Screen-reader text; when present the spinner becomes a live status region instead of aria-hidden. */
+    label?: string | undefined;
+    /** Extra class on the root element, for layout. */
+    className?: string | undefined;
+}
+/**
+ * The shared loading ring: track = currentColor at
+ * 35%, arc = currentColor, reduced motion keeps a static two-tone ring. Without `label`
+ * it is decorative (`aria-hidden`) and the surrounding text must say what is loading.
+ */
+export declare function Spinner({ size, tone, label, className }: SpinnerProps): import("react").JSX.Element;

package/dist/types/seekbuddy/StatusBadge.d.ts

@@ -0,0 +1,33 @@
+import type { ReactNode } from 'react';
+/**
+ * Closed set of tones. Each one is a fixed meaning with its own state dot and theme token; adding a
+ * tone means adding an entry here and in `DOTS`, a colour class in `StatusBadge.module.css` and a
+ * story — callers only pick a tone, never a colour.
+ */
+export type StatusTone = 'neutral' | 'success' | 'progress' | 'warning' | 'error';
+export interface StatusBadgeProps {
+    /** Meaning of the badge, which fixes its dot and colour; see `StatusTone`. */
+    tone: StatusTone;
+    /** Label text; localized by the caller. */
+    children: ReactNode;
+    /** Drop the leading dot when the row already carries one. Default `true`. */
+    dot?: boolean | undefined;
+    /** Extra class on the root element, for layout. */
+    className?: string | undefined;
+}
+/**
+ * Read-only status chip: a state dot plus a label, in one of five tones — "running", "mounting",
+ * "not connected", "mount failed", "delisted" and friends.
+ *
+ * The dot is the upstream `StateDot` (the same glyph the terminal block uses for run state), so
+ * `progress` gets upstream's animated chase rather than a second spinner vocabulary. Colour comes
+ * from the tone: upstream `Pill` has no tone variants, and recolouring an upstream component through
+ * a consumer `className` couples the caller to its internal styles. This owns the tones once so no
+ * call site needs that override. Geometry — capsule,
+ * height, font — stays with the `Pill` it wraps.
+ *
+ * Static by design: no `onClick`, so `Pill` renders a `<span>` and there are no interactive states
+ * to keep in sync. The dot is `aria-hidden`; the label carries the meaning. Tokens are theme-aware
+ * (`--dsw-alias-state-*` / `--dsw-alias-label-tertiary`), so dark mode needs no extra rules.
+ */
+export declare function StatusBadge({ tone, children, dot, className }: StatusBadgeProps): import("react").JSX.Element;

package/dist/types/seekbuddy/SubtleButton.d.ts

@@ -0,0 +1,30 @@
+import { type ComponentPropsWithoutRef } from 'react';
+import { Button } from '@seekbuddy/dsh-ui';
+/** Upstream `Button` props minus `variant`: the shape is fixed to the ghost capsule. */
+export type SubtleButtonProps = Omit<ComponentPropsWithoutRef<typeof Button>, 'variant' | 'className'> & {
+    /** Extra class on the `<button>`, for layout. */
+    className?: string | undefined;
+};
+/**
+ * Ghost capsule with a secondary label — for low-emphasis navigation that sits next to real actions
+ * (a card's "view details" link, a back button), where the default ghost label would compete with them.
+ *
+ * Upstream `ButtonVariant` has no quiet family, and setting `color` on a ghost `Button` through a consumer
+ * `className` covers its resting state only. This owns the whole state set once — the label steps up to the
+ * primary label on hover and press, plus a focus-visible ring — while geometry, sizes, the hover / press
+ * fills and the disabled 40 % opacity stay with the upstream ghost `Button` it wraps.
+ *
+ * Tokens: `--dsw-alias-label-secondary` (resting label), `--dsw-alias-label-primary` (hover / press label)
+ * and the shared focus ring (width and colour from the theme's `focus.css`).
+ * All are theme-aware, so dark mode needs no extra rules.
+ */
+export declare const SubtleButton: import("react").ForwardRefExoticComponent<Omit<Omit<{
+    variant?: import("@seekbuddy/dsh-ui").ButtonVariant;
+    size?: 'md' | 'sm';
+    icon?: import("react").ReactNode;
+    className?: string | undefined;
+    children?: import("react").ReactNode;
+} & import("react").ButtonHTMLAttributes<HTMLButtonElement> & import("react").RefAttributes<HTMLButtonElement>, "ref">, "className" | "variant"> & {
+    /** Extra class on the `<button>`, for layout. */
+    className?: string | undefined;
+} & import("react").RefAttributes<HTMLButtonElement>>;

package/dist/types/seekbuddy/Switch.d.ts

@@ -0,0 +1,36 @@
+import type { ButtonHTMLAttributes, MouseEvent, ReactNode } from 'react';
+/** `large` = 44×22 (antd default), `medium` = 36×20 (default), `small` = 28×16 for dense rows and table cells. */
+export type SwitchSize = 'large' | 'medium' | 'small';
+export interface SwitchProps extends Omit<ButtonHTMLAttributes<HTMLButtonElement>, 'onChange' | 'onClick' | 'children' | 'type' | 'role' | 'aria-checked' | 'defaultValue'> {
+    /** Controlled state; when given, the caller owns it and `defaultChecked` is ignored. */
+    checked?: boolean | undefined;
+    /** Initial state for the uncontrolled form. */
+    defaultChecked?: boolean | undefined;
+    /** Alias of `defaultChecked` (antd parity). */
+    defaultValue?: boolean | undefined;
+    /** Content shown inside the track while on (short text or a 12px icon). */
+    checkedChildren?: ReactNode;
+    /** Content shown inside the track while off. */
+    unCheckedChildren?: ReactNode;
+    /** Blocks clicks and dims the switch; `onChange` does not fire. */
+    disabled?: boolean | undefined;
+    /** Track size; see `SwitchSize`. Default `medium`. */
+    size?: SwitchSize | undefined;
+    /** Fires when the value flips (after `onClick`); not fired while `disabled`. */
+    onChange?: ((checked: boolean, event: MouseEvent<HTMLButtonElement>) => void) | undefined;
+    /** Fires on every click with the value the switch is about to take. */
+    onClick?: ((checked: boolean, event: MouseEvent<HTMLButtonElement>) => void) | undefined;
+}
+/**
+ * Binary on/off toggle (`role="switch"`, WAI-ARIA switch pattern) with the antd `Switch` prop
+ * shape. Upstream's own `Switch` is a minimal, fully controlled control with a different prop shape; this
+ * one keeps antd's. Colours follow upstream's: on track
+ * `--dsw-alias-brand-primary` with thumb and track text in `--dsw-alias-label-primary-foreground`,
+ * off track a 40 % `color-mix` of `--dsw-alias-label-primary` with a `--dsw-alias-switch-thumb`
+ * thumb; capsule and thumb are true circles (`corner-shape: round`); no motion. Differences from antd (deliberate, only these two): the default `size` is `medium`
+ * (36×20) rather than `large`, and there is no `loading` prop.
+ *
+ * Accessibility: a switch without `checkedChildren` / `unCheckedChildren` is purely graphical, so
+ * pass `aria-label` (or `aria-labelledby` pointing at the visible row label).
+ */
+export declare function Switch({ checked, defaultChecked, defaultValue, checkedChildren, unCheckedChildren, disabled, size, onChange, onClick, className, ...rest }: SwitchProps): import("react").JSX.Element;

package/dist/types/seekbuddy/Tabs.d.ts

@@ -0,0 +1,49 @@
+import type { ReactNode } from 'react';
+export interface TabItem<T extends string> {
+    /** Stable identity of the tab; also the value handed to `onChange` (antd `items[].key`). */
+    key: T;
+    /** Visible tab text. */
+    label: ReactNode;
+    /** Optional count badge; omitted when undefined. */
+    count?: number | undefined;
+    /** Skipped by the arrow keys and not selectable. */
+    disabled?: boolean | undefined;
+    /**
+     * Optional panel content. When any item carries `children`, the component renders the
+     * active item's panel itself (`role="tabpanel"`, wired with `aria-controls` / `aria-labelledby`).
+     * Leave it out when the panel is routed content the caller renders (for example a router outlet).
+     */
+    children?: ReactNode | undefined;
+}
+export interface TabsProps<T extends string> {
+    /** Accessible name of the tab list ("Skill views"). */
+    label: string;
+    /** Tabs in display order. */
+    items: ReadonlyArray<TabItem<T>>;
+    /** Controlled selection (antd `activeKey`); the caller owns it (URL state, useState, …). */
+    activeKey: T;
+    /** Called with the key of the tab the user selects. */
+    onChange: (key: T) => void;
+    /**
+     * DOM id of a caller-rendered panel showing the selected tab's content. Every tab then declares
+     * `aria-controls={panelId}` and gets the id `<panelId>-tab-<key>` for the panel's `aria-labelledby`.
+     * Ignored when items carry `children` (ids are generated and wired automatically).
+     */
+    panelId?: string | undefined;
+    /**
+     * Type scale of the tab labels: `sm` = `--dsw-font-xxs-12` (default; toolbars and in-card switches),
+     * `md` = `--dsw-font-s-14`, `lg` = `--dsw-font-base-16` (page-level view switches).
+     */
+    size?: 'sm' | 'md' | 'lg' | undefined;
+    /** Bold labels: every tab takes the `-strong-` variant of its size's font token (weight 600 in the theme). */
+    bold?: boolean | undefined;
+    /** Extra class on the root element, for layout. */
+    className?: string | undefined;
+}
+/**
+ * Underline tab list (WAI-ARIA tabs, automatic activation): roving tabindex, arrow /
+ * Home / End keys move selection and focus, disabled tabs are skipped. Upstream ships
+ * no Tabs — its view switchers are rows of `Pill` — so this package provides one.
+ * Data-driven like antd's `items`.
+ */
+export declare function Tabs<T extends string>({ label, items, activeKey, onChange, panelId, size, bold, className, }: TabsProps<T>): import("react").JSX.Element;

package/dist/types/seekbuddy/Timeline.d.ts

@@ -0,0 +1,42 @@
+import type { ReactNode } from 'react';
+/** Run state shown by the left badge: grey spinner / green check / red cross / grey dash. */
+export type TimelineStatus = 'running' | 'succeeded' | 'failed' | 'canceled';
+export interface TimelineItem {
+    /** Stable identity of the entry (React key). */
+    key: string;
+    /** Run state shown by the left badge. */
+    status: TimelineStatus;
+    /** Title line; may carry a `Pill` tag or other inline nodes. */
+    title: ReactNode;
+    /** Grey metadata parts (trigger kind, time, duration); the component spaces them. */
+    meta?: ReadonlyArray<ReactNode> | undefined;
+    /** Optional third line — rendered in the error color for `failed`, grey otherwise. */
+    message?: ReactNode | undefined;
+    /** When given the whole entry becomes a button (keep `message` free of interactive nodes). */
+    onSelect?: (() => void) | undefined;
+}
+export interface TimelineGroup {
+    /** Stable identity of the group (React key). */
+    key: string;
+    /** Group heading such as a date bucket ("Today"); omit for a headless single group. */
+    heading?: ReactNode | undefined;
+    /** Entries of the group, in display order. */
+    items: ReadonlyArray<TimelineItem>;
+}
+export interface TimelineProps {
+    /** Accessible name of the whole timeline ("Run history"). */
+    label: string;
+    /** Screen-reader text per status; badges themselves are aria-hidden. Copy comes from the caller's locale. */
+    statusLabels: Readonly<Record<TimelineStatus, string>>;
+    /** Groups in display order; ordering and bucketing are the caller's. */
+    groups: ReadonlyArray<TimelineGroup>;
+    /** Extra class on the root element, for layout. */
+    className?: string | undefined;
+}
+/**
+ * Vertical run timeline: date-bucket groups,
+ * each an ordered list of entries with a status badge, title, grey meta line, optional message
+ * and a rail that runs continuously inside a group. Data-driven like antd's `items`; grouping,
+ * sorting, copy and time formatting stay with the caller. Upstream ships no Timeline.
+ */
+export declare function Timeline({ label, statusLabels, groups, className }: TimelineProps): import("react").JSX.Element;