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

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

@@ -0,0 +1,14 @@
+import type { DashboardWidget, DashboardWidgetView } from '@mastra/client-js';
+import type { ChartCardProps } from '../../metrics/components/chart-card';
+/** What a widget's card shows as its title: `title`, and `titleMenu` with several views. */
+export type ViewHeading = Pick<ChartCardProps, 'title' | 'titleMenu'>;
+export declare const unsupportedMessage: (fields: string[], names?: Record<string, string>) => string;
+/** A view's value in the card's menu: its label in kebab case (`Token usage` → `token-usage`), or its position when unlabelled or blank. */
+export declare const viewValue: (label: string | undefined, index: number) => string;
+/** A view's visible name: its label, or `View n` when unlabelled or blank, so every option has an accessible name. */
+export declare const viewLabel: (label: string | undefined, index: number) => string;
+/**
+ * The card title for the open view: the widget's title for a single view; with several, the open
+ * view's label, as a menu of every view (as the metrics cards switch views).
+ */
+export declare function viewTitle(widget: DashboardWidget, views: readonly DashboardWidgetView[], index: number, onChoose: (index: number) => void): ViewHeading;

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

@@ -0,0 +1,27 @@
+import type { DashboardDefinition, DashboardDrilldown, DashboardDrilldownTarget, DashboardWidget, DashboardWidgetView } from '@mastra/client-js';
+import type { DrilldownScope } from '../../metrics/drilldown';
+import type { DatePreset } from '../../metrics/hooks/use-metrics';
+import type { PropertyFilterToken } from '../../../ds/components/PropertyFilter/types';
+export type DashboardScope = 'org' | 'project';
+/** Whether a widget, view or column tagged with `scope` shows at the page's scope. */
+export declare const inScope: (item: {
+    scope?: DashboardScope;
+}, scope: DashboardScope) => boolean;
+export type DashboardDrilldownPage = DashboardDrilldownTarget['page'];
+/** Where a widget's button or a click leads; the page turns it into a URL. */
+export type OnDashboardDrilldown = (page: DashboardDrilldownPage, scope: DrilldownScope) => void;
+/** The view's drilldown over the widget's, target by target. */
+export declare function viewDrilldown(widget: DashboardWidget, view: DashboardWidgetView): DashboardDrilldown;
+/**
+ * A target's filter chips as a drilldown scope. Only single-value chips on scope fields carry over;
+ * nested groups have no scope equivalent.
+ */
+export declare function targetScope(target: DashboardDrilldownTarget): DrilldownScope;
+/**
+ * The range and filters a page applies when its URL sets neither. The Metrics filter bar holds
+ * chips, so only top-level chips carry over.
+ */
+export declare function dashboardDefaults(definition: Pick<DashboardDefinition, 'defaults'>): {
+    preset?: DatePreset;
+    filterTokens: PropertyFilterToken[];
+};

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

@@ -0,0 +1,6 @@
+/**
+ * ANDs the page's metrics or scores filters with a widget's: a field set on one side is kept; set on
+ * both, lists of alternatives intersect (`tags`, which must all match, combine), per-key maps merge, and
+ * single values must be equal. `undefined` when the two contradict, so nothing can match.
+ */
+export declare function intersectFilters<F extends object>(page: F | undefined, widget: Partial<F> | undefined): Partial<F> | undefined;

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

@@ -0,0 +1,7 @@
+import type { CHART_COLOR_NAMES, ValueFormat } from './values';
+/** The formatters a format names: one for values and tooltips, a compact one for the y-axis. */
+export declare const FORMATTERS: Record<ValueFormat, {
+    value: (n: number) => string;
+    axis?: (n: number) => string;
+}>;
+export declare const chartColor: (name: (typeof CHART_COLOR_NAMES)[number]) => "var(--chart-amber)" | "var(--chart-red)" | "var(--chart-share-1)" | "var(--chart-share-2)" | "var(--chart-share-3)" | "var(--chart-share-4)" | "var(--chart-share-5)" | "var(--muted-foreground)";

package/dist/src/domains/dashboards/lib/prepare-widget.d.ts

@@ -0,0 +1,26 @@
+import type { DashboardDefinitionEnvelope, DashboardWidget } from '@mastra/client-js';
+import type { AnyWidgetKind, ResolvedView } from '../widget-kind';
+import type { DashboardScope } from './definition';
+type Issue = {
+    path: PropertyKey[];
+    message: string;
+};
+export declare const describeIssue: (issue: Issue | undefined) => string;
+/** A widget as storage accepts it: only `id`, `kind` and `views` are known before it's parsed. */
+export type StoredWidget = DashboardDefinitionEnvelope['rows'][number]['widgets'][number];
+export type PreparedWidget = {
+    ok: true;
+    kind: AnyWidgetKind;
+    widget: DashboardWidget;
+    views: [ResolvedView<unknown>, ...ResolvedView<unknown>[]];
+} | {
+    ok: false;
+    message: string;
+}
+/** Nothing at the page's scope. */
+ | {
+    ok: 'hidden';
+};
+/** Checks one widget against core's schema and its kind's options, keeping the views and columns at `scope`. */
+export declare function prepareWidget(stored: StoredWidget, registry: ReadonlyMap<string, AnyWidgetKind>, scope: DashboardScope): PreparedWidget;
+export {};

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

@@ -0,0 +1,95 @@
+import type { AggregateSpansArgs, AggregateTracesArgs, DashboardQuery, MastraClient } from '@mastra/client-js';
+import type { MetricsQueryFilters } from '@mastra/react/hooks/metrics';
+import type { AggregatePriority } from '../../metrics/lib/request-limiter';
+type Window = {
+    start: Date;
+    end: Date;
+};
+type Interval = '1h' | '1d';
+type Args<M extends keyof MastraClient> = MastraClient[M] extends (args: infer A, ...rest: never[]) => unknown ? A : never;
+type Call = {
+    method: 'aggregateTraces';
+    args: AggregateTracesArgs;
+    priority?: AggregatePriority;
+} | {
+    method: 'aggregateSpans';
+    args: AggregateSpansArgs;
+    priority?: AggregatePriority;
+} | {
+    method: 'getMetricAggregate';
+    args: Args<'getMetricAggregate'>;
+} | {
+    method: 'getMetricBreakdown';
+    args: Args<'getMetricBreakdown'>;
+} | {
+    method: 'getMetricTimeSeries';
+    args: Args<'getMetricTimeSeries'>;
+} | {
+    method: 'getMetricPercentiles';
+    args: Args<'getMetricPercentiles'>;
+} | {
+    method: 'getScoreAggregate';
+    args: Args<'getScoreAggregate'>;
+} | {
+    method: 'getScoreBreakdown';
+    args: Args<'getScoreBreakdown'>;
+} | {
+    method: 'getScoreTimeSeries';
+    args: Args<'getScoreTimeSeries'>;
+} | {
+    method: 'getScorePercentiles';
+    args: Args<'getScorePercentiles'>;
+};
+/** One call a dashboard query makes, with the args it sends. */
+export type DashboardRequest = Call & {
+    /** Its filters contradict the page's, so nothing can match: it isn't sent and answers empty. */
+    unsatisfiable?: true;
+};
+export type DashboardRequestMethod = DashboardRequest['method'];
+type Answers = {
+    [M in DashboardRequestMethod]: Awaited<ReturnType<MastraClient[M]>>;
+};
+/** A request's answer, tagged with the method that produced it so a widget narrows it by `method`. */
+export type DashboardAnswer = {
+    [M in DashboardRequestMethod]: {
+        method: M;
+        data: Answers[M];
+    };
+}[DashboardRequestMethod];
+type TraceWhere = NonNullable<AggregateTracesArgs['where']>;
+type SpanWhere = NonNullable<AggregateSpansArgs['where']>;
+/** What the page adds to every widget's query: its frozen window and its filter bar. */
+export type DashboardPageContext = {
+    window: Window;
+    /** The page's metrics and scores filters, `timestamp` included. */
+    filters: MetricsQueryFilters['filters'];
+    /** The filter bar as trace and span predicates, from the aggregate gates. */
+    traceWhere?: TraceWhere;
+    spanWhere?: SpanWhere;
+};
+/** How the widget kind sends a query. */
+export type DashboardRequestOptions = {
+    /** The bucket size, for a query that doesn't set its own. Unset sends the query as written. */
+    interval?: Interval;
+};
+/**
+ * The request a query sends over `window`, the page's filters ANDed with the widget's: trace and span
+ * predicates are joined with `and`; metrics and scores filters intersect (`intersectFilters`), and a
+ * contradiction marks the request unsatisfiable. A scores query without a scorer sends nothing: the
+ * `scores` kind expands it per scorer first.
+ */
+export declare function buildRequest(query: DashboardQuery, page: DashboardPageContext, { interval }: DashboardRequestOptions, window?: Window, priority?: AggregatePriority): DashboardRequest | undefined;
+/** Whether a query asks for the previous window as a request of its own. */
+export declare function sendsPreviousRequest(query: DashboardQuery): boolean;
+/** The previous window's request, sent last so the widget never waits on it. */
+export declare function buildPreviousRequest(query: DashboardQuery, page: DashboardPageContext, options: DashboardRequestOptions): DashboardRequest | undefined;
+/** Runs a request on the client; an unsatisfiable one answers empty without a call. */
+export declare function sendRequest(client: MastraClient, request: DashboardRequest): Promise<DashboardAnswer>;
+/**
+ * The React Query key. Answers are cached tagged with their method, so they live under the dashboards'
+ * own keys rather than `useTraceAggregate`'s, whose entries hold the bare response.
+ */
+export declare function requestKey(request: DashboardRequest): readonly unknown[];
+/** Whether a query needs the trace or span aggregate gate. */
+export declare const aggregateSource: (query: DashboardQuery) => "span" | "trace" | undefined;
+export {};

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

@@ -0,0 +1,35 @@
+import type { DashboardQuery } from '@mastra/client-js';
+import type { BucketLabels } from '../../metrics/lib/bucket-labels';
+import type { DashboardAnswer } from './requests';
+export type Scorer = {
+    scorerId: string;
+    name: string;
+};
+export type ScoresBucket = BucketLabels & Record<string, number | string | undefined>;
+/** Whether the query leaves its scorer out, so the widget has to find the scorers itself. */
+export declare const needsScorer: (query: DashboardQuery | undefined) => boolean;
+/** The scorer the view's queries name themselves, when none of them leaves it out. */
+export declare function ownScorers(queries: DashboardQuery[]): Scorer[];
+/** Every scorer among the recent scores, sorted by id, named as the scores name them. */
+export declare function discoveredScorers(scores: {
+    scorerId: string;
+    scorerName?: string;
+}[]): Scorer[];
+/** The query for one scorer: its own scorer if it names one, else `scorerId`. */
+export declare const withScorer: (query: DashboardQuery | undefined, scorerId: string) => DashboardQuery | undefined;
+/**
+ * Lays each scorer's points on the window's bucket grid, keyed by scorer id, and reads each scorer's
+ * mean (0 when the aggregate has no value, as the Scores card shows it). `means` and `points` hold
+ * one answer per scorer, in `scorers`' order.
+ */
+export declare function shapeScores(scorers: Scorer[], means: (DashboardAnswer | undefined)[], points: (DashboardAnswer | undefined)[], window: {
+    start: Date;
+    end: Date;
+}, stepHours: number): {
+    buckets: ScoresBucket[];
+    lines: {
+        scorerId: string;
+        name: string;
+        mean: number;
+    }[];
+};

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

@@ -0,0 +1,188 @@
+import type { DashboardColumn, DashboardQuery } from '@mastra/client-js';
+import { z } from 'zod/v4';
+import type { DrilldownScope } from '../../metrics/drilldown';
+import type { DashboardAnswer } from './requests';
+export declare const TABLE_VALUE_FORMATS: readonly ['count', 'usd', 'duration', 'percent'];
+export declare const tableColumnOptionsSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    description: z.ZodOptional<z.ZodString>;
+    width: z.ZodOptional<z.ZodString>;
+    sortable: z.ZodOptional<z.ZodBoolean>;
+    type: z.ZodLiteral<"name">;
+    as: z.ZodOptional<z.ZodLiteral<"project">>;
+    unnamed: z.ZodOptional<z.ZodString>;
+    mark: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+        icon: z.ZodEnum<{
+            agent: "agent";
+            tool: "tool";
+            workflow: "workflow";
+        }>;
+    }, z.core.$strict>, z.ZodObject<{
+        providerDimension: z.ZodString;
+    }, z.core.$strict>]>>;
+}, z.core.$strict>, z.ZodObject<{
+    description: z.ZodOptional<z.ZodString>;
+    width: z.ZodOptional<z.ZodString>;
+    sortable: z.ZodOptional<z.ZodBoolean>;
+    type: z.ZodLiteral<"dimension">;
+    dimension: z.ZodString;
+    as: z.ZodOptional<z.ZodLiteral<"project">>;
+    query: z.ZodOptional<z.ZodString>;
+    joinOn: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    description: z.ZodOptional<z.ZodString>;
+    width: z.ZodOptional<z.ZodString>;
+    sortable: z.ZodOptional<z.ZodBoolean>;
+    type: z.ZodLiteral<"value">;
+    value: z.ZodType<import("./values").ValueExpr, unknown, z.core.$ZodTypeInternals<import("./values").ValueExpr, unknown>>;
+    format: z.ZodEnum<{
+        count: "count";
+        duration: "duration";
+        percent: "percent";
+        usd: "usd";
+    }>;
+    emphasis: z.ZodOptional<z.ZodBoolean>;
+    missing: z.ZodOptional<z.ZodNumber>;
+    additive: z.ZodOptional<z.ZodBoolean>;
+    better: z.ZodOptional<z.ZodEnum<{
+        higher: "higher";
+        lower: "lower";
+    }>>;
+    unpricedWhen: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"change">;
+    description: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>], "type">;
+export type TableColumnOptions = z.infer<typeof tableColumnOptionsSchema>;
+type ColumnOf<O extends TableColumnOptions> = {
+    id: string;
+    label: string;
+    options: O;
+};
+/** A column, told apart by `options.type`. */
+export type TableColumn = {
+    [T in TableColumnOptions['type']]: ColumnOf<Extract<TableColumnOptions, {
+        type: T;
+    }>>;
+}[TableColumnOptions['type']];
+export type ValueColumn = Extract<TableColumn, {
+    options: {
+        type: 'value';
+    };
+}>;
+export declare const DRILLDOWN_FIELDS: readonly ['projectId', 'entityName', 'threadId', 'resourceId', 'environment', 'sessionId', 'userId', 'model', 'provider'];
+export declare const tableOptionsSchema: z.ZodObject<{
+    groupBy: z.ZodArray<z.ZodString>;
+    defaultSort: z.ZodObject<{
+        column: z.ZodString;
+        direction: z.ZodEnum<{
+            asc: "asc";
+            desc: "desc";
+        }>;
+    }, z.core.$strict>;
+    pageSize: z.ZodOptional<z.ZodNumber>;
+    emptyMessage: z.ZodString;
+    ariaLabel: z.ZodOptional<z.ZodString>;
+    hideUnnamed: z.ZodOptional<z.ZodBoolean>;
+    dropped: z.ZodOptional<z.ZodBoolean>;
+    openWhen: z.ZodOptional<z.ZodObject<{
+        minRows: z.ZodNumber;
+    }, z.core.$strict>>;
+    rowDrilldown: z.ZodOptional<z.ZodObject<{
+        fields: z.ZodRecord<z.ZodString, z.ZodEnum<{
+            entityName: "entityName";
+            environment: "environment";
+            model: "model";
+            projectId: "projectId";
+            provider: "provider";
+            resourceId: "resourceId";
+            sessionId: "sessionId";
+            threadId: "threadId";
+            userId: "userId";
+        }>>;
+        spanTypes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        keepEmpty: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type TableOptions = z.infer<typeof tableOptionsSchema>;
+/** The view's columns with their options parsed; `issues` reports what doesn't parse. */
+export declare function parseColumns(columns: readonly DashboardColumn[] | undefined): {
+    columns: TableColumn[];
+    issues: string[];
+};
+export declare const isValueColumn: (column: TableColumn) => column is ValueColumn;
+/** What the schema can't say: columns that name each other and queries the view has. */
+export declare function tableIssues(columns: readonly DashboardColumn[] | undefined, options: TableOptions, queries: readonly DashboardQuery[]): string[];
+export type TableRow = {
+    key: string;
+    /** The row's `groupBy` values. */
+    dimensions: Record<string, string>;
+    /** The last `groupBy` value; `''` when the group has none. */
+    name: string;
+    /** Per value column. */
+    values: Record<string, number | undefined>;
+    /** Per `usd` column, when the answer names a currency. */
+    units: Record<string, string | undefined>;
+    /** Per lookup column. */
+    lookups: Record<string, string | undefined>;
+};
+type Answers = ReadonlyMap<string, DashboardAnswer | undefined>;
+/** The queries rows come from, in the view's order: those a value column reads. */
+export declare function rowQueries(columns: TableColumn[], queries: readonly DashboardQuery[]): string[];
+/**
+ * The rows: one per group in any query a value column reads, created in the view's query order, then
+ * each column's value read from the row's entries. A lookup column fills in by its `joinOn` dimension.
+ */
+export declare function buildTableRows(options: TableOptions, columns: TableColumn[], queries: readonly DashboardQuery[], answers: Answers): TableRow[];
+export type PreviousValues = Map<string, Record<string, number | undefined>>;
+/** The previous window's values per row key, read the same way. */
+export declare function previousTableValues(options: TableOptions, columns: TableColumn[], queries: readonly DashboardQuery[], answers: Answers): PreviousValues;
+/**
+ * The rows to list: unnamed ones left out when asked, and, when the list is whole, a row at zero for
+ * each group a total was above 0 for in the previous window but that has no row now.
+ */
+export declare function listedRows(options: TableOptions, columns: TableColumn[], built: TableRow[], previous: PreviousValues | undefined, truncated: boolean): TableRow[];
+export type TableContent = {
+    rows: TableRow[];
+    /** The previous window's values by row key, once they're passed in. */
+    before: PreviousValues | undefined;
+    truncated: boolean;
+    /** The cap the first truncated aggregate hit, when it names one. */
+    limit: number | undefined;
+};
+/**
+ * What the table lists once its row queries answer. `current` and `previous` hold one answer per
+ * query, in the view's order; leave `previous` out until the previous window has settled.
+ */
+export declare function tableContent(options: TableOptions, columns: TableColumn[], queries: readonly DashboardQuery[], current: readonly (DashboardAnswer | undefined)[], previous: readonly (DashboardAnswer | undefined)[] | undefined): TableContent;
+/**
+ * Groups whose value in `column` is above zero, once the requests of every query it reads answer.
+ * `answers` holds one answer per query, in order.
+ */
+export declare function countRows(options: TableOptions, column: ValueColumn, queries: readonly DashboardQuery[], answers: readonly (DashboardAnswer | undefined)[]): OpenerRows;
+export type Change = {
+    /** Now minus before; unset when there's nothing to compare. */
+    delta?: number;
+    /** Relative change (0.5 = +50%); for a percent, the difference itself (0.02 = +2 points). */
+    change?: number;
+    isNew: boolean;
+};
+/** How a row's value in `column` moved against the previous window. */
+export declare function valueChange(column: ValueColumn, now: number | undefined, before: number | undefined): Change;
+export declare function changeTrend(change: Change, column: ValueColumn): 'good' | 'bad' | undefined;
+export declare const DASH = "\u2014";
+export declare function formatChange(change: Change, column: ValueColumn): string;
+/** A value in its column's format; dollars unless the answer names another currency. */
+export declare function formatValue(column: ValueColumn, value: number, unit: string | undefined): string;
+/** What a row click adds: its dimensions as drilldown fields; an entity name as a span filter when asked. */
+export declare function rowDrilldown(options: TableOptions, row: TableRow): DrilldownScope;
+/** The opener view's row count: still loading, not countable (a page filter blocks it, or its sort column reads no query), or counted. */
+export type OpenerRows = number | 'loading' | 'uncountable';
+/**
+ * The view a table opens on. Without an `openWhen` view, the first. The `openWhen` view opens while
+ * its rows load, so the tabs don't jump, and once it has `minRows` of them; it's passed over when it
+ * can't count them or has too few.
+ */
+export declare function openingView(views: readonly {
+    options: TableOptions;
+}[], rows: OpenerRows): number;
+export {};

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

@@ -0,0 +1,119 @@
+import type { DashboardQuery } from '@mastra/client-js';
+import { z } from 'zod/v4';
+import type { BucketLabels } from '../../metrics/lib/bucket-labels';
+import type { DashboardAnswer } from './requests';
+import type { ValueExpr } from './values';
+export declare const timeseriesSeriesSchema: z.ZodObject<{
+    dataKey: z.ZodString;
+    label: z.ZodString;
+    color: z.ZodEnum<{
+        error: "error";
+        green: "green";
+        indigo: "indigo";
+        neutral: "neutral";
+        sky: "sky";
+        teal: "teal";
+        violet: "violet";
+        warning: "warning";
+    }>;
+    emphasis: z.ZodOptional<z.ZodBoolean>;
+    value: z.ZodType<ValueExpr, unknown, z.core.$ZodTypeInternals<ValueExpr, unknown>>;
+    rangeTotal: z.ZodOptional<z.ZodType<ValueExpr, unknown, z.core.$ZodTypeInternals<ValueExpr, unknown>>>;
+    round: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strict>;
+export declare const timeseriesOptionsSchema: z.ZodObject<{
+    chart: z.ZodEnum<{
+        line: "line";
+        stackedBar: "stackedBar";
+    }>;
+    format: z.ZodEnum<{
+        count: "count";
+        duration: "duration";
+        percent: "percent";
+        score: "score";
+        usd: "usd";
+    }>;
+    axis: z.ZodOptional<z.ZodBoolean>;
+    series: z.ZodArray<z.ZodObject<{
+        dataKey: z.ZodString;
+        label: z.ZodString;
+        color: z.ZodEnum<{
+            error: "error";
+            green: "green";
+            indigo: "indigo";
+            neutral: "neutral";
+            sky: "sky";
+            teal: "teal";
+            violet: "violet";
+            warning: "warning";
+        }>;
+        emphasis: z.ZodOptional<z.ZodBoolean>;
+        value: z.ZodType<ValueExpr, unknown, z.core.$ZodTypeInternals<ValueExpr, unknown>>;
+        rangeTotal: z.ZodOptional<z.ZodType<ValueExpr, unknown, z.core.$ZodTypeInternals<ValueExpr, unknown>>>;
+        round: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strict>>;
+    buckets: z.ZodOptional<z.ZodEnum<{
+        api: "api";
+        chart: "chart";
+    }>>;
+    totals: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    hideEmpty: z.ZodOptional<z.ZodBoolean>;
+    emphasizeFirst: z.ZodOptional<z.ZodBoolean>;
+    xLabels: z.ZodOptional<z.ZodLiteral<"edges">>;
+    flatYDomain: z.ZodOptional<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
+    yDomain: z.ZodOptional<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
+    total: z.ZodOptional<z.ZodObject<{
+        value: z.ZodUnion<readonly [z.ZodLiteral<"total">, z.ZodObject<{
+            peak: z.ZodString;
+        }, z.core.$strict>, z.ZodType<ValueExpr, unknown, z.core.$ZodTypeInternals<ValueExpr, unknown>>]>;
+        format: z.ZodOptional<z.ZodEnum<{
+            count: "count";
+            duration: "duration";
+            percent: "percent";
+            score: "score";
+            usd: "usd";
+        }>>;
+    }, z.core.$strict>>;
+    emptyMessage: z.ZodOptional<z.ZodString>;
+    emptyWhenZero: z.ZodOptional<z.ZodType<ValueExpr, unknown, z.core.$ZodTypeInternals<ValueExpr, unknown>>>;
+}, z.core.$strict>;
+export type TimeseriesOptions = z.infer<typeof timeseriesOptionsSchema>;
+export type TimeseriesSeries = z.infer<typeof timeseriesSeriesSchema>;
+type Window = {
+    start: Date;
+    end: Date;
+};
+export type ChartBucket = BucketLabels & Record<string, number | string | undefined>;
+export type ShapedTimeseries = {
+    data: ChartBucket[];
+    /** The series shown, each with its range total when it has one. */
+    series: (Omit<TimeseriesSeries, 'rangeTotal'> & {
+        rangeTotal?: number;
+    })[];
+    /** Hours per bucket, for a clicked bucket's window. */
+    stepHours: number;
+    /** The card's total, from `options.total`. */
+    total?: number;
+    /** Every plotted value is zero (or missing). */
+    flat: boolean;
+    /** Nothing to show in the range. */
+    empty: boolean;
+};
+/**
+ * Lays a timeseries view's answers on the chart's bucket grid. `chart` buckets add every point that
+ * falls in a bucket (missing is 0); `api` buckets take the API's point (missing stays unset).
+ */
+export declare function shapeTimeseries({ options, responses, window, hasTraceQueries, }: {
+    options: TimeseriesOptions;
+    /** Each query's answer, by query id. */
+    responses: ReadonlyMap<string, DashboardAnswer | undefined>;
+    window: Window;
+    hasTraceQueries: boolean;
+}): ShapedTimeseries;
+/**
+ * What the schema can't say: query ids the view has, bucketed queries that leave their interval to the
+ * chart's grid, refs that pick one of the percentiles their query asks for, and refs that pick one group
+ * of a grouped aggregation that can't be added up.
+ */
+export declare function timeseriesIssues(options: TimeseriesOptions, queries: readonly DashboardQuery[]): string[];
+export {};

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

@@ -0,0 +1,86 @@
+import { z } from 'zod/v4';
+/**
+ * The options vocabulary widget kinds share. Values reference a view's query results and
+ * combine them with a few fixed operations; there are no free-form expressions.
+ */
+/** Names one of the view's queries by its `id`, never its position, so reordering queries keeps refs. */
+export declare const queryRefSchema: z.ZodString;
+/** A number read from one query's result. */
+export declare const valueRefSchema: z.ZodObject<{
+    query: z.ZodString;
+    field: z.ZodOptional<z.ZodEnum<{
+        estimatedCost: "estimatedCost";
+        value: "value";
+    }>>;
+    measure: z.ZodOptional<z.ZodString>;
+    percentile: z.ZodOptional<z.ZodNumber>;
+    groups: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    notGroups: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>;
+export type ValueRef = z.infer<typeof valueRefSchema>;
+export type ValueExpr = ValueRef | {
+    const: number;
+} | {
+    sum: ValueExpr[];
+}
+/** The first minus the second. */
+ | {
+    minus: [ValueExpr, ValueExpr];
+}
+/** `of / over`; no value when `over` is 0 or has none. */
+ | {
+    ratio: {
+        of: ValueExpr;
+        over: ValueExpr;
+    };
+}
+/** The largest part that has a value. */
+ | {
+    max: ValueExpr[];
+}
+/** The first part that has a value. */
+ | {
+    coalesce: ValueExpr[];
+};
+export declare const valueExprSchema: z.ZodType<ValueExpr>;
+export declare const VALUE_FORMATS: readonly ['count', 'usd', 'duration', 'percent', 'score'];
+export declare const formatSchema: z.ZodEnum<{
+    count: "count";
+    duration: "duration";
+    percent: "percent";
+    score: "score";
+    usd: "usd";
+}>;
+export type ValueFormat = z.infer<typeof formatSchema>;
+export declare const CHART_COLOR_NAMES: readonly ['green', 'sky', 'violet', 'teal', 'indigo', 'warning', 'error', 'neutral'];
+export declare const colorSchema: z.ZodEnum<{
+    error: "error";
+    green: "green";
+    indigo: "indigo";
+    neutral: "neutral";
+    sky: "sky";
+    teal: "teal";
+    violet: "violet";
+    warning: "warning";
+}>;
+/** Every ref an expression reads, in order. */
+export declare function exprRefs(expr: ValueExpr): ValueRef[];
+/**
+ * Evaluates an expression, reading each ref through `read`. A missing operand counts as 0 in `sum` and
+ * `minus` while another has a value; the result is missing when every operand is.
+ */
+export declare function evaluate(expr: ValueExpr, read: (ref: ValueRef) => number | undefined): number | undefined;
+/** Whether the series with group key `name` is one a ref reads. */
+export declare function matchesGroups(ref: ValueRef, name: string): boolean;
+/** Each query's answer under its id, for reading refs. Queries without an id can't be referenced. */
+export declare function answersById<T>(queries: readonly {
+    id?: string;
+}[], answers: readonly T[]): Map<string, T | undefined>;
+/** Where a query id sits in the view's queries, or `undefined` if no query has it. */
+export declare const queryIndex: (queries: readonly {
+    id?: string;
+}[], id: string | undefined) => number | undefined;
+/** An issue for each referenced query id the view doesn't have. */
+export declare function unknownQueryIssues(ids: readonly string[], queries: readonly {
+    id?: string;
+}[], where?: string): string[];

package/dist/src/domains/dashboards/metrics-dashboard.d.ts

@@ -0,0 +1,7 @@
+import type { DashboardDefinition } from '@mastra/client-js';
+/**
+ * The Metrics page as a dashboard: four charts in two rows (usage and health first), then the
+ * breakdown of who caused them. Org and project pages share it; scope-tagged parts pick per page.
+ * It is frozen: copy it (`structuredClone(METRICS_DASHBOARD)`) before customising.
+ */
+export declare const METRICS_DASHBOARD: DashboardDefinition;

package/dist/src/domains/dashboards/widget-kind.d.ts

@@ -0,0 +1,31 @@
+import type { DashboardWidget, DashboardWidgetView } from '@mastra/client-js';
+import type { ComponentType } from 'react';
+import type { z } from 'zod/v4';
+import type { DashboardScope, OnDashboardDrilldown } from './lib/definition';
+/** A view whose options passed its kind's schema. */
+export type ResolvedView<Options> = DashboardWidgetView & {
+    options: Options;
+};
+export type WidgetKindProps<Options> = {
+    widget: DashboardWidget;
+    /** The views at the page's scope, options parsed. Never empty. */
+    views: [ResolvedView<Options>, ...ResolvedView<Options>[]];
+    scope: DashboardScope;
+    onDrilldown?: OnDashboardDrilldown;
+};
+/**
+ * One kind of widget, self-contained: the renderer only looks it up by name, checks each view's
+ * options against `optionsSchema`, and renders `component`.
+ */
+export type WidgetKind<Options = unknown> = {
+    kind: string;
+    /** Each view's `options`, parsed before the widget renders. */
+    optionsSchema: z.ZodType<Options>;
+    /** Further problems with a view, e.g. options naming a query the view doesn't have. */
+    issues?: (view: ResolvedView<Options>) => string[];
+    component: ComponentType<WidgetKindProps<Options>>;
+};
+/** Keeps a kind's options type while it joins a list of kinds of different options. */
+export declare const defineWidgetKind: <Options>(kind: WidgetKind<Options>) => WidgetKind<Options>;
+/** A registry entry, whatever its options. */
+export type AnyWidgetKind = WidgetKind<any>;

package/dist/src/domains/logs/components/index.d.ts

@@ -3,3 +3,4 @@ export { LogsErrorContent, type LogsErrorContentProps } from './logs-error-conte
 export { LogsListView, type LogsListViewProps } from './logs-list-view';
 export { LogsToolbar, type LogsToolbarProps } from './logs-toolbar';
 export { NoLogsInfo, type NoLogsInfoProps } from './no-logs-info';
+export { LogsSavedViews, type LogsSavedViewsProps } from './logs-saved-views';