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

package/dist/src/domains/chat/context/dataset-save-context-value.d.ts

@@ -0,0 +1,12 @@
+export interface DatasetSaveContextValue {
+    /** Whether dataset save actions should be shown on messages */
+    enabled: boolean;
+    /** Thread ID for fetching actual messages from storage */
+    threadId: string;
+    /** Agent ID for fetching messages via agent memory */
+    agentId: string;
+    /** Request context to persist with saved dataset items */
+    requestContext?: Record<string, unknown>;
+}
+export declare const DatasetSaveContext: import('react').Context<DatasetSaveContextValue | null>;
+export declare function useDatasetSaveContext(): DatasetSaveContextValue | null;

package/dist/src/domains/chat/context/dataset-save-context.d.ts

@@ -1,14 +1,5 @@
-export interface DatasetSaveContextValue {
-    /** Whether dataset save actions should be shown on messages */
-    enabled: boolean;
-    /** Thread ID for fetching actual messages from storage */
-    threadId: string;
-    /** Agent ID for fetching messages via agent memory */
-    agentId: string;
-    /** Request context to persist with saved dataset items */
-    requestContext?: Record<string, unknown>;
-}
+import { ReactNode } from 'react';
+import { DatasetSaveContextValue } from './dataset-save-context-value';
 export declare function DatasetSaveProvider({ children, ...value }: DatasetSaveContextValue & {
-    children: React.ReactNode;
+    children: ReactNode;
 }): import("react").JSX.Element;
-export declare function useDatasetSaveContext(): DatasetSaveContextValue | null;

package/dist/src/domains/chat/index.d.ts

@@ -5,5 +5,7 @@ export * from './messages/message-metadata';
 export * from './messages/signal-data';
 export * from './messages/renderers/tool-part';
 export * from './context/dataset-save-context';
+export { useDatasetSaveContext } from './context/dataset-save-context-value';
+export type { DatasetSaveContextValue } from './context/dataset-save-context-value';
 export * from './messages/dataset-save-action';
 export * from './messages/assistant-message-actions';

package/dist/src/domains/chat/messages/reasoning-content.d.ts

@@ -1,3 +1,3 @@
 import { ReasoningPart } from '@mastra/react/ui';
-import { ReasoningProps } from './reasoning';
-export declare function getReasoningContent(part: ReasoningPart): ReasoningProps | undefined;
+import { ReasoningContent } from '../../../ds/components/ai/activity';
+export declare function getReasoningContent(part: ReasoningPart): ReasoningContent | undefined;

package/dist/src/domains/chat/messages/skill-activation.d.ts

@@ -0,0 +1,8 @@
+export interface SkillActivation {
+    name: string;
+    instructions: string;
+    arguments?: string;
+    /** The work-item feed appended after the envelope: comments written by collaborators, shown as context. */
+    feed?: string;
+}
+export declare function parseSkillActivation(text: string): SkillActivation | undefined;

package/dist/src/domains/chat/messages/skill-message.d.ts

@@ -0,0 +1,4 @@
+import { SkillActivation } from './skill-activation';
+export declare function SkillMessage({ activation }: {
+    activation: SkillActivation;
+}): import("react").JSX.Element;

package/dist/src/domains/chat/tools/badges/agent-badge-wrapper.d.ts

@@ -1,7 +1,7 @@
 import { AgentMessage } from './agent-badge';
 import { MessageMetadata } from '../..';
 import { ToolApprovalButtonsProps } from './tool-approval-buttons';
-import { ToolCallStatus } from '../../../../ds/components/ai/tool-call';
+import { ActivityStatus } from '../../../../ds/components/ai/activity';
 interface SubAgentToolResult {
     toolName: string;
     toolCallId: string;
@@ -21,7 +21,7 @@ interface AgentBadgeWrapperProps extends Omit<ToolApprovalButtonsProps, 'toolCal
     suspendPayload?: any;
     toolCalled?: boolean;
     isComplete?: boolean;
-    status?: ToolCallStatus;
+    status?: ActivityStatus;
     errorText?: string;
 }
 export declare const AgentBadgeWrapper: ({ agentId, result, metadata, toolCallId, toolApprovalMetadata, toolName, isNetwork, suspendPayload, toolCalled, isComplete, status, errorText, }: AgentBadgeWrapperProps) => import("react").JSX.Element;

package/dist/src/domains/chat/tools/badges/agent-badge.d.ts

@@ -1,7 +1,7 @@
 import { default as React } from 'react';
 import { MessageMetadata } from '../..';
 import { ToolApprovalButtonsProps } from './tool-approval-buttons';
-import { ToolCallStatus } from '../../../../ds/components/ai/tool-call';
+import { ActivityStatus } from '../../../../ds/components/ai/activity';
 type TextMessage = {
     type: 'text';
     content: string;
@@ -23,10 +23,8 @@ export interface AgentBadgeProps extends Omit<ToolApprovalButtonsProps, 'toolCal
     toolCalled?: boolean;
     isComplete?: boolean;
     keepOpenForStreamingChildMessages?: boolean;
-    status?: ToolCallStatus;
-    /** Error message when the delegation failed (tool part state `output-error`). */
+    status?: ActivityStatus;
     errorText?: string;
-    /** When set, shows a control that loads older messages from the sub-agent thread. */
     onLoadPrevious?: () => void;
     isLoadingPrevious?: boolean;
 }

package/dist/src/domains/chat/tools/badges/awaits-tool-approval.d.ts

@@ -0,0 +1,4 @@
+import { ToolApprovalButtonsProps } from './tool-approval-buttons';
+type ToolApprovalState = Pick<ToolApprovalButtonsProps, 'toolApprovalMetadata' | 'toolCalled'>;
+export declare function awaitsToolApproval({ toolApprovalMetadata, toolCalled }: ToolApprovalState): boolean;
+export {};

package/dist/src/domains/chat/tools/badges/file-tree-badge.d.ts

@@ -1,12 +1,14 @@
 import { DataMessagePart } from '../tool-card';
 import { MessageMetadata } from '../..';
 import { ToolApprovalButtonsProps } from './tool-approval-buttons';
+import { ActivityStatus } from '../../../../ds/components/ai/activity';
 export interface FileTreeBadgeProps extends Omit<ToolApprovalButtonsProps, 'toolCalled'> {
     toolName: string;
     args: Record<string, unknown> | string;
-    result: any;
+    result: unknown;
     metadata?: MessageMetadata;
     toolCalled?: boolean;
     dataParts?: ReadonlyArray<DataMessagePart>;
+    status?: ActivityStatus;
 }
-export declare const FileTreeBadge: ({ toolName, args, result, toolCallId, toolApprovalMetadata, isNetwork, toolCalled: toolCalledProp, dataParts, }: FileTreeBadgeProps) => import("react").JSX.Element;
+export declare const FileTreeBadge: ({ toolName, args, result, metadata, toolCallId, toolApprovalMetadata, isNetwork, toolCalled: toolCalledProp, dataParts, status, }: FileTreeBadgeProps) => import("react").JSX.Element;

package/dist/src/domains/chat/tools/badges/observation-marker-badge.d.ts

@@ -2,6 +2,7 @@ export interface OmMarkerData {
     observedAt?: string;
     completedAt?: string;
     failedAt?: string;
+    disconnectedAt?: string;
     startedAt?: string;
     tokensObserved?: number;
     tokensToObserve?: number;
@@ -36,17 +37,7 @@ export interface OmMarkerData {
 }
 export interface ObservationMarkerBadgeProps {
     toolName: string;
-    args: Record<string, unknown>;
-    metadata?: {
-        mode?: string;
-        omData?: OmMarkerData;
-    };
+    omData: OmMarkerData;
 }
-/**
- * Renders an inline badge for OM observation markers.
- * These are converted from data-om-* parts to tool-call format for assistant-ui compatibility.
- *
- * The badge includes a `data-om-badge` attribute with the cycleId so that
- * the BracketOverlay can find it via DOM queries for positioning bracket lines.
- */
-export declare const ObservationMarkerBadge: ({ toolName, args, metadata }: ObservationMarkerBadgeProps) => import("react").JSX.Element;
+/** `data-om-*` attributes let the thread's bracket overlay find each marker in the DOM. */
+export declare const ObservationMarkerBadge: ({ toolName, omData }: ObservationMarkerBadgeProps) => import("react").JSX.Element;

package/dist/src/domains/chat/tools/badges/observation-marker-details.d.ts

@@ -0,0 +1,22 @@
+export interface ObservationStatsProps {
+    inputTokens?: number;
+    outputTokens?: number;
+    durationMs?: number;
+}
+export declare const ObservationStats: ({ inputTokens, outputTokens, durationMs }: ObservationStatsProps) => import("react").JSX.Element | null;
+export interface ObservationSectionsProps {
+    observations?: string;
+    isReflection: boolean;
+    maxHeight: string;
+    currentTask?: string;
+    suggestedResponse?: string;
+}
+export declare const ObservationSections: ({ observations, isReflection, maxHeight, currentTask, suggestedResponse, }: ObservationSectionsProps) => import("react").JSX.Element;
+export interface ExtractionsProps {
+    extractedValues?: Record<string, unknown>;
+    extractionFailures?: Array<{
+        slug: string;
+        error: string;
+    }>;
+}
+export declare const Extractions: ({ extractedValues, extractionFailures }: ExtractionsProps) => import("react").JSX.Element | null;

package/dist/src/domains/chat/tools/badges/observation-marker-format.d.ts

@@ -0,0 +1,4 @@
+export declare function formatTokens(tokens: number): string;
+export declare function compressionRatio(inputTokens?: number, outputTokens?: number): number | undefined;
+export declare function extractedValueEntries(values?: Record<string, unknown>): Array<[string, unknown]>;
+export declare function formatExtractedValue(value: unknown): string;

package/dist/src/domains/chat/tools/badges/sandbox-execution-badge.d.ts

@@ -1,12 +1,14 @@
 import { DataMessagePart } from '../tool-card';
 import { MessageMetadata } from '../..';
 import { ToolApprovalButtonsProps } from './tool-approval-buttons';
+import { ActivityStatus } from '../../../../ds/components/ai/activity';
 export interface SandboxExecutionBadgeProps extends Omit<ToolApprovalButtonsProps, 'toolCalled'> {
     toolName: string;
     args: Record<string, unknown> | string;
-    result: any;
+    result: unknown;
     metadata?: MessageMetadata;
     toolCalled?: boolean;
     dataParts?: ReadonlyArray<DataMessagePart>;
+    status?: ActivityStatus;
 }
-export declare const SandboxExecutionBadge: ({ toolName, args, result, metadata, toolCallId, toolApprovalMetadata, isNetwork, toolCalled: toolCalledProp, dataParts: dataPartsProp, }: SandboxExecutionBadgeProps) => import("react").JSX.Element;
+export declare const SandboxExecutionBadge: ({ toolName, args, result, metadata, toolCallId, toolApprovalMetadata, isNetwork, toolCalled: toolCalledProp, dataParts, status, }: SandboxExecutionBadgeProps) => import("react").JSX.Element;

package/dist/src/domains/chat/tools/badges/tool-badge.d.ts

@@ -1,6 +1,6 @@
 import { MessageMetadata } from '../..';
 import { ToolApprovalButtonsProps } from './tool-approval-buttons';
-import { ToolCallStatus } from '../../../../ds/components/ai/tool-call';
+import { ActivityStatus } from '../../../../ds/components/ai/activity';
 export interface ToolBadgeProps extends Omit<ToolApprovalButtonsProps, 'toolCalled'> {
     toolName: string;
     args: Record<string, unknown> | string;
@@ -12,6 +12,6 @@ export interface ToolBadgeProps extends Omit<ToolApprovalButtonsProps, 'toolCall
     suspendPayload?: any;
     toolCalled?: boolean;
     withoutArgs?: boolean;
-    status?: ToolCallStatus;
+    status?: ActivityStatus;
 }
 export declare const ToolBadge: ({ toolName, args, result, metadata, toolOutput, toolCallId, toolApprovalMetadata, suspendPayload, isNetwork, toolCalled: toolCalledProp, withoutArgs, status, }: ToolBadgeProps) => import("react").JSX.Element;

package/dist/src/domains/chat/tools/badges/workspace-data-parts.d.ts

@@ -0,0 +1,20 @@
+import { DataMessagePart } from '../tool-card';
+interface WorkspaceResource {
+    id?: string;
+    name?: string;
+    provider?: string;
+    status?: string;
+}
+/** Shape of `workspace.getInfo()`, written by workspace tools as a `workspace-metadata` data part. */
+export interface WorkspaceMetadata {
+    toolName?: string;
+    id?: string;
+    name?: string;
+    status?: string;
+    filesystem?: WorkspaceResource;
+    sandbox?: WorkspaceResource;
+}
+export declare function parseToolArgs(args: Record<string, unknown> | string): Record<string, unknown>;
+export declare function toolDataParts(dataParts: ReadonlyArray<DataMessagePart> | undefined, name: string, toolCallId: string): DataMessagePart[];
+export declare function workspaceMetadata(dataParts: ReadonlyArray<DataMessagePart> | undefined, toolCallId: string): WorkspaceMetadata | undefined;
+export {};

package/dist/src/domains/chat/tools/badges/workspace-link.d.ts

@@ -0,0 +1,7 @@
+import { ReactNode } from 'react';
+export interface WorkspaceLinkProps {
+    href: string;
+    icon: ReactNode;
+    children: ReactNode;
+}
+export declare const WorkspaceLink: ({ href, icon, children }: WorkspaceLinkProps) => import("react").JSX.Element;

package/dist/src/domains/chat/tools/submit-plan-tool.d.ts

@@ -1,6 +1,7 @@
 import { MessageMetadata } from '..';
 export interface SubmitPlanToolProps {
-    agentId: string;
+    /** Omitted for read-only history (e.g. traces): submitted plans still render, pending ones can't be answered. */
+    agentId?: string;
     agentVersionId?: string;
     requestContext?: Record<string, any>;
     toolName: string;

package/dist/src/domains/chat/tools/tool-card-kind.d.ts

@@ -1,6 +1,6 @@
 import { MessageMetadata, SuspendedToolMetadata, ToolApprovalMetadata } from '../messages/message-metadata';
 import { ToolPartFields } from '../messages/renderers/tool-part';
-import { ToolCallStatus } from '../../../ds/components/ai/tool-call';
+import { ActivityStatus } from '../../../ds/components/ai/activity';
 /** Which card draws a call. Decided once, shared by the dispatcher and the fold. */
 export type ToolCardKind = 'hidden' | 'observation' | 'ask_user' | 'submit_plan' | 'background' | 'agent' | 'workflow' | 'file_tree' | 'sandbox' | 'code_mode' | 'mcp_app' | 'plain';
 export interface ToolCardContext {
@@ -15,7 +15,7 @@ export declare const isAgentCall: (metadata: MessageMetadata | undefined, toolNa
 export declare const isWorkflowCall: (metadata: MessageMetadata | undefined, toolName: string) => boolean;
 export declare const isSettledState: (state: string | undefined) => boolean;
 /** A call neither settled nor carried by a live run reads as idle, so stale history never shimmers. */
-export declare function badgeStatus(state: string | undefined, chatRunning: boolean): ToolCallStatus;
+export declare function badgeStatus(state: string | undefined, chatRunning: boolean): ActivityStatus;
 export declare const codeModeCall: (input: unknown, output: unknown) => {
     code: string;
     result?: import('./code-mode').CodeModeResult;

package/dist/src/domains/memory/lib/observation-priority.d.ts

@@ -0,0 +1,33 @@
+export type ObservationPriority = 'high' | 'medium' | 'low' | 'complete';
+export declare const observationPriorityByEmoji: {
+    readonly '\uD83D\uDD34': "high";
+    readonly '\uD83D\uDFE1': "medium";
+    readonly '\uD83D\uDFE2': "low";
+    readonly '\u2705': "complete";
+};
+export declare const observationPriorityTone: {
+    high: {
+        card: string;
+        fill: string;
+        accentBorder: string;
+        time: string;
+    };
+    medium: {
+        card: string;
+        fill: string;
+        accentBorder: string;
+        time: string;
+    };
+    low: {
+        card: string;
+        fill: string;
+        accentBorder: string;
+        time: string;
+    };
+    complete: {
+        card: string;
+        fill: string;
+        accentBorder: string;
+        time: string;
+    };
+};

package/dist/src/domains/traces/components/thread-trace/index.d.ts

@@ -2,7 +2,6 @@ import { ThreadTraceDetails, ThreadTraceDetailsActions, ThreadTraceDetailsHeader
 import { ThreadTraceList } from './thread-trace-list';
 import { ThreadTraceLoadMoreSentinel } from './thread-trace-load-more-sentinel';
 import { ThreadTraceMessages, ThreadTraceMessagesHeader, ThreadTraceTabContent, ThreadTraceTabList } from './thread-trace-messages';
-import { ThreadTraceRail } from './thread-trace-rail';
 import { ThreadTraceRoot } from './thread-trace-root';
 import { ThreadTraceRow } from './thread-trace-row';
 import { ThreadTraceSpanPanel } from './thread-trace-span-panel';
@@ -16,7 +15,6 @@ import { ThreadTraceSpans } from './thread-trace-spans';
  * @example
  * <ThreadTrace traceIds={ids} anchorTraceId={anchor}>
  *   <ThreadTrace.List>
- *     <ThreadTrace.Rail turns={turns} />
  *     <ThreadTrace.LoadMoreSentinel ref={setEndOfListElement} />
  *     {ids.map((traceId, i) => (
  *       <ThreadTrace.Row key={traceId} traceId={traceId}>
@@ -42,7 +40,6 @@ import { ThreadTraceSpans } from './thread-trace-spans';
  */
 export declare const ThreadTrace: typeof ThreadTraceRoot & {
     List: typeof ThreadTraceList;
-    Rail: typeof ThreadTraceRail;
     LoadMoreSentinel: typeof ThreadTraceLoadMoreSentinel;
     Row: typeof ThreadTraceRow;
     Messages: typeof ThreadTraceMessages;
@@ -63,7 +60,6 @@ export type { ThreadTraceRowContextValue } from './thread-trace-row-context';
 export { THREAD_TRACE_MESSAGES_TAB } from './thread-trace-row';
 export type { ThreadTraceRootProps } from './thread-trace-root';
 export type { ThreadTraceListProps } from './thread-trace-list';
-export type { ThreadTraceRailProps } from './thread-trace-rail';
 export type { ThreadTraceLoadMoreSentinelProps } from './thread-trace-load-more-sentinel';
 export type { ThreadTraceRowProps } from './thread-trace-row';
 export type { ThreadTraceMessagesProps, ThreadTraceMessagesHeaderProps, ThreadTraceTabListProps, ThreadTraceTabProps, ThreadTraceTabContentProps, } from './thread-trace-messages';

package/dist/src/domains/traces/components/trace-data-panel-view.stories.d.ts

@@ -20,7 +20,7 @@ declare const meta: {
         initialSpanId?: string | null | undefined;
         onPrevious?: (() => void) | undefined;
         onNext?: (() => void) | undefined;
-        size?: "md" | "half" | "wide" | "full" | undefined;
+        size?: "md" | "full" | "half" | "wide" | undefined;
         depth?: 3 | 1 | 2 | undefined;
         headerSlot?: import('react').ReactNode;
         title?: string | undefined;

package/dist/src/domains/workflows/components/workflow-layout.d.ts

@@ -7,6 +7,6 @@ export interface WorkflowLayoutProps {
  * suspended steps, data inspector. `raisedSurfaceStyle` carries the rim, so the
  * panels never draw a border of their own; the radius belongs to the family.
  */
-export declare const panelSurfaceStyle = "bg-card hover:bg-card active:bg-card shadow-raised [--field:var(--field-on-surface)] [--field-disabled:var(--field-on-surface)] [--field-rim:var(--field-rim-on-surface)] [--field-rim-focus:var(--field-rim-focus-on-surface)] rounded-studio-panel";
+export declare const panelSurfaceStyle = "bg-card hover:bg-card active:bg-card shadow-raised [--field:var(--field-on-surface)] [--field-disabled:var(--field-on-surface)] [--field-rim:var(--field-rim-on-surface)] rounded-studio-panel";
 export declare function WorkflowPanelResizeHandle(): import("react").JSX.Element | null;
 export declare const WorkflowLayout: ({ children, leftSlot }: WorkflowLayoutProps) => import("react").JSX.Element;

package/dist/src/domains/workflows/utils/nested-workflows.d.ts

@@ -18,10 +18,10 @@ interface TreeRowBase {
 export type WorkflowTreeRow = (TreeRowBase & {
     kind: 'workflow';
     workflow: WorkflowListEntry;
-    /** Direct nested workflow step ids (registered or inline), for the badge and expansion. */
+    /** Direct nested workflow step ids (registered or not), for the badge and expansion. */
     nestedIds: string[];
 }) | (TreeRowBase & {
-    kind: 'inline';
+    kind: 'unregistered';
     /** Nested workflow that is not registered standalone — rendered as a non-link leaf row. */
     stepId: string;
     description?: string;
@@ -41,7 +41,7 @@ export declare function buildRegistryIndex(workflowsById: Record<string, GetWork
 /**
  * Flattens the visible rows of the workflows tree: every root, plus the
  * children of each expanded row, depth-first. Registered children recurse as
- * full workflow rows; inline-only nested workflows render as leaf rows. An
+ * full workflow rows; unregistered nested workflows render as leaf rows. An
  * ancestor guard drops a child already on its own ancestry path, so mutually
  * nested workflows cannot expand forever.
  */

package/dist/src/domains/workflows/workflow-status-tone.d.ts

@@ -0,0 +1,16 @@
+export type WorkflowStatusTone = 'success' | 'destructive' | 'info' | 'warning' | 'neutral';
+export declare function workflowStatusTone(status: string | undefined): WorkflowStatusTone;
+export declare const workflowStatusToneText: {
+    success: string;
+    destructive: string;
+    info: string;
+    warning: string;
+    neutral: string;
+};
+export declare const workflowStatusToneBar: {
+    success: string;
+    destructive: string;
+    info: string;
+    warning: string;
+    neutral: string;
+};

package/dist/src/ds/components/AlertDialog/alert-dialog.d.ts

@@ -1,49 +1,22 @@
 import { AlertDialog as AlertDialogPrimitive } from '@base-ui/react/alert-dialog';
-import * as React from 'react';
-declare function AlertDialog({ open, onOpenChange, children, }: {
-    open?: boolean;
-    onOpenChange?: (open: boolean) => void;
-    children: React.ReactNode;
-}): React.JSX.Element;
+import { DialogBody, DialogCancel, DialogDescription, DialogFooter, DialogHeader, DialogTitle } from '../Dialog';
+import { DialogSize } from '../Dialog/dialog-shell';
+declare function AlertDialog(props: AlertDialogPrimitive.Root.Props): import("react").JSX.Element;
 declare namespace AlertDialog {
-    var Trigger: React.ForwardRefExoticComponent<Omit<AlertDialogTriggerProps, "ref"> & React.RefAttributes<HTMLButtonElement>>;
-    var Portal: React.ForwardRefExoticComponent<Omit<import("@base-ui/react").AlertDialogPortalProps, "ref"> & React.RefAttributes<HTMLDivElement>>;
-    var Overlay: React.ForwardRefExoticComponent<Omit<AlertDialogOverlayProps, "ref"> & React.RefAttributes<HTMLDivElement>>;
-    var Content: React.ForwardRefExoticComponent<Omit<AlertDialogContentProps, "ref"> & React.RefAttributes<HTMLDivElement>>;
-    var Header: {
-        ({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): React.JSX.Element;
-        displayName: string;
-    };
-    var Footer: {
-        ({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): React.JSX.Element;
-        displayName: string;
-    };
-    var Body: {
-        ({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): React.JSX.Element;
-        displayName: string;
-    };
-    var Title: React.ForwardRefExoticComponent<Omit<AlertDialogTitleProps, "ref"> & React.RefAttributes<HTMLHeadingElement>>;
-    var Description: React.ForwardRefExoticComponent<Omit<AlertDialogDescriptionProps, "ref"> & React.RefAttributes<HTMLParagraphElement>>;
-    var Action: React.ForwardRefExoticComponent<Omit<AlertDialogActionProps, "ref"> & React.RefAttributes<HTMLButtonElement>>;
-    var Cancel: React.ForwardRefExoticComponent<Omit<AlertDialogActionProps, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+    var Trigger: AlertDialogPrimitive.Trigger;
+    var Content: typeof AlertDialogContent;
+    var Header: typeof DialogHeader;
+    var Footer: typeof DialogFooter;
+    var Body: typeof DialogBody;
+    var Title: typeof DialogTitle;
+    var Description: typeof DialogDescription;
+    var Action: typeof AlertDialogAction;
+    var Cancel: typeof DialogCancel;
 }
-type AlertDialogTriggerProps = AlertDialogPrimitive.Trigger.Props & {
-    /** @deprecated Use Base UI's native `render` prop instead for stronger composition typing. */
-    asChild?: boolean;
-};
-type AlertDialogOverlayProps = Omit<AlertDialogPrimitive.Backdrop.Props, 'className'> & {
-    className?: string;
-};
 type AlertDialogContentProps = Omit<AlertDialogPrimitive.Popup.Props, 'className'> & {
     className?: string;
+    size?: DialogSize;
 };
-type AlertDialogTitleProps = Omit<AlertDialogPrimitive.Title.Props, 'className'> & {
-    className?: string;
-};
-type AlertDialogDescriptionProps = Omit<AlertDialogPrimitive.Description.Props, 'className'> & {
-    className?: string;
-};
-type AlertDialogActionProps = Omit<AlertDialogPrimitive.Close.Props, 'className'> & {
-    className?: string;
-};
+declare function AlertDialogContent({ className, size, ...props }: AlertDialogContentProps): import("react").JSX.Element;
+declare function AlertDialogAction({ children, ...props }: AlertDialogPrimitive.Close.Props): import("react").JSX.Element;
 export { AlertDialog };

package/dist/src/ds/components/Badge/Badge.d.ts

@@ -1,50 +1,100 @@
 import { HTMLAttributes, ReactNode } from 'react';
-export type BadgeEmphasis = 'default' | 'muted';
+export type BadgeEmphasis = 'strong' | 'subtle';
 export type BadgeIndicator = 'dot' | 'pulse';
 declare const badgeToneStyles: {
+    studio: {
+        strong: string;
+        subtle: string;
+        indicator: string;
+    };
+    server: {
+        strong: string;
+        subtle: string;
+        indicator: string;
+    };
+    observability: {
+        strong: string;
+        subtle: string;
+        indicator: string;
+    };
+    factory: {
+        strong: string;
+        subtle: string;
+        indicator: string;
+    };
+    workers: {
+        strong: string;
+        subtle: string;
+        indicator: string;
+    };
+    'persistent-server': {
+        strong: string;
+        subtle: string;
+        indicator: string;
+    };
     neutral: {
-        default: string;
-        muted: string;
+        strong: string;
+        subtle: string;
         indicator: string;
     };
+    success: {
+        indicator: string;
+        strong: string;
+        subtle: string;
+    };
+    destructive: {
+        indicator: string;
+        strong: string;
+        subtle: string;
+    };
+    info: {
+        indicator: string;
+        strong: string;
+        subtle: string;
+    };
+    warning: {
+        indicator: string;
+        strong: string;
+        subtle: string;
+    };
     green: {
-        default: string;
-        muted: string;
+        strong: string;
+        subtle: string;
         indicator: string;
     };
     red: {
-        default: string;
-        muted: string;
+        strong: string;
+        subtle: string;
         indicator: string;
     };
-    blue: {
-        default: string;
-        muted: string;
+    yellow: {
+        strong: string;
+        subtle: string;
         indicator: string;
     };
-    yellow: {
-        default: string;
-        muted: string;
+    blue: {
+        strong: string;
+        subtle: string;
         indicator: string;
     };
     purple: {
-        default: string;
-        muted: string;
+        strong: string;
+        subtle: string;
         indicator: string;
     };
     orange: {
-        default: string;
-        muted: string;
+        strong: string;
+        subtle: string;
         indicator: string;
     };
     cyan: {
-        default: string;
-        muted: string;
+        strong: string;
+        subtle: string;
         indicator: string;
     };
     pink: {
-        default: string;
-        muted: string;
+        strong: string;
+        subtle: string;
         indicator: string;
     };
 };

package/dist/src/ds/components/Badge/badge.stories.d.ts

@@ -1,8 +1,14 @@
-import { Meta, StoryObj } from '@storybook/react-vite';
-import { Badge } from './Badge';
-declare const meta: Meta<typeof Badge>;
+import { StoryObj } from '@storybook/react-vite';
+import { BadgeProps } from './Badge';
+declare const meta: {
+    title: string;
+    component: ({ icon, indicator, variant, emphasis, size, className, children, ...props }: BadgeProps) => import("react").JSX.Element;
+    parameters: {
+        layout: string;
+    };
+};
 export default meta;
-type Story = StoryObj<typeof Badge>;
+type Story = StoryObj<typeof meta>;
 export declare const StyleComparison: Story;
 export declare const Matrix: Story;
 export declare const Emphasis: Story;

package/dist/src/ds/components/CodeDiff/code-diff.d.ts

@@ -1,5 +1,15 @@
-export interface CodeDiffProps {
+export type CodeDiffProps = {
+    className?: string;
+    layout?: 'split' | 'unified';
+} & ({
     codeA: string;
     codeB: string;
-}
-export declare function CodeDiff({ codeA, codeB }: CodeDiffProps): import("react").JSX.Element;
+    filename?: string;
+    patch?: never;
+} | {
+    patch: string;
+    codeA?: never;
+    codeB?: never;
+    filename?: never;
+});
+export declare function CodeDiff({ className, layout, ...source }: CodeDiffProps): import("react").JSX.Element;