@mastra/playground-ui 65.0.0-alpha.8 → 65.0.0

package/dist/src/domains/traces/components/traces-explorer/traces-explorer-context.d.ts

@@ -0,0 +1,114 @@
+import { EntityType } from '@mastra/core/observability';
+import { TraceQueryDiscoveryTimeRange } from '@mastra/react/hooks/traces';
+import { useTraceColumnPreferences } from '../../hooks/use-trace-column-preferences';
+import { useTracesListSource } from '../../hooks/use-traces-list-source';
+import { TraceColumnPreferences } from '../../trace-list-columns';
+import { SpanTab, TraceDatePreset } from '../../types';
+import { TraceSpanView } from '../trace-data-panel-view';
+import { TracesFilters, TracesSelection, TracesSortDirection } from './traces-explorer-actions';
+import { DataListSort } from '../../../../ds/components/DataList';
+export type TracesExplorerScope = {
+    entityId: string;
+    entityType?: EntityType;
+};
+export type TracesMetricsSupport = {
+    supported: boolean;
+    isLoading: boolean;
+};
+/**
+ * Host switches (e.g. feature flags). Each one can only turn a feature off:
+ * it is combined with what the server supports, and defaults to on.
+ */
+export type TracesExplorerFeatures = {
+    traceQuery?: boolean;
+    feedback?: boolean;
+};
+export type TracesConfigContextValue = {
+    listId: string;
+    scopedFieldIds: ReadonlySet<string>;
+    hiddenFieldIds: readonly string[];
+    withQueryTrace: boolean;
+    withFeedback: boolean;
+    withRootDuration: boolean;
+    /** The server supports delta polling, so auto-refresh merges new traces instead of reloading pages. */
+    withDeltaPolling: boolean;
+    /** Whether field discovery should run: the server supports it and the trace query API is on. */
+    withDiscovery: boolean;
+    isCapabilitiesLoading: boolean;
+    metricsSupport: TracesMetricsSupport;
+    /** Shared by every discovery consumer so they hit the same cached query. */
+    discoveryTimeRange: TraceQueryDiscoveryTimeRange;
+};
+export type TracesFiltersActions = {
+    /** Replaces the filter tokens and groups. The scope tokens are always kept. */
+    setFilterTokens: (tokens: TracesFilters['tokens'], groups: TracesFilters['groups']) => void;
+    setDatePreset: (preset: TraceDatePreset) => void;
+    setDate: (value: Date | undefined, end: 'from' | 'to') => void;
+    setDateRange: (from: Date | undefined, to: Date | undefined) => void;
+};
+export type TracesFiltersContextValue = TracesFiltersActions & {
+    /** The host's filters with the entries this server can't query dropped. */
+    filters: TracesFilters;
+    dateFrom?: Date;
+    dateTo?: Date;
+    filtersApplied: boolean;
+    contentFiltersApplied: boolean;
+};
+export type TracesSelectionActions = {
+    selectTrace: (traceId: string) => void;
+    closeTrace: () => void;
+    selectSpan: (spanId: string | null) => void;
+    setSpanTab: (tab: SpanTab) => void;
+    setSpanView: (view: TraceSpanView) => void;
+    selectScore: (scoreId: string | null) => void;
+    highlightSpans: (spanIds: string[]) => void;
+};
+export type TracesSelectionContextValue = TracesSelectionActions & {
+    selection: TracesSelection;
+    selectedTraceId?: string;
+};
+type ListSource = ReturnType<typeof useTracesListSource>;
+export type TracesListContextValue = Pick<ListSource, 'rows' | 'isLoading' | 'isFetchingNextPage' | 'hasNextPage' | 'setEndOfListElement' | 'error' | 'refetch' | 'autoRefetch' | 'setAutoRefetch'> & {
+    sortDirection: TracesSortDirection;
+    onSortChange: (direction: DataListSort) => void;
+};
+export type TracesColumnsContextValue = ReturnType<typeof useTraceColumnPreferences>;
+export declare const TracesConfigContext: import('react').Context<TracesConfigContextValue | null>;
+export declare const TracesFiltersContext: import('react').Context<TracesFiltersContextValue | null>;
+export declare const TracesSelectionContext: import('react').Context<TracesSelectionContextValue | null>;
+export declare const TracesListContext: import('react').Context<TracesListContextValue | null>;
+/** Kept out of `TracesListContext` so a poll tick doesn't re-render every list consumer. */
+export declare const TracesListFetchingContext: import('react').Context<boolean | null>;
+export declare const TracesColumnsContext: import('react').Context<{
+    preferences: TraceColumnPreferences;
+    toggleColumn: (column: import('../../trace-list-columns').TraceOptionalColumn) => void;
+    addCustomColumn: (field: import('../../trace-list-columns').TraceCustomColumn) => void;
+    removeCustomColumn: (field: import('../../trace-list-columns').TraceCustomColumn) => void;
+    addMetadataColumn: (key: string) => void;
+    removeMetadataColumn: (key: string) => void;
+    resetColumns: () => void;
+} | null>;
+export declare const useTracesConfig: () => TracesConfigContextValue;
+export declare const useTracesFilters: () => TracesFiltersContextValue;
+export declare const useTracesSelection: () => TracesSelectionContextValue;
+export declare const useTracesList: () => TracesListContextValue;
+/** Whether the list query is fetching, including background refetches and retries. */
+export declare const useTracesListFetching: () => boolean;
+export declare const useTracesColumns: () => {
+    preferences: TraceColumnPreferences;
+    toggleColumn: (column: import('../../trace-list-columns').TraceOptionalColumn) => void;
+    addCustomColumn: (field: import('../../trace-list-columns').TraceCustomColumn) => void;
+    removeCustomColumn: (field: import('../../trace-list-columns').TraceCustomColumn) => void;
+    addMetadataColumn: (key: string) => void;
+    removeMetadataColumn: (key: string) => void;
+    resetColumns: () => void;
+};
+export type TraceUsageColumns = {
+    /** Column preferences with the usage columns removed when the store can't serve them. */
+    displayedPreferences: TraceColumnPreferences;
+    /** Whether usage should be fetched: metrics are supported and a usage column is visible. */
+    usageEnabled: boolean;
+    usageDisabledReason?: string;
+};
+export declare const useTraceUsageColumns: () => TraceUsageColumns;
+export {};

package/dist/src/domains/traces/components/traces-explorer/traces-explorer-filter-bar.d.ts

@@ -0,0 +1,24 @@
+import { ReactNode } from 'react';
+import { TraceTimeRangeChipProps } from '../trace-time-range-chip';
+import { FilterBarItem } from '../../../../ds/components/FilterBar';
+export type TracesExplorerFilterBarProps = {
+    /** Replaces the default chips and input, e.g. to pass a configured `TracesExplorer.TimeRangeChip`. */
+    children?: ReactNode;
+};
+/**
+ * The trace filters bar, wired to the explorer's fields and filters. Hosts that need extra
+ * fields or items (e.g. their own scope pickers) can render the design-system `FilterBar`
+ * themselves from `useTracesFilterBarFields()` / `useTracesFilterBar()` and reuse `FilterChips`.
+ */
+export declare function TracesExplorerFilterBar({ children }: TracesExplorerFilterBarProps): import("react").JSX.Element;
+export type TracesExplorerFilterChipsProps = {
+    /** Rendered for the time range item. Defaults to `<TracesExplorer.TimeRangeChip />`. */
+    timeRange?: ReactNode;
+    /** Renders every other item. Defaults to the design-system chip. */
+    renderChip?: (item: FilterBarItem) => ReactNode;
+};
+/** The bar's chips: the time range chip in its slot, then one chip per filter. */
+export declare function TracesExplorerFilterChips({ timeRange, renderChip }: TracesExplorerFilterChipsProps): import("react").JSX.Element;
+export type TracesExplorerTimeRangeChipProps = Partial<Pick<TraceTimeRangeChipProps, 'presets' | 'minDate' | 'maxRangeMs'>>;
+/** Its own component so a list loading flip only re-renders the chip, not the whole bar. */
+export declare function TracesExplorerTimeRangeChip({ presets, minDate, maxRangeMs, }: TracesExplorerTimeRangeChipProps): import("react").JSX.Element;

package/dist/src/domains/traces/components/traces-explorer/traces-explorer-layout.d.ts

@@ -0,0 +1,14 @@
+import { ReactNode } from 'react';
+import { TracesListContextValue } from './traces-explorer-context';
+export type TracesExplorerErrorRenderArgs = Pick<TracesListContextValue, 'refetch'> & {
+    error: NonNullable<TracesListContextValue['error']>;
+    isFetching: boolean;
+};
+export type TracesExplorerLayoutProps = {
+    breadcrumbs?: ReactNode;
+    actionRow: ReactNode;
+    children: ReactNode;
+    /** Renders the list-error state (e.g. host-classified errors with a retry). Defaults to `TracesErrorContent`. */
+    renderError?: (args: TracesExplorerErrorRenderArgs) => ReactNode;
+};
+export declare function TracesExplorerLayout({ breadcrumbs, actionRow, children, renderError }: TracesExplorerLayoutProps): import("react").JSX.Element;

package/dist/src/domains/traces/components/traces-explorer/traces-explorer-list-provider.d.ts

@@ -0,0 +1,13 @@
+import { ReactNode } from 'react';
+import { TracesSortDirection } from './traces-explorer-actions';
+type TracesListProviderProps = {
+    sortDirection: TracesSortDirection;
+    onSortChange: (direction: TracesSortDirection) => void;
+    children: ReactNode;
+};
+/**
+ * Owns the list query and its poll clock. Its own memoized component so a poll tick re-renders
+ * only list consumers, and a selection change doesn't re-run the list query hooks.
+ */
+export declare const TracesListProvider: import('react').MemoExoticComponent<({ sortDirection, onSortChange, children, }: TracesListProviderProps) => import("react").JSX.Element>;
+export {};

package/dist/src/domains/traces/components/traces-explorer/traces-explorer-list.d.ts

@@ -0,0 +1 @@
+export declare function TracesExplorerList(): import("react").JSX.Element;

package/dist/src/domains/traces/components/traces-explorer/traces-explorer-panel.d.ts

@@ -0,0 +1,18 @@
+import { ComponentProps, ReactNode } from 'react';
+import { TraceSpanPanelProps } from '../trace-span-panel';
+import { TraceAsItemDialog } from '../../../observability/components/trace-as-item-dialog';
+export type TracesExplorerPanelProps = {
+    /** Opens a score of one of the full thread's traces (the host owns routing). */
+    onOpenScore: (traceId: string, scoreId: string) => void;
+    renderCreateDatasetDialog?: ComponentProps<typeof TraceAsItemDialog>['renderCreateDatasetDialog'];
+    /** Host integration actions rendered alongside the trace controls. */
+    headerActionsSlot?: (args: {
+        traceId: string;
+        spans: TraceSpanPanelProps['spans'];
+    }) => ReactNode;
+    /** Builds the href of the dedicated trace page; without it the drawer offers no "Open trace page" link. */
+    traceHref?: (traceId: string) => string;
+    /** Shows "Add full trace to dataset" in the trace actions menu. Defaults to `true`. */
+    withAddTraceToDataset?: boolean;
+};
+export declare function TracesExplorerPanel({ onOpenScore, renderCreateDatasetDialog, headerActionsSlot, traceHref, withAddTraceToDataset, }: TracesExplorerPanelProps): import("react").JSX.Element;

package/dist/src/domains/traces/components/traces-explorer/traces-explorer-root.d.ts

@@ -0,0 +1,21 @@
+import { ReactNode } from 'react';
+import { TracesExplorerState, TracesFilters, TracesSelection, TracesSortDirection } from './traces-explorer-actions';
+import { TracesExplorerFeatures, TracesExplorerScope, TracesMetricsSupport } from './traces-explorer-context';
+export type TracesExplorerRootProps = {
+    selection: TracesSelection;
+    filters: TracesFilters;
+    /** Receives the full next state once per user action, so a filter edit and the selection it clears land together. */
+    onChange: (next: TracesExplorerState) => void;
+    sortDirection: TracesSortDirection;
+    onSortDirectionChange: (next: TracesSortDirection) => void;
+    /** Pins the explorer to one entity: its fields stay in the filters but never surface as chips. */
+    scope?: TracesExplorerScope;
+    /** Resolved by the host, which may know better than the storage capabilities (e.g. hosted deployments). */
+    metricsSupport: TracesMetricsSupport;
+    /** Host switches combined with the server capabilities; a feature runs only when both allow it. */
+    features?: TracesExplorerFeatures;
+    /** The host's default filters. Filters matching them don't count as applied (e.g. in empty states). */
+    initialFilters?: TracesFilters;
+    children: ReactNode;
+};
+export declare function TracesExplorerRoot({ selection, filters: rawFilters, onChange, sortDirection, onSortDirectionChange, scope, metricsSupport, features, initialFilters, children, }: TracesExplorerRootProps): import("react").JSX.Element;

package/dist/src/domains/traces/components/traces-explorer/use-traces-discovery.d.ts

@@ -0,0 +1,15 @@
+/**
+ * The metadata fields observed on traces in the explorer's date window. Every caller shares one
+ * cached query, so each part (bar, columns menu, layout) can ask for it directly.
+ */
+export declare function useTracesDiscovery(): {
+    fields: import('@mastra/react/hooks/traces').TraceMetadataFilterField[];
+    canonicalFields: {
+        path: string;
+        valueKind: "string" | "number" | "stringOrNumber" | "timestamp" | "presence" | "array";
+        operators: ("eq" | "exists" | "gt" | "gte" | "in" | "includes" | "lt" | "lte" | "matches" | "ne" | "notExists" | "notIn" | "notIncludes" | "notMatches")[];
+        valueSuggestions: boolean;
+    }[];
+    isLoading: boolean;
+    error: Error | null;
+};

package/dist/src/domains/traces/components/traces-explorer/use-traces-filter-bar.d.ts

@@ -0,0 +1,15 @@
+import { FilterBarExpression, FilterBarField, FilterBarItem } from '../../../../ds/components/FilterBar';
+/** The fields the trace filter bar offers: time range, trace fields, and discovered metadata. */
+export declare function useTracesFilterBarFields(): FilterBarField[];
+/**
+ * The explorer's filters as filter bar values, and the handlers that write bar edits back.
+ * Scope items never show up in the bar; the explorer keeps them on every edit.
+ */
+export declare function useTracesFilterBar(): {
+    filterBarValue: FilterBarExpression;
+    flatFilterBarValue: FilterBarItem[];
+    onFilterBarChange: (expression: FilterBarExpression) => void;
+    onFlatFilterBarChange: (nodes: FilterBarItem[]) => void;
+    /** Replaces any filter on `fieldId` with `is value`, e.g. from a list cell. */
+    onFilterByField: (fieldId: string, value: string) => void;
+};

package/dist/src/domains/traces/hooks/index.d.ts

@@ -16,7 +16,6 @@ export { useEnvironments } from '@mastra/react/hooks/traces';
 export { useServiceNames } from '@mastra/react/hooks/traces';
 export { useTraceSpanNavigation } from './use-trace-span-navigation';
 export { useTraceListNavigation } from './use-trace-list-navigation';
-export { useTraceUrlState, type UseTraceUrlStateResult, type UseTraceUrlStateOptions, type SetURLSearchParamsLike, } from './use-trace-url-state';
-export { useTraceFilterPersistence, type TraceFilterPersistenceOptions } from './use-trace-filter-persistence';
+export type { SetURLSearchParamsLike } from '../../../lib/sort/use-url-sort';
 export { useExpandedSpanIds } from './use-expanded-span-ids';
 export { useVisibleTraceRows } from './use-visible-trace-rows';

package/dist/src/domains/traces/hooks/use-traces-list-source.d.ts

@@ -1,5 +1,9 @@
 import { TraceQueryArgs, UseTraceQueryArgs } from '@mastra/react/hooks/traces';
 export declare const TRACES_LIST_REFETCH_INTERVAL_MS = 10000;
+/** Delta polls only ask for what changed since the cursor, so they can run less often. */
+export declare const TRACES_LIST_DELTA_POLL_INTERVAL_MS = 30000;
+/** How far past the anchor a delta-polled rolling window reaches, so traces started after mount still match. */
+export declare const TRACES_LIST_DELTA_HORIZON_MS: number;
 /** The server refused the request (e.g. a time range over its cap); retrying cannot change that. */
 export declare function isRejectedTraceListRequest(error: unknown): boolean;
 export declare function fixedWindowRefetchInterval(error: unknown): number | false;
@@ -9,12 +13,14 @@ export interface UseTracesListSourceArgs {
     rolling?: boolean;
     initialAutoRefetch?: boolean;
     withQueryTrace?: boolean;
+    /** The server supports delta polling: auto-refresh merges new traces instead of reloading the pages. */
+    withDeltaPolling?: boolean;
     legacyFilters?: UseTraceQueryArgs['legacyFilters'];
     /** Rows per page; defaults to `TRACE_QUERY_PER_PAGE`. */
     limit?: number;
     enabled?: boolean;
 }
-export declare function useTracesListSource({ query: buildQuery, orderBy, rolling, initialAutoRefetch, withQueryTrace, legacyFilters, limit, enabled, }: UseTracesListSourceArgs): {
+export declare function useTracesListSource({ query: buildQuery, orderBy, rolling, initialAutoRefetch, withQueryTrace, withDeltaPolling, legacyFilters, limit, enabled, }: UseTracesListSourceArgs): {
     rows: import('..').TracesListViewTrace[];
     autoRefetch: boolean;
     setAutoRefetch: import('react').Dispatch<import('react').SetStateAction<boolean>>;

package/dist/src/domains/traces/trace-query-filters.d.ts

@@ -35,4 +35,6 @@ export declare function buildTraceQueryRequest({ rootEntityType, status, dateFro
     excludedFieldIds?: ReadonlySet<string>;
     now: Date;
 }): Pick<QueryTracesInput, 'timeRange' | 'where'>;
+/** The query window for a date range: open ends fall back to the last seven days up to `now`. */
+export declare function resolveTraceQueryTimeRange(dateFrom: Date | undefined, dateTo: Date | undefined, now: Date): QueryTracesInput['timeRange'];
 export {};

package/dist/src/domains/workflows/context/use-persisted-workflow-run.d.ts

@@ -82,6 +82,11 @@ export declare function usePersistedWorkflowRun(workflowId: string, runId: strin
         requestContext?: {
             [x: string]: any;
         } | undefined;
+        tracingContext?: {
+            traceId?: string | undefined;
+            spanId?: string | undefined;
+            parentSpanId?: string | undefined;
+        } | undefined;
         stepExecutionPath?: string[] | undefined;
         resumeLabels?: {
             [x: string]: {
@@ -96,11 +101,6 @@ export declare function usePersistedWorkflowRun(workflowId: string, runId: strin
         waitingPaths?: {
             [x: string]: number[];
         } | undefined;
-        tracingContext?: {
-            traceId?: string | undefined;
-            spanId?: string | undefined;
-            parentSpanId?: string | undefined;
-        } | undefined;
         serializedStepGraph?: import('@mastra/core/workflows').SerializedStepFlowEntry[] | undefined;
     } | undefined;
     isLoading: boolean;

package/dist/src/ds/components/BillingIllustration/art/credits-art.d.ts

@@ -0,0 +1,2 @@
+import { BillingArt } from './billing-art';
+export declare const creditsArt: BillingArt;

package/dist/src/ds/components/BillingIllustration/art/plan-art.d.ts

@@ -0,0 +1,5 @@
+import { BillingArt } from './billing-art';
+export declare const freeArt: BillingArt;
+export declare const starterArt: BillingArt;
+export declare const teamsArt: BillingArt;
+export declare const enterpriseArt: BillingArt;

package/dist/src/ds/components/BillingIllustration/billing-illustration.d.ts

@@ -1,5 +1,5 @@
 import { ComponentProps } from 'react';
-export type BillingIllustrationName = 'serverless' | 'small' | 'medium' | 'large';
+export type BillingIllustrationName = 'serverless' | 'small' | 'medium' | 'large' | 'credits' | 'free' | 'starter' | 'teams' | 'enterprise';
 export type BillingIllustrationTone = 'ink' | 'muted' | 'faded';
 export type BillingIllustrationProps = Omit<ComponentProps<'svg'>, 'children' | 'viewBox'> & {
     name: BillingIllustrationName;

package/dist/src/ds/components/CodeEditor/code-editor.d.ts

@@ -16,6 +16,8 @@ export type CodeEditorProps = {
     value?: string;
     onChange?: (value: string) => void;
     showCopyButton?: boolean;
+    /** Offers a button that rewrites the JSON with Prettier. Needs `onChange`; ignored for markdown or read-only editors. */
+    showFormatButton?: boolean;
     className?: string;
     highlightVariables?: boolean;
     language?: CodeEditorLanguage;
@@ -37,6 +39,8 @@ export declare const CodeEditor: import('react').ForwardRefExoticComponent<{
     value?: string;
     onChange?: (value: string) => void;
     showCopyButton?: boolean;
+    /** Offers a button that rewrites the JSON with Prettier. Needs `onChange`; ignored for markdown or read-only editors. */
+    showFormatButton?: boolean;
     className?: string;
     highlightVariables?: boolean;
     language?: CodeEditorLanguage;

package/dist/src/ds/components/Combobox/combobox-parts.d.ts

@@ -91,7 +91,7 @@ declare function ComboboxSeparator({ className, ...props }: BaseCombobox.Separat
  * inside their own area so the chevron keeps its place on the first row. While the field is one
  * line it keeps the pill shape of every other field; once chips wrap it takes the Textarea corner.
  */
-declare function ComboboxChips({ className, children, ...props }: BaseCombobox.Chips.Props): React.JSX.Element;
+declare function ComboboxChips({ className, children, 'aria-label': ariaLabel, ...props }: BaseCombobox.InputGroup.Props): React.JSX.Element;
 /** One picked item inside ComboboxChips. The × (or Backspace in the input) removes it. */
 declare function ComboboxChip({ className, children, showRemove, ...props }: BaseCombobox.Chip.Props & {
     showRemove?: boolean;

package/dist/src/ds/components/DataList/data-list-root.d.ts

@@ -25,6 +25,8 @@ export type DataListRootProps = Omit<ScrollAreaProps, 'children' | 'orientation'
     fit?: DataListFit;
     /** Surface treatment; defaults to `default` (rows on a raised card panel). */
     variant?: DataListVariant;
+    /** Disable the internal scroll area when a parent owns scrolling, allowing row effects to extend outside the list. */
+    scrollable?: boolean;
     /**
      * Edge fades from the underlying ScrollArea. DataList keeps the top fade off
      * by default so it does not fade the sticky top header.

package/dist/src/ds/components/Select/select.d.ts

@@ -58,4 +58,8 @@ export type SelectItemProps = Omit<SelectPrimitive.Item.Props, 'className'> & {
     className?: string;
 };
 declare const SelectItem: React.ForwardRefExoticComponent<Omit<SelectItemProps, "ref"> & React.RefAttributes<HTMLDivElement>>;
-export { Select, SelectGroup, SelectValue, SelectTrigger, SelectContent, SelectItem };
+export type SelectSeparatorProps = Omit<SelectPrimitive.Separator.Props, 'className'> & {
+    className?: string;
+};
+declare const SelectSeparator: React.ForwardRefExoticComponent<Omit<SelectSeparatorProps, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export { Select, SelectGroup, SelectValue, SelectTrigger, SelectContent, SelectItem, SelectSeparator };

package/dist/src/ds/components/Sidebar/header/sidebar-badge.d.ts

@@ -0,0 +1,7 @@
+import { ComponentPropsWithoutRef } from 'react';
+export type SidebarBadgeProps = ComponentPropsWithoutRef<'span'>;
+/**
+ * A label next to the brand in the sidebar header, such as `Beta` or `Staging`. A quieter `Badge`:
+ * muted text and no inset rim, so it reads as part of the brand rather than as a control.
+ */
+export declare function SidebarBadge({ className, ...props }: SidebarBadgeProps): import("react").JSX.Element;

package/dist/src/ds/components/Sidebar/header/sidebar-button-hint.d.ts

@@ -0,0 +1,7 @@
+import { ReactNode } from 'react';
+export type SidebarButtonHintProps = {
+    label: ReactNode;
+    shortcut?: ReactNode;
+};
+/** Tooltip content for the sidebar's header buttons: the label, then its shortcut. */
+export declare function SidebarButtonHint({ label, shortcut }: SidebarButtonHintProps): import("react").JSX.Element;

package/dist/src/ds/components/Sidebar/header/sidebar-search-trigger.d.ts

@@ -1,7 +1,18 @@
-import { ComponentPropsWithoutRef, ReactNode } from 'react';
-export type SidebarSearchTriggerProps = ComponentPropsWithoutRef<'button'> & {
+import { ReactNode } from 'react';
+import { ButtonProps } from '../../Button';
+export type SidebarSearchTriggerProps = Omit<ButtonProps, 'variant' | 'size' | 'tooltip' | 'children'> & {
+    /** Tooltip label, and the accessible name unless `aria-label` is set. Defaults to `Search`. */
+    label?: string;
+    /** Shortcut shown in the tooltip next to the label, e.g. `⌘ K`. */
     shortcut?: ReactNode;
+    /** The icon. Defaults to a search glyph. */
+    children?: ReactNode;
 };
-export declare const SidebarSearchTrigger: import('react').ForwardRefExoticComponent<Omit<import('react').DetailedHTMLProps<import('react').ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref"> & {
+export declare const SidebarSearchTrigger: import('react').ForwardRefExoticComponent<Omit<ButtonProps, "children" | "size" | "tooltip" | "variant"> & {
+    /** Tooltip label, and the accessible name unless `aria-label` is set. Defaults to `Search`. */
+    label?: string;
+    /** Shortcut shown in the tooltip next to the label, e.g. `⌘ K`. */
     shortcut?: ReactNode;
+    /** The icon. Defaults to a search glyph. */
+    children?: ReactNode;
 } & import('react').RefAttributes<HTMLButtonElement>>;

package/dist/src/ds/components/Sidebar/index.d.ts

@@ -1,4 +1,5 @@
 export { Sidebar } from './sidebar';
+export { SidebarBadge, type SidebarBadgeProps } from './header/sidebar-badge';
 export { SidebarBrand, type SidebarBrandProps } from './header/sidebar-brand';
 export { SidebarCommandHeader, type SidebarCommandHeaderProps } from './header/sidebar-command-header';
 export { SidebarFooter, type SidebarFooterProps } from './footer/sidebar-footer';

package/dist/src/ds/components/Sidebar/root/sidebar-trigger.d.ts

@@ -1,3 +1,3 @@
-import { ComponentPropsWithoutRef } from 'react';
-export type SidebarTriggerProps = ComponentPropsWithoutRef<'button'>;
+import { ButtonProps } from '../../Button';
+export type SidebarTriggerProps = Omit<ButtonProps, 'variant' | 'size' | 'tooltip' | 'children'>;
 export declare function SidebarTrigger({ className, onClick, ...props }: SidebarTriggerProps): import("react").JSX.Element | null;

package/dist/src/ds/components/Sidebar/sidebar.d.ts

@@ -1,4 +1,5 @@
 import { SidebarFooter } from './footer/sidebar-footer';
+import { SidebarBadge } from './header/sidebar-badge';
 import { SidebarBrand } from './header/sidebar-brand';
 import { SidebarHeader } from './header/sidebar-header';
 import { SidebarNav } from './nav/sidebar-nav';
@@ -15,6 +16,7 @@ import { SidebarRoot } from './root/sidebar-root';
 import { SidebarTrigger } from './root/sidebar-trigger';
 import { SidebarSections } from './sections/sidebar-sections';
 export declare const Sidebar: typeof SidebarRoot & {
+    Badge: typeof SidebarBadge;
     Brand: typeof SidebarBrand;
     CommandHeader: import('react').ForwardRefExoticComponent<Omit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLElement>, HTMLElement>, "ref"> & import('react').RefAttributes<HTMLElement>>;
     Footer: typeof SidebarFooter;
@@ -37,8 +39,10 @@ export declare const Sidebar: typeof SidebarRoot & {
         View: typeof import('./nav-stack/sidebar-nav-stack-view').SidebarNavStackView;
     };
     Provider: typeof SidebarProvider;
-    SearchTrigger: import('react').ForwardRefExoticComponent<Omit<import('react').DetailedHTMLProps<import('react').ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref"> & {
+    SearchTrigger: import('react').ForwardRefExoticComponent<Omit<import('../Button').ButtonProps, "children" | "size" | "tooltip" | "variant"> & {
+        label?: string;
         shortcut?: import('react').ReactNode;
+        children?: import('react').ReactNode;
     } & import('react').RefAttributes<HTMLButtonElement>>;
     Sections: typeof SidebarSections;
     Trigger: typeof SidebarTrigger;

package/dist/src/ds/components/ai/activity/presets/notification-activity.d.ts

@@ -12,5 +12,9 @@ export interface NotificationActivityProps {
         label: string;
     };
     defaultOpen?: boolean;
+    /** Badges rendered after the priority, status and pending badges. */
+    extraBadges?: ReactNode;
+    /** A label shown above the message once opened, e.g. to flag it as untrusted. */
+    messageLabel?: string;
 }
-export declare function NotificationActivity({ label, message, state, icon, priority, status, pending, link, defaultOpen, }: NotificationActivityProps): import("react").JSX.Element;
+export declare function NotificationActivity({ label, message, state, icon, priority, status, pending, link, defaultOpen, extraBadges, messageLabel, }: NotificationActivityProps): import("react").JSX.Element;