@mastra/playground-ui 66.1.0-alpha.2 → 67.0.0

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

@@ -4,4 +4,5 @@ export { ActivityDisclosureProvider } from './activity-disclosure-provider';
 export { useActivityRow } from './use-activity-disclosure';
 export { ActivityTimedTrigger } from './components/activity-timed-trigger';
 export type { ActivityTimedTriggerProps } from './components/activity-timed-trigger';
-export type { ActivityCall, ActivityCallStatus, ActivityMember, ActivityThought } from './model/activity-members';
+export type { ActivityCall, ActivityCallState, ActivityCallStatus, ActivityMember, ActivityThought, } from './model/activity-members';
+export { callPose, liveWords } from './model/activity-words';

package/dist/src/domains/chat/activity/model/activity-members.d.ts

@@ -13,6 +13,7 @@ export interface ActivityCall {
     /** What opening the call alone shows; absent when it has nothing to show. */
     body?: ReactNode;
 }
+export type ActivityCallState = Pick<ActivityCall, 'toolName' | 'args' | 'status' | 'startedAt'>;
 export interface ActivityThought {
     kind: 'thought';
     key: string;

package/dist/src/domains/chat/activity/model/activity-words.d.ts

@@ -1,5 +1,6 @@
 import type { LucideIcon } from 'lucide-react';
 import type { ActivityCall } from './activity-members';
+import type { AgentIndicatorState } from '../../../../ds/components/AgentIndicator';
 export interface ActivityWords {
     icon: LucideIcon;
     label: string;
@@ -12,6 +13,8 @@ export interface CallsOutcome {
     incomplete: number;
 }
 type WordedCall = Pick<ActivityCall, 'toolName' | 'args' | 'status'>;
+export declare function callPose(toolName: string): AgentIndicatorState;
+export declare function stretchPose(calls: readonly WordedCall[], live: boolean): AgentIndicatorState;
 /** What the stretch is doing now: the latest running call, or thinking between calls. */
 export declare function liveWords(calls: readonly WordedCall[]): ActivityWords;
 /** What the stretch did: a lone call in the past tense, several as one sentence of kinds. */

package/dist/src/domains/chat/messages/renderers/tool-part.d.ts

@@ -7,6 +7,10 @@ export interface ToolPartFields {
     input: unknown;
     output: unknown;
     modelOutput?: unknown;
+    /** The Mastra background task running the call, when it was deferred. */
+    backgroundTaskId?: string;
+    /** `running` while a deferred call's part holds a placeholder; `completed`/`failed` once it holds the result. */
+    backgroundTaskStatus?: string;
     state?: string;
     errorText?: string;
 }

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

@@ -1,5 +1,7 @@
 import type { SkillActivation } from './skill-activation';
-export declare function SkillMessage({ activation, defaultOpen }: {
+import type { ActivityAppearance } from '../../../ds/components/ai/activity';
+export declare function SkillMessage({ activation, defaultOpen, appearance, }: {
     activation: SkillActivation;
     defaultOpen?: boolean;
+    appearance?: ActivityAppearance;
 }): import("react").JSX.Element;

package/dist/src/domains/chat/tools/badges/mcp-task-chip.d.ts

@@ -0,0 +1,14 @@
+import type { McpTaskView } from './use-mcp-task-progress';
+/** `task · working · 0:42` for a tool call that continued as an MCP task, with its task id to copy. */
+export declare function McpTaskChip({ task }: {
+    task: McpTaskView;
+}): import("react").JSX.Element;
+/**
+ * The chip for a call deferred to a Mastra background task. The chat stream ends with the turn, so
+ * the task's later progress and its end never reach this card; until the progress shows the task
+ * ended, the background task is polled for how it ended.
+ */
+export declare function BackgroundMcpTaskChip({ task, backgroundTaskId }: {
+    task: McpTaskView;
+    backgroundTaskId: string;
+}): import("react").JSX.Element;

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

@@ -13,5 +13,9 @@ export interface ToolBadgeProps extends Omit<ToolApprovalRequest, 'toolCalled'>
     toolCalled?: boolean;
     withoutArgs?: boolean;
     status?: ActivityStatus;
+    /** The Mastra background task running the call, when it was deferred. */
+    backgroundTaskId?: string;
+    /** `running` while the part holds a deferred call's placeholder; `completed`/`failed` once it holds the result. */
+    backgroundTaskStatus?: string;
 }
-export declare const ToolBadge: ({ toolName, args, result, metadata, toolOutput, toolCallId, toolApprovalMetadata, suspendPayload, isNetwork, toolCalled: toolCalledProp, withoutArgs, status, }: ToolBadgeProps) => import("react").JSX.Element;
+export declare const ToolBadge: ({ toolName, args, result, metadata, toolOutput, toolCallId, toolApprovalMetadata, suspendPayload, isNetwork, toolCalled: toolCalledProp, withoutArgs, status, backgroundTaskId, backgroundTaskStatus, }: ToolBadgeProps) => import("react").JSX.Element;

package/dist/src/domains/chat/tools/badges/use-mcp-task-progress.d.ts

@@ -0,0 +1,27 @@
+import type { ActivityStatus } from '../../../../ds/components/ai/activity';
+export type McpTaskStatus = 'working' | 'input_required' | 'completed' | 'failed' | 'cancelled';
+/** What `@mastra/mcp`'s client writes to a task-backed tool's output stream (`MCPTaskProgress`). */
+export interface McpTaskProgress {
+    type: 'mcp-task';
+    taskId: string;
+    status: McpTaskStatus;
+    createdAt: string;
+    serverName: string;
+}
+export declare const isTerminalMcpTaskStatus: (status: McpTaskStatus) => status is "cancelled" | "completed" | "failed";
+export interface McpTaskView extends McpTaskProgress {
+    /** When the card saw the task end; the elapsed time stops here. */
+    endedAt?: number;
+}
+/**
+ * The MCP task behind a tool call, if the call continued as one. The final result replaces the
+ * progress writes, so the last one seen is kept for as long as the card is mounted; its terminal
+ * status then comes from how the call ended. Progress isn't saved with the thread, so a reloaded
+ * card has no task to show.
+ *
+ * A deferred call (one running as a Mastra background task) settles its part with a placeholder
+ * long before the task ends, so its end is never inferred here: the background task says when.
+ */
+export declare function useMcpTaskProgress(result: unknown, status: ActivityStatus, { deferred }?: {
+    deferred?: boolean;
+}): McpTaskView | undefined;

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

@@ -10,6 +10,10 @@ export interface ToolCardProps {
     input: any;
     output: any;
     modelOutput?: unknown;
+    /** The Mastra background task running the call, when it was deferred. */
+    backgroundTaskId?: string;
+    /** The background task's status in the part's metadata: `running` until the part holds its result. */
+    backgroundTaskStatus?: string;
     toolCallId: string;
     /** Part state: v5 `output-available`/`output-error`/`input-available`, or v4 `result`/`call`. */
     state?: string;
@@ -23,4 +27,4 @@ export interface ToolCardProps {
 }
 /** Its own workflow run scope, so a streaming workflow result can drive a live graph inside the card. */
 export declare const ToolCard: (props: ToolCardProps) => import("react").JSX.Element;
-export declare const ToolCardInner: ({ toolName, input, output, modelOutput, toolCallId, state, errorText, metadata, dataParts, readOnly, }: ToolCardProps) => import("react").JSX.Element | null;
+export declare const ToolCardInner: ({ toolName, input, output, modelOutput, backgroundTaskId, backgroundTaskStatus, toolCallId, state, errorText, metadata, dataParts, readOnly, }: ToolCardProps) => import("react").JSX.Element | null;

package/dist/src/domains/dashboards/components/dashboard-grid.d.ts

@@ -0,0 +1,18 @@
+import type { DASHBOARD_WIDGET_SPANS } from '@mastra/core/storage/dashboards';
+import type { ReactNode } from 'react';
+export type DashboardSpan = (typeof DASHBOARD_WIDGET_SPANS)[number];
+/** One dashboard row: its own grid, so a short row never pulls widgets up from the next. */
+export declare function DashboardGridRow({ children }: {
+    children: ReactNode;
+}): import("react").JSX.Element;
+/** A grid cell; the grid owns the width, so a card's own `min-w-*` is neutralised. */
+export declare function DashboardGridCell({ span, id, children }: {
+    span: DashboardSpan;
+    id?: string;
+    children: ReactNode;
+}): import("react").JSX.Element;
+/** The dashboard's rows, sized by the container's width rather than the viewport's. */
+export declare function DashboardGrid({ children, className }: {
+    children: ReactNode;
+    className?: string;
+}): import("react").JSX.Element;

package/dist/src/domains/dashboards/components/dashboard-renderer.d.ts

@@ -0,0 +1,19 @@
+import type { DashboardDefinition } from '@mastra/client-js';
+import type { DashboardScope, OnDashboardDrilldown } from '../lib/definition';
+import type { AnyWidgetKind } from '../widget-kind';
+export type DashboardRendererProps = {
+    definition: DashboardDefinition;
+    /** Which widgets, views and columns show: `org` spans several projects, `project` is one. */
+    scope: DashboardScope;
+    /** Opens a drilldown; each host routes to its own Traces or Logs page. */
+    onDrilldown?: OnDashboardDrilldown;
+    /** Kinds beyond the built-in ones; a kind of the same name replaces the built-in. */
+    kinds?: AnyWidgetKind[];
+    className?: string;
+};
+/**
+ * Lays a dashboard definition out on a 12-column grid inside the page's `MetricsProvider`, which
+ * owns the range and filters. Each widget is checked and rendered on its own: one that fails to
+ * parse, query or render shows its own error, and the rest of the dashboard still renders.
+ */
+export declare function DashboardRenderer({ definition, scope, onDrilldown, kinds, className }: DashboardRendererProps): import("react").JSX.Element;

package/dist/src/domains/dashboards/components/view-gate.d.ts

@@ -0,0 +1,30 @@
+import type { DashboardQuery } from '@mastra/client-js';
+import type { ReactNode } from 'react';
+import type { DashboardPageContext } from '../lib/requests';
+/** A view that can't run yet: capabilities loading, or a page filter its aggregates can't apply. */
+export type PendingGate = {
+    status: 'loading';
+} | {
+    status: 'unsupported-filter';
+    unsupportedFields: string[];
+};
+/** The page filters `queries` can't apply; `undefined` when they apply them all. */
+export type BlockedFields = (queries: DashboardQuery[]) => string[] | undefined;
+type GateProps = {
+    queries: DashboardQuery[];
+    /** Rendered with the page context once every query can run. */
+    children: (page: DashboardPageContext, blocked: BlockedFields) => ReactNode;
+    /** Rendered while a gate isn't ready; a server without the aggregates renders nothing. */
+    pending: (gate: PendingGate) => ReactNode;
+    /**
+     * Renders `children` even when a page filter can't apply, for widgets whose views each say so on
+     * their own (a table's tabs); they check `blocked`.
+     */
+    partial?: boolean;
+};
+/**
+ * The page context for a widget's queries. Metrics and scores answer every filter; queries with trace
+ * or span aggregates wait on their gates, as the cards built on them do.
+ */
+export declare function ViewGate(props: GateProps): import("react").JSX.Element;
+export {};

package/dist/src/domains/dashboards/components/widget-chrome.d.ts

@@ -0,0 +1,7 @@
+import type { ViewHeading } from '../lib/chrome';
+import type { PendingGate } from './view-gate';
+/** A chart widget while its aggregate gates aren't ready, as `TraceAggregateCard` shows it. */
+export declare function PendingChartCard({ gate, heading }: {
+    gate: PendingGate;
+    heading: ViewHeading;
+}): import("react").JSX.Element;

package/dist/src/domains/dashboards/components/widget-controls.d.ts

@@ -0,0 +1,8 @@
+import type { DashboardWidget, DashboardWidgetView } from '@mastra/client-js';
+import type { OnDashboardDrilldown } from '../lib/definition';
+/** The view's action button, named for the page it opens (Logs names errors only when the target keeps to them). */
+export declare function DrilldownAction({ widget, view, onDrilldown, }: {
+    widget: DashboardWidget;
+    view: DashboardWidgetView;
+    onDrilldown: OnDashboardDrilldown | undefined;
+}): import("react").JSX.Element | null;

package/dist/src/domains/dashboards/components/widget-error.d.ts

@@ -0,0 +1,6 @@
+import type { DashboardWidget } from '@mastra/client-js';
+/** A widget that can't render: its own card, so the rest of the dashboard still does. */
+export declare function WidgetError({ widget, message }: {
+    widget: Pick<DashboardWidget, 'id' | 'title'>;
+    message: string;
+}): import("react").JSX.Element;

package/dist/src/domains/dashboards/hooks/use-dashboard-requests.d.ts

@@ -0,0 +1,10 @@
+import type { UseQueryResult } from '@tanstack/react-query';
+import type { DashboardAnswer, DashboardRequest } from '../lib/requests';
+export type DashboardQueryResult = UseQueryResult<DashboardAnswer>;
+/**
+ * Sends a view's requests; equal requests share one fetch across widgets. Results line up with
+ * `requests`: an `undefined` request keeps its slot without sending anything. A request whose key
+ * changed has no answer until its own arrives, so a widget never shows one window's or filter's
+ * figures under another: it loads instead, and dims only while refetching an answer it already has.
+ */
+export declare function useDashboardRequests(requests: (DashboardRequest | undefined)[]): (DashboardQueryResult | undefined)[];

package/dist/src/domains/dashboards/hooks/use-scorers.d.ts

@@ -0,0 +1,66 @@
+import type { DashboardQuery } from '@mastra/client-js';
+import type { DashboardPageContext } from '../lib/requests';
+/**
+ * The scorers to chart: the queries' own scorer, or, when they leave it out, every scorer among the
+ * range's most recent scores, as the Scores card finds them (the API can't list scorers).
+ */
+export declare function useScorers(queries: DashboardQuery[], page: DashboardPageContext): {
+    recent: import("@tanstack/react-query").UseQueryResult<{
+        pagination?: {
+            total: number;
+            page: number;
+            perPage: number | false;
+            hasMore: boolean;
+        } | undefined;
+        delta?: {
+            limit: number;
+            hasMore: boolean;
+        } | undefined;
+        deltaCursor?: string | undefined;
+        scores: {
+            scoreId?: (string | null) | undefined;
+            timestamp: string;
+            traceId?: (string | null) | undefined;
+            spanId?: (string | null) | undefined;
+            scorerId: string;
+            scorerName?: (string | null) | undefined;
+            scorerVersion?: (string | null) | undefined;
+            scoreSource?: (string | null) | undefined;
+            source?: (string | null) | undefined;
+            score: number;
+            reason?: (string | null) | undefined;
+            entityType?: (("agent" | "classifier" | "input_processor" | "input_step_processor" | "mcp_server" | "memory" | "output_processor" | "output_step_processor" | "rag_ingestion" | "scorer" | "tool" | "tool_result_processor" | "trajectory" | "workflow_run" | "workflow_step") | null) | undefined;
+            entityId?: (string | null) | undefined;
+            entityName?: (string | null) | undefined;
+            parentEntityType?: (("agent" | "classifier" | "input_processor" | "input_step_processor" | "mcp_server" | "memory" | "output_processor" | "output_step_processor" | "rag_ingestion" | "scorer" | "tool" | "tool_result_processor" | "trajectory" | "workflow_run" | "workflow_step") | null) | undefined;
+            parentEntityId?: (string | null) | undefined;
+            parentEntityName?: (string | null) | undefined;
+            rootEntityType?: (("agent" | "classifier" | "input_processor" | "input_step_processor" | "mcp_server" | "memory" | "output_processor" | "output_step_processor" | "rag_ingestion" | "scorer" | "tool" | "tool_result_processor" | "trajectory" | "workflow_run" | "workflow_step") | null) | undefined;
+            rootEntityId?: (string | null) | undefined;
+            rootEntityName?: (string | null) | undefined;
+            userId?: (string | null) | undefined;
+            organizationId?: (string | null) | undefined;
+            resourceId?: (string | null) | undefined;
+            runId?: (string | null) | undefined;
+            sessionId?: (string | null) | undefined;
+            threadId?: (string | null) | undefined;
+            requestId?: (string | null) | undefined;
+            environment?: (string | null) | undefined;
+            serviceName?: (string | null) | undefined;
+            scope?: ({
+                [key: string]: unknown;
+            } | null) | undefined;
+            entityVersionId?: (string | null) | undefined;
+            parentEntityVersionId?: (string | null) | undefined;
+            rootEntityVersionId?: (string | null) | undefined;
+            experimentId?: (string | null) | undefined;
+            executionSource?: (string | null) | undefined;
+            tags?: (string[] | null) | undefined;
+            scoreTraceId?: (string | null) | undefined;
+            metadata?: ({
+                [key: string]: unknown;
+            } | null) | undefined;
+        }[];
+    }, Error>;
+    scorers: import("../lib/scores").Scorer[];
+};

package/dist/src/domains/dashboards/hooks/use-widget-views.d.ts

@@ -0,0 +1,18 @@
+import type { DashboardWidget, DashboardWidgetView } from '@mastra/client-js';
+import type { DrilldownScope } from '../../metrics/drilldown';
+import type { OnDashboardDrilldown } from '../lib/definition';
+import type { ResolvedView } from '../widget-kind';
+export type Views<Options> = readonly [ResolvedView<Options>, ...ResolvedView<Options>[]];
+/**
+ * The open view of a widget, `defaultIndex` until one is picked, and the card title for it
+ * (`title`, and `titleMenu` with several views) to spread into `ChartCard`.
+ */
+export declare function useViewMenu<Options>(widget: DashboardWidget, views: Views<Options>, defaultIndex?: number): {
+    view: ResolvedView<Options>;
+    index: number;
+    heading: import("../lib/chrome").ViewHeading;
+};
+/** What clicking a bucket or row opens, with what was clicked; `undefined` when the view has no click target. */
+export declare function useDrilldown(widget: DashboardWidget, view: DashboardWidgetView, onDrilldown: OnDashboardDrilldown | undefined): ((clicked: DrilldownScope) => void) | undefined;
+/** Whether the view has an action button to show (`DrilldownAction`). */
+export declare const hasDrilldownAction: (widget: DashboardWidget, view: DashboardWidgetView, onDrilldown: OnDashboardDrilldown | undefined) => boolean;

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

@@ -0,0 +1,19 @@
+export { DashboardRenderer } from './components/dashboard-renderer';
+export { prepareWidget } from './lib/prepare-widget';
+export type { PreparedWidget } from './lib/prepare-widget';
+export type { DashboardRendererProps } from './components/dashboard-renderer';
+export { DashboardGrid, DashboardGridCell, DashboardGridRow } from './components/dashboard-grid';
+export type { DashboardSpan } from './components/dashboard-grid';
+export { ViewGate } from './components/view-gate';
+export { WidgetError } from './components/widget-error';
+export { DrilldownAction } from './components/widget-controls';
+export { METRICS_DASHBOARD } from './metrics-dashboard';
+export { useDashboardRequests } from './hooks/use-dashboard-requests';
+export { hasDrilldownAction, useDrilldown, useViewMenu } from './hooks/use-widget-views';
+export * from './kinds';
+export { dashboardDefaults } from './lib/definition';
+export type { DashboardScope, OnDashboardDrilldown } from './lib/definition';
+export { buildRequest } from './lib/requests';
+export type { DashboardPageContext, DashboardRequest } from './lib/requests';
+export { defineWidgetKind } from './widget-kind';
+export type { AnyWidgetKind, ResolvedView, WidgetKind, WidgetKindProps } from './widget-kind';

package/dist/src/domains/dashboards/kinds/index.d.ts

@@ -0,0 +1,7 @@
+import type { AnyWidgetKind } from '../widget-kind';
+export { tableKind } from './table';
+export { kpisKind } from './kpis';
+export { scoresKind } from './scores';
+export { timeseriesKind } from './timeseries';
+/** The kinds every dashboard can use; hosts add their own through `DashboardRenderer`'s `kinds`. */
+export declare const BUILT_IN_WIDGET_KINDS: AnyWidgetKind[];

package/dist/src/domains/dashboards/kinds/kpis/index.d.ts

@@ -0,0 +1,13 @@
+export { kpiFigures, kpisOptionsSchema } from './options';
+export type { KpiFigures, KpisOptions } from './options';
+/** A row of headline numbers, each against the previous window. */
+export declare const kpisKind: import("../..").WidgetKind<{
+    items: {
+        label: string;
+        icon: "bot" | "coins" | "hash" | "threads";
+        format: "count" | "usd";
+        value: import("../../lib/values").ValueExpr;
+        detail: string;
+        lowerIsBetter?: boolean | undefined;
+    }[];
+}>;

package/dist/src/domains/dashboards/kinds/kpis/kpis-widget.d.ts

@@ -0,0 +1,3 @@
+import type { WidgetKindProps } from '../../widget-kind';
+import type { KpisOptions } from './options';
+export declare function KpisWidget({ views }: WidgetKindProps<KpisOptions>): import("react").JSX.Element;

package/dist/src/domains/dashboards/kinds/kpis/options.d.ts

@@ -0,0 +1,35 @@
+import { z } from 'zod/v4';
+import type { AggregateValue } from '../../lib/answers';
+import type { ValueExpr } from '../../lib/values';
+import type { ResolvedView } from '../../widget-kind';
+export declare const kpisOptionsSchema: z.ZodObject<{
+    items: z.ZodArray<z.ZodObject<{
+        label: z.ZodString;
+        icon: z.ZodEnum<{
+            bot: "bot";
+            coins: "coins";
+            hash: "hash";
+            threads: "threads";
+        }>;
+        format: z.ZodEnum<{
+            count: "count";
+            usd: "usd";
+        }>;
+        value: z.ZodType<ValueExpr, unknown, z.core.$ZodTypeInternals<ValueExpr, unknown>>;
+        detail: z.ZodString;
+        lowerIsBetter: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type KpisOptions = z.infer<typeof kpisOptionsSchema>;
+export type KpiFigures = {
+    value?: number;
+    previous?: number;
+    change?: number;
+};
+/**
+ * A KPI's figures. A single aggregate keeps the API's own change; a sum adds the parts and works
+ * out the change from the summed previous value, as the Tokens KPI does.
+ */
+export declare function kpiFigures(expr: ValueExpr, responses: ReadonlyMap<string, AggregateValue | undefined>): KpiFigures;
+/** What the schema can't say: query ids the view has, and only metrics or scores aggregates (scores naming a scorer), or sums of them. */
+export declare const kpisIssues: (view: ResolvedView<KpisOptions>) => string[];

package/dist/src/domains/dashboards/kinds/scores/index.d.ts

@@ -0,0 +1,8 @@
+export { scoresOptionsSchema } from './options';
+export type { ScoresOptions } from './options';
+/** One line per scorer, 0 to 1, with each scorer's mean in the legend. */
+export declare const scoresKind: import("../..").WidgetKind<{
+    average: string;
+    series: string;
+    emptyMessage?: string | undefined;
+}>;

package/dist/src/domains/dashboards/kinds/scores/options.d.ts

@@ -0,0 +1,13 @@
+import { z } from 'zod/v4';
+import type { ResolvedView } from '../../widget-kind';
+export declare const scoresOptionsSchema: z.ZodObject<{
+    average: z.ZodString;
+    series: z.ZodString;
+    emptyMessage: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type ScoresOptions = z.infer<typeof scoresOptionsSchema>;
+/**
+ * Both ids must name scores queries of the right request, and when both name a scorer it must be the
+ * same one, since each scorer's mean and line are drawn together.
+ */
+export declare const scoresIssues: (view: ResolvedView<ScoresOptions>) => string[];

package/dist/src/domains/dashboards/kinds/scores/scores-widget.d.ts

@@ -0,0 +1,3 @@
+import type { WidgetKindProps } from '../../widget-kind';
+import type { ScoresOptions } from './options';
+export declare function ScoresWidget({ widget, views }: WidgetKindProps<ScoresOptions>): import("react").JSX.Element;

package/dist/src/domains/dashboards/kinds/table/index.d.ts

@@ -0,0 +1,23 @@
+export { tableColumnOptionsSchema, tableOptionsSchema } from '../../lib/table';
+export type { TableColumnOptions, TableOptions } from '../../lib/table';
+/** Groups joined across the view's queries as a sortable table, with change against the previous window. */
+export declare const tableKind: import("../..").WidgetKind<{
+    groupBy: string[];
+    defaultSort: {
+        column: string;
+        direction: "asc" | "desc";
+    };
+    pageSize?: number | undefined;
+    emptyMessage: string;
+    ariaLabel?: string | undefined;
+    hideUnnamed?: boolean | undefined;
+    dropped?: boolean | undefined;
+    openWhen?: {
+        minRows: number;
+    } | undefined;
+    rowDrilldown?: {
+        fields: Record<string, "entityName" | "environment" | "model" | "projectId" | "provider" | "resourceId" | "sessionId" | "threadId" | "userId">;
+        spanTypes?: string[] | undefined;
+        keepEmpty?: boolean | undefined;
+    } | undefined;
+}>;

package/dist/src/domains/dashboards/kinds/table/table-cells.d.ts

@@ -0,0 +1,26 @@
+import type { Change, TableColumnOptions, TableRow, ValueColumn } from '../../lib/table';
+type NameOptions = Extract<TableColumnOptions, {
+    type: 'name';
+}>;
+type DimensionOptions = Extract<TableColumnOptions, {
+    type: 'dimension';
+}>;
+/** The row's mark and name; with a provider mark, a model reads `openai › gpt-5-mini`. */
+export declare function TableNameCell({ options, row }: {
+    options: NameOptions;
+    row: TableRow;
+}): import("react").JSX.Element;
+export declare function TableDimensionCell({ id, options, row }: {
+    id: string;
+    options: DimensionOptions;
+    row: TableRow;
+}): import("react").JSX.Element;
+export declare function TableValueCell({ column, row }: {
+    column: ValueColumn;
+    row: TableRow;
+}): import("react").JSX.Element;
+export declare function TableChangeCell({ change, column }: {
+    change: Change | undefined;
+    column: ValueColumn;
+}): import("react").JSX.Element;
+export {};

package/dist/src/domains/dashboards/kinds/table/table-columns.d.ts

@@ -0,0 +1,7 @@
+import type { Change, TableColumn, TableRow, ValueColumn } from '../../lib/table';
+import type { MetricsTableColumn } from '../../../../ds/components/MetricsTable';
+/** The MetricsTable column for one of the view's columns. */
+export declare function tableColumn(column: TableColumn, window: {
+    start: Date;
+    end: Date;
+}, compared: ValueColumn | undefined, changeOf: (row: TableRow) => Change | undefined): MetricsTableColumn<TableRow>;

package/dist/src/domains/dashboards/kinds/table/table-frame.d.ts

@@ -0,0 +1,13 @@
+import type { ReactNode } from 'react';
+import type { ViewHeading } from '../../lib/chrome';
+import type { TableOptions } from '../../lib/table';
+import type { ResolvedView, WidgetKindProps } from '../../widget-kind';
+export type TableTabProps = WidgetKindProps<TableOptions> & {
+    view: ResolvedView<TableOptions>;
+    heading: ViewHeading;
+};
+/** The table's card: the open view's title, as a menu of every view when there are several. */
+export declare function TableFrame({ heading, isUpdating, children, }: Pick<TableTabProps, 'heading'> & {
+    isUpdating?: boolean;
+    children: ReactNode;
+}): import("react").JSX.Element;

package/dist/src/domains/dashboards/kinds/table/table-tabs.d.ts

@@ -0,0 +1,10 @@
+import type { BlockedFields } from '../../components/view-gate';
+import type { DashboardPageContext } from '../../lib/requests';
+import type { TableOptions } from '../../lib/table';
+import type { WidgetKindProps } from '../../widget-kind';
+type Props = WidgetKindProps<TableOptions>;
+export declare function TableTabs({ page, blocked, ...props }: Props & {
+    page: DashboardPageContext;
+    blocked: BlockedFields;
+}): import("react").JSX.Element;
+export {};

package/dist/src/domains/dashboards/kinds/table/table-view.d.ts

@@ -0,0 +1,5 @@
+import type { DashboardPageContext } from '../../lib/requests';
+import type { TableTabProps } from './table-frame';
+export declare function TableView(props: TableTabProps & {
+    page: DashboardPageContext;
+}): import("react").JSX.Element;

package/dist/src/domains/dashboards/kinds/table/table-widget.d.ts

@@ -0,0 +1,7 @@
+import type { TableOptions } from '../../lib/table';
+import type { WidgetKindProps } from '../../widget-kind';
+/**
+ * Groups as a sortable table, one view per tab. It waits on the aggregate gates every tab needs, so tabs
+ * don't come and go; a tab whose gate can't apply the page's filters says so.
+ */
+export declare function TableWidget(props: WidgetKindProps<TableOptions>): import("react").JSX.Element;

package/dist/src/domains/dashboards/kinds/timeseries/index.d.ts

@@ -0,0 +1,30 @@
+/** Values per time bucket as stacked bars or lines, from metrics, trace or span time series. */
+export declare const timeseriesKind: import("../..").WidgetKind<{
+    chart: "line" | "stackedBar";
+    format: "count" | "duration" | "percent" | "score" | "usd";
+    axis?: boolean | undefined;
+    series: {
+        dataKey: string;
+        label: string;
+        color: "error" | "green" | "indigo" | "neutral" | "sky" | "teal" | "violet" | "warning";
+        emphasis?: boolean | undefined;
+        value: import("../../lib/values").ValueExpr;
+        rangeTotal?: import("../../lib/values").ValueExpr | undefined;
+        round?: boolean | undefined;
+    }[];
+    buckets?: "api" | "chart" | undefined;
+    totals?: string[] | undefined;
+    hideEmpty?: boolean | undefined;
+    emphasizeFirst?: boolean | undefined;
+    xLabels?: "edges" | undefined;
+    flatYDomain?: [number, number] | undefined;
+    yDomain?: [number, number] | undefined;
+    total?: {
+        value: "total" | {
+            peak: string;
+        } | import("../../lib/values").ValueExpr;
+        format?: "count" | "duration" | "percent" | "score" | "usd" | undefined;
+    } | undefined;
+    emptyMessage?: string | undefined;
+    emptyWhenZero?: import("../../lib/values").ValueExpr | undefined;
+}>;

package/dist/src/domains/dashboards/kinds/timeseries/timeseries-widget.d.ts

@@ -0,0 +1,5 @@
+import type { TimeseriesOptions } from '../../lib/timeseries';
+import type { WidgetKindProps } from '../../widget-kind';
+type Props = WidgetKindProps<TimeseriesOptions>;
+export declare function TimeseriesWidget(props: Props): import("react").JSX.Element;
+export {};

package/dist/src/domains/dashboards/lib/answers.d.ts

@@ -0,0 +1,43 @@
+import type { TraceAggregateRow } from '../../metrics/lib/trace-aggregate';
+import type { DashboardAnswer } from './requests';
+/** A point in a metrics or scores series. */
+export type SeriesPoint = {
+    timestamp: string | Date;
+    value: number;
+    estimatedCost?: number | null;
+};
+/** A series of a time series or percentiles answer: `name` is its group, `percentile` the one it plots. */
+export type AnswerSeries = {
+    name?: string;
+    percentile?: number;
+    points: SeriesPoint[];
+};
+/** A metrics or scores aggregate: its value and, when compared, the previous window's. */
+export type AggregateValue = {
+    value?: number | null;
+    previousValue?: number | null;
+    changePercent?: number | null;
+    estimatedCost?: number | null;
+    previousEstimatedCost?: number | null;
+    costChangePercent?: number | null;
+};
+/** A breakdown group of a metrics or scores breakdown. */
+export type AnswerGroup = {
+    dimensions: Record<string, string | null>;
+    value: number;
+    estimatedCost?: number | null;
+    costUnit?: string | null;
+};
+/** The rows of a trace or span aggregate, else `undefined`. */
+export declare function rowsOf(answer: DashboardAnswer | undefined): {
+    rows: TraceAggregateRow[];
+    truncated?: boolean;
+} | undefined;
+/** The series of a metrics or scores time series or percentiles answer, else `undefined`. */
+export declare function seriesOf(answer: DashboardAnswer | undefined): AnswerSeries[] | undefined;
+/** A metrics or scores aggregate's figures, else `undefined`. */
+export declare function valueOf(answer: DashboardAnswer | undefined): AggregateValue | undefined;
+/** The groups of a metrics or scores breakdown, else `undefined`. */
+export declare function groupsOf(answer: DashboardAnswer | undefined): AnswerGroup[] | undefined;
+/** A measure of an aggregate row by name; `undefined` when the row doesn't have it. */
+export declare function measureOf(measures: Readonly<Record<string, unknown>>, name: string): number | undefined;