@mastra/playground-ui 10.0.0 → 11.0.0

package/dist/src/domains/datasets/hooks/use-dataset-items.d.ts

@@ -0,0 +1,225 @@
+/**
+ * Hook to fetch a single dataset item by ID
+ */
+export declare const useDatasetItem: (datasetId: string, itemId: string) => import('@tanstack/react-query').UseQueryResult<import('@mastra/client-js').DatasetItem, Error>;
+/**
+ * Hook to list items in a dataset with infinite scroll pagination and optional search
+ * @param version - Optional version timestamp to view historical snapshot
+ */
+export declare const useDatasetItems: (datasetId: string, search?: string, version?: number | null) => {
+    setEndOfListElement: (node: HTMLDivElement | null) => (() => void) | undefined;
+    data: import('@mastra/client-js').DatasetItem[];
+    error: Error;
+    isError: true;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: false;
+    isRefetchError: true;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "error";
+    fetchNextPage: (options?: import('@tanstack/react-query').FetchNextPageOptions) => Promise<import('@tanstack/react-query').InfiniteQueryObserverResult<import('@mastra/client-js').DatasetItem[], Error>>;
+    fetchPreviousPage: (options?: import('@tanstack/react-query').FetchPreviousPageOptions) => Promise<import('@tanstack/react-query').InfiniteQueryObserverResult<import('@mastra/client-js').DatasetItem[], Error>>;
+    hasNextPage: boolean;
+    hasPreviousPage: boolean;
+    isFetchNextPageError: boolean;
+    isFetchingNextPage: boolean;
+    isFetchPreviousPageError: boolean;
+    isFetchingPreviousPage: boolean;
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: import('@tanstack/react-query').RefetchOptions) => Promise<import('@tanstack/react-query').QueryObserverResult<import('@mastra/client-js').DatasetItem[], Error>>;
+    fetchStatus: import('@tanstack/react-query').FetchStatus;
+    promise: Promise<import('@mastra/client-js').DatasetItem[]>;
+} | {
+    setEndOfListElement: (node: HTMLDivElement | null) => (() => void) | undefined;
+    data: import('@mastra/client-js').DatasetItem[];
+    error: null;
+    isError: false;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: false;
+    isRefetchError: false;
+    isFetchNextPageError: false;
+    isFetchPreviousPageError: false;
+    isSuccess: true;
+    isPlaceholderData: false;
+    status: "success";
+    fetchNextPage: (options?: import('@tanstack/react-query').FetchNextPageOptions) => Promise<import('@tanstack/react-query').InfiniteQueryObserverResult<import('@mastra/client-js').DatasetItem[], Error>>;
+    fetchPreviousPage: (options?: import('@tanstack/react-query').FetchPreviousPageOptions) => Promise<import('@tanstack/react-query').InfiniteQueryObserverResult<import('@mastra/client-js').DatasetItem[], Error>>;
+    hasNextPage: boolean;
+    hasPreviousPage: boolean;
+    isFetchingNextPage: boolean;
+    isFetchingPreviousPage: boolean;
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: import('@tanstack/react-query').RefetchOptions) => Promise<import('@tanstack/react-query').QueryObserverResult<import('@mastra/client-js').DatasetItem[], Error>>;
+    fetchStatus: import('@tanstack/react-query').FetchStatus;
+    promise: Promise<import('@mastra/client-js').DatasetItem[]>;
+} | {
+    setEndOfListElement: (node: HTMLDivElement | null) => (() => void) | undefined;
+    data: undefined;
+    error: Error;
+    isError: true;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: true;
+    isRefetchError: false;
+    isFetchNextPageError: false;
+    isFetchPreviousPageError: false;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "error";
+    fetchNextPage: (options?: import('@tanstack/react-query').FetchNextPageOptions) => Promise<import('@tanstack/react-query').InfiniteQueryObserverResult<import('@mastra/client-js').DatasetItem[], Error>>;
+    fetchPreviousPage: (options?: import('@tanstack/react-query').FetchPreviousPageOptions) => Promise<import('@tanstack/react-query').InfiniteQueryObserverResult<import('@mastra/client-js').DatasetItem[], Error>>;
+    hasNextPage: boolean;
+    hasPreviousPage: boolean;
+    isFetchingNextPage: boolean;
+    isFetchingPreviousPage: boolean;
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: import('@tanstack/react-query').RefetchOptions) => Promise<import('@tanstack/react-query').QueryObserverResult<import('@mastra/client-js').DatasetItem[], Error>>;
+    fetchStatus: import('@tanstack/react-query').FetchStatus;
+    promise: Promise<import('@mastra/client-js').DatasetItem[]>;
+} | {
+    setEndOfListElement: (node: HTMLDivElement | null) => (() => void) | undefined;
+    data: undefined;
+    error: null;
+    isError: false;
+    isPending: true;
+    isLoading: true;
+    isLoadingError: false;
+    isRefetchError: false;
+    isFetchNextPageError: false;
+    isFetchPreviousPageError: false;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "pending";
+    fetchNextPage: (options?: import('@tanstack/react-query').FetchNextPageOptions) => Promise<import('@tanstack/react-query').InfiniteQueryObserverResult<import('@mastra/client-js').DatasetItem[], Error>>;
+    fetchPreviousPage: (options?: import('@tanstack/react-query').FetchPreviousPageOptions) => Promise<import('@tanstack/react-query').InfiniteQueryObserverResult<import('@mastra/client-js').DatasetItem[], Error>>;
+    hasNextPage: boolean;
+    hasPreviousPage: boolean;
+    isFetchingNextPage: boolean;
+    isFetchingPreviousPage: boolean;
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: import('@tanstack/react-query').RefetchOptions) => Promise<import('@tanstack/react-query').QueryObserverResult<import('@mastra/client-js').DatasetItem[], Error>>;
+    fetchStatus: import('@tanstack/react-query').FetchStatus;
+    promise: Promise<import('@mastra/client-js').DatasetItem[]>;
+} | {
+    setEndOfListElement: (node: HTMLDivElement | null) => (() => void) | undefined;
+    data: undefined;
+    error: null;
+    isError: false;
+    isPending: true;
+    isLoadingError: false;
+    isRefetchError: false;
+    isFetchNextPageError: false;
+    isFetchPreviousPageError: false;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "pending";
+    fetchNextPage: (options?: import('@tanstack/react-query').FetchNextPageOptions) => Promise<import('@tanstack/react-query').InfiniteQueryObserverResult<import('@mastra/client-js').DatasetItem[], Error>>;
+    fetchPreviousPage: (options?: import('@tanstack/react-query').FetchPreviousPageOptions) => Promise<import('@tanstack/react-query').InfiniteQueryObserverResult<import('@mastra/client-js').DatasetItem[], Error>>;
+    hasNextPage: boolean;
+    hasPreviousPage: boolean;
+    isFetchingNextPage: boolean;
+    isFetchingPreviousPage: boolean;
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isLoading: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: import('@tanstack/react-query').RefetchOptions) => Promise<import('@tanstack/react-query').QueryObserverResult<import('@mastra/client-js').DatasetItem[], Error>>;
+    fetchStatus: import('@tanstack/react-query').FetchStatus;
+    promise: Promise<import('@mastra/client-js').DatasetItem[]>;
+} | {
+    setEndOfListElement: (node: HTMLDivElement | null) => (() => void) | undefined;
+    data: import('@mastra/client-js').DatasetItem[];
+    isError: false;
+    error: null;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: true;
+    isPlaceholderData: true;
+    isFetchNextPageError: false;
+    isFetchPreviousPageError: false;
+    status: "success";
+    fetchNextPage: (options?: import('@tanstack/react-query').FetchNextPageOptions) => Promise<import('@tanstack/react-query').InfiniteQueryObserverResult<import('@mastra/client-js').DatasetItem[], Error>>;
+    fetchPreviousPage: (options?: import('@tanstack/react-query').FetchPreviousPageOptions) => Promise<import('@tanstack/react-query').InfiniteQueryObserverResult<import('@mastra/client-js').DatasetItem[], Error>>;
+    hasNextPage: boolean;
+    hasPreviousPage: boolean;
+    isFetchingNextPage: boolean;
+    isFetchingPreviousPage: boolean;
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: import('@tanstack/react-query').RefetchOptions) => Promise<import('@tanstack/react-query').QueryObserverResult<import('@mastra/client-js').DatasetItem[], Error>>;
+    fetchStatus: import('@tanstack/react-query').FetchStatus;
+    promise: Promise<import('@mastra/client-js').DatasetItem[]>;
+};

package/dist/src/domains/datasets/hooks/use-dataset-mutations.d.ts

@@ -0,0 +1,62 @@
+import { CreateDatasetParams, UpdateDatasetParams, AddDatasetItemParams, UpdateDatasetItemParams, TriggerDatasetExperimentParams, BatchInsertDatasetItemsParams, BatchDeleteDatasetItemsParams } from '@mastra/client-js';
+/**
+ * Hook providing mutation functions for datasets, items, and runs
+ * All mutations invalidate relevant query caches on success
+ */
+export declare const useDatasetMutations: () => {
+    createDataset: import('@tanstack/react-query').UseMutationResult<import('@mastra/client-js').DatasetRecord, Error, CreateDatasetParams, unknown>;
+    updateDataset: import('@tanstack/react-query').UseMutationResult<import('@mastra/client-js').DatasetRecord, Error, UpdateDatasetParams, unknown>;
+    deleteDataset: import('@tanstack/react-query').UseMutationResult<{
+        success: boolean;
+    }, Error, string, unknown>;
+    addItem: import('@tanstack/react-query').UseMutationResult<import('@mastra/client-js').DatasetItem, Error, AddDatasetItemParams, unknown>;
+    updateItem: import('@tanstack/react-query').UseMutationResult<import('@mastra/client-js').DatasetItem, Error, UpdateDatasetItemParams, unknown>;
+    deleteItem: import('@tanstack/react-query').UseMutationResult<{
+        success: boolean;
+    }, Error, {
+        datasetId: string;
+        itemId: string;
+    }, unknown>;
+    deleteItems: import('@tanstack/react-query').UseMutationResult<{
+        success: boolean;
+        deletedCount: number;
+    }, Error, {
+        datasetId: string;
+        itemIds: string[];
+    }, unknown>;
+    batchInsertItems: import('@tanstack/react-query').UseMutationResult<{
+        items: import('@mastra/client-js').DatasetItem[];
+        count: number;
+    }, Error, BatchInsertDatasetItemsParams, unknown>;
+    batchDeleteItems: import('@tanstack/react-query').UseMutationResult<{
+        success: boolean;
+        deletedCount: number;
+    }, Error, BatchDeleteDatasetItemsParams, unknown>;
+    triggerExperiment: import('@tanstack/react-query').UseMutationResult<{
+        experimentId: string;
+        status: "pending" | "running" | "completed" | "failed";
+        totalItems: number;
+        succeededCount: number;
+        failedCount: number;
+        startedAt: string | Date;
+        completedAt: string | Date | null;
+        results: Array<{
+            itemId: string;
+            itemDatasetVersion: number | null;
+            input: unknown;
+            output: unknown | null;
+            groundTruth: unknown | null;
+            error: string | null;
+            startedAt: string | Date;
+            completedAt: string | Date;
+            retryCount: number;
+            scores: Array<{
+                scorerId: string;
+                scorerName: string;
+                score: number | null;
+                reason: string | null;
+                error: string | null;
+            }>;
+        }>;
+    }, Error, TriggerDatasetExperimentParams, unknown>;
+};

package/dist/src/domains/datasets/hooks/use-dataset-versions.d.ts

@@ -0,0 +1,17 @@
+export interface DatasetVersion {
+    id?: string;
+    datasetId?: string;
+    version: number;
+    createdAt?: Date | string;
+    isCurrent: boolean;
+}
+/**
+ * Hook to fetch dataset versions from the API with infinite pagination.
+ */
+export declare const useDatasetVersions: (datasetId: string) => import('@tanstack/react-query').UseInfiniteQueryResult<{
+    id: string;
+    datasetId: string;
+    version: number;
+    createdAt: string | Date;
+    isCurrent: boolean;
+}[], Error>;

package/dist/src/domains/datasets/hooks/use-datasets.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Hook to list all datasets with optional pagination
+ */
+export declare const useDatasets: (pagination?: {
+    page?: number;
+    perPage?: number;
+}) => import('@tanstack/react-query').UseQueryResult<{
+    datasets: import('@mastra/client-js').DatasetRecord[];
+    pagination: import('@mastra/core/storage').PaginationInfo;
+}, Error>;
+/**
+ * Hook to fetch a single dataset by ID
+ */
+export declare const useDataset: (datasetId: string) => import('@tanstack/react-query').UseQueryResult<import('@mastra/client-js').DatasetRecord, Error>;

package/dist/src/domains/datasets/hooks/use-item-selection.d.ts

@@ -0,0 +1,17 @@
+export interface ItemSelectionState {
+    /** Set of currently selected item IDs */
+    selectedIds: Set<string>;
+    /** Number of selected items */
+    selectedCount: number;
+    /** Toggle single item or range selection with shift key */
+    toggle: (id: string, shiftKey: boolean, allIds: string[]) => void;
+    /** Select all provided IDs */
+    selectAll: (ids: string[]) => void;
+    /** Clear all selections */
+    clearSelection: () => void;
+}
+/**
+ * Hook for managing item selection state
+ * Supports single toggle, shift-click range selection, and select all
+ */
+export declare function useItemSelection(): ItemSelectionState;

package/dist/src/domains/datasets/hooks/use-json-parser.d.ts

@@ -0,0 +1,15 @@
+import { ImportableItem, JSONValidationError } from '../utils/json-validation';
+/** Result of parsing a JSON file */
+export interface ParsedJSON {
+    items: ImportableItem[];
+    errors: JSONValidationError[];
+    rawData: unknown;
+}
+/**
+ * Hook for parsing JSON files for dataset import
+ */
+export declare function useJSONParser(): {
+    parseFile: (file: File) => Promise<ParsedJSON>;
+    isParsing: boolean;
+    error: Error | null;
+};

package/dist/src/domains/datasets/hooks/use-scorer-schema.d.ts

@@ -0,0 +1,14 @@
+import { JSONSchema7 } from 'json-schema';
+/**
+ * Hook that returns scorer input/output schemas.
+ * - agentInputSchema: for agent-type scorers (ScorerRunInputForAgent/ScorerRunOutputForAgent)
+ * - customInputSchema: for custom scorers (input/output as any)
+ * - outputSchema: score + reason from scoreRowDataSchema
+ */
+export declare function useScorerSchema(): {
+    agentInputSchema: JSONSchema7;
+    customInputSchema: JSONSchema7;
+    outputSchema: JSONSchema7;
+    isLoading: boolean;
+    error: Error | null;
+};

package/dist/src/domains/datasets/hooks/use-workflow-schema.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Hook to fetch workflow input/output schema by workflow ID.
+ * Returns { inputSchema, outputSchema } where each is Record<string, unknown> | null.
+ */
+export declare function useWorkflowSchema(workflowId: string | null): import('@tanstack/react-query').UseQueryResult<{
+    inputSchema: Record<string, unknown> | null;
+    outputSchema: Record<string, unknown> | null;
+}, Error>;

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

@@ -0,0 +1,53 @@
+export * from './hooks/use-datasets';
+export * from './hooks/use-dataset-items';
+export * from './hooks/use-dataset-item-versions';
+export * from './hooks/use-dataset-experiments';
+export * from './hooks/use-compare-experiments';
+export * from './hooks/use-dataset-versions';
+export * from './hooks/use-dataset-mutations';
+export * from './hooks/use-csv-parser';
+export * from './utils/csv-validation';
+export * from './utils/json-cell-parser';
+export * from './hooks/use-json-parser';
+export * from './utils/json-validation';
+export * from './hooks/use-item-selection';
+export * from './utils/csv-export';
+export * from './utils/json-export';
+export { DatasetsTable } from './components/datasets-table/datasets-table';
+export { CreateDatasetDialog } from './components/create-dataset-dialog';
+export { CreateDatasetFromItemsDialog } from './components/create-dataset-from-items-dialog';
+export { AddItemsToDatasetDialog } from './components/add-items-to-dataset-dialog';
+export { DuplicateDatasetDialog } from './components/duplicate-dataset-dialog';
+export { EditDatasetDialog } from './components/edit-dataset-dialog';
+export { DeleteDatasetDialog } from './components/delete-dataset-dialog';
+export { EmptyDatasetsTable } from './components/empty-datasets-table';
+export { DatasetPageContent } from './components/dataset-detail/dataset-page-content';
+export { DatasetItemsList } from './components/items/dataset-items-list';
+export { DatasetExperiments } from './components/experiments/dataset-experiments';
+export { ActionsMenu } from './components/dataset-detail/items-list-actions';
+export { AddItemDialog } from './components/add-item-dialog';
+export { EditItemDialog } from './components/edit-item-dialog';
+export { DatasetItemHeader } from './components/dataset-detail/dataset-item-header';
+export type { DatasetItemHeaderProps } from './components/dataset-detail/dataset-item-header';
+export { DatasetItemContent } from './components/dataset-detail/dataset-item-content';
+export type { DatasetItemContentProps } from './components/dataset-detail/dataset-item-content';
+export { EditModeContent } from './components/dataset-detail/dataset-item-form';
+export type { EditModeContentProps } from './components/dataset-detail/dataset-item-form';
+export { ItemPageToolbar } from './components/dataset-detail/item-page-toolbar';
+export type { ItemPageToolbarProps } from './components/dataset-detail/item-page-toolbar';
+export { CSVImportDialog } from './components/csv-import';
+export { JSONImportDialog } from './components/json-import';
+export { ExperimentTriggerDialog } from './components/experiment-trigger/experiment-trigger-dialog';
+export { TargetSelector, type TargetType } from './components/experiment-trigger/target-selector';
+export { ScorerSelector } from './components/experiment-trigger/scorer-selector';
+export { ExperimentResultsListAndDetails, type ExperimentResultsListAndDetailsProps, } from '../experiments/components/experiment-results-list-and-details';
+export { ExperimentPageHeader, type ExperimentPageHeaderProps } from '../experiments/components/experiment-page-header';
+export { ExperimentStats, type ExperimentStatsProps } from '../experiments/components/experiment-stats';
+export { ExperimentResultTracePanel, type ExperimentResultTracePanelProps, } from '../experiments/components/experiment-result-trace-panel';
+export { ExperimentResultSpanPane, type ExperimentResultSpanPaneProps, } from '../experiments/components/experiment-result-span-pane';
+export { ComparisonView } from './components/comparison/comparison-view';
+export { ScoreDelta } from './components/comparison/score-delta';
+export { DatasetVersionsPanel } from './components/items/dataset-versions-panel';
+export { DatasetItemVersionsPanel } from './components/versions';
+export { DatasetCompareVersionToolbar } from './components/versions';
+export { DatasetCompareVersionsList } from './components/versions';

package/dist/src/domains/datasets/pages/datasets/item/index.d.ts

@@ -0,0 +1,10 @@
+import { DatasetItem } from '@mastra/client-js';
+export interface DatasetItemPageProps {
+    item: DatasetItem;
+}
+/**
+ * Page component for displaying a single dataset item's details.
+ * Read-only view showing input, ground truth, and metadata.
+ */
+export declare function DatasetItemPage({ item }: DatasetItemPageProps): import("react/jsx-runtime").JSX.Element;
+export default DatasetItemPage;

package/dist/src/domains/datasets/utils/csv-export.d.ts

@@ -0,0 +1,6 @@
+import { DatasetItem } from '@mastra/client-js';
+/**
+ * Export dataset items to CSV and trigger download
+ * Columns: input, groundTruth, createdAt
+ */
+export declare function exportItemsToCSV(items: DatasetItem[], filename: string): void;

package/dist/src/domains/datasets/utils/csv-validation.d.ts

@@ -0,0 +1,62 @@
+/**
+ * CSV validation utilities for dataset import
+ * Validates mapped data before import, including schema validation
+ */
+/** Column mapping configuration */
+export type ColumnMapping = Record<string, 'input' | 'groundTruth' | 'metadata' | 'ignore'>;
+/** Validation error for a specific row/column */
+export interface ValidationError {
+    row: number;
+    column: string;
+    message: string;
+}
+/** Result of validation */
+export interface ValidationResult {
+    valid: boolean;
+    errors: ValidationError[];
+}
+/** Field-level validation error from schema validation */
+export interface FieldError {
+    path: string;
+    code: string;
+    message: string;
+}
+/** Validation result for a single row */
+export interface RowValidationResult {
+    rowNumber: number;
+    field: 'input' | 'groundTruth';
+    errors: FieldError[];
+    data: unknown;
+}
+/** Overall CSV schema validation result */
+export interface CsvValidationResult {
+    validCount: number;
+    invalidCount: number;
+    validRows: Array<{
+        rowNumber: number;
+        input: unknown;
+        groundTruth?: unknown;
+    }>;
+    invalidRows: RowValidationResult[];
+    totalRows: number;
+}
+/**
+ * Validate CSV rows against dataset schemas.
+ *
+ * @param rows Mapped rows from CSV (with input/groundTruth fields)
+ * @param inputSchema JSON Schema for input field (null = skip validation)
+ * @param groundTruthSchema JSON Schema for groundTruth field (null = skip validation)
+ * @param maxErrors Maximum number of invalid rows to collect details for (default 10)
+ */
+export declare function validateCsvRows(rows: Array<{
+    input: unknown;
+    groundTruth?: unknown;
+}>, inputSchema: Record<string, unknown> | null | undefined, groundTruthSchema: Record<string, unknown> | null | undefined, maxErrors?: number): CsvValidationResult;
+/**
+ * Validate mapped CSV data before import (basic validation without schemas).
+ * Checks that input columns are mapped and values are present.
+ * @param data - Parsed CSV rows
+ * @param mapping - Column mapping configuration
+ * @returns Validation result with errors
+ */
+export declare function validateMappedData(data: Record<string, unknown>[], mapping: ColumnMapping): ValidationResult;

package/dist/src/domains/datasets/utils/json-cell-parser.d.ts

@@ -0,0 +1,24 @@
+/**
+ * JSON cell parser for CSV import
+ * Auto-parses JSON strings in cells, with warnings for malformed JSON
+ */
+export interface ParsedCell {
+    parsed: unknown;
+    warning?: string;
+}
+export interface ParsedRow {
+    data: Record<string, unknown>;
+    warnings: string[];
+}
+/**
+ * Parse a single cell value, attempting JSON parse if it looks like JSON
+ * - null/undefined/empty string -> { parsed: null }
+ * - JSON string (starts with { or [) -> attempt parse, warn on failure
+ * - Plain string -> keep as-is
+ */
+export declare function parseJSONCell(value: string | null | undefined): ParsedCell;
+/**
+ * Parse all values in a row, converting empty strings to null
+ * and applying JSON parsing where applicable
+ */
+export declare function parseRow(row: Record<string, unknown>): ParsedRow;

package/dist/src/domains/datasets/utils/json-export.d.ts

@@ -0,0 +1,5 @@
+import { DatasetItem } from '@mastra/client-js';
+/**
+ * Export dataset items to JSON and trigger download
+ */
+export declare function exportItemsToJSON(items: DatasetItem[], filename: string): void;

package/dist/src/domains/datasets/utils/json-validation.d.ts

@@ -0,0 +1,27 @@
+/**
+ * JSON validation utilities for dataset import
+ * Validates JSON structure matches expected format
+ */
+/** Expected structure of an imported item */
+export interface ImportableItem {
+    input: unknown;
+    groundTruth?: unknown;
+    metadata?: Record<string, unknown>;
+}
+/** Validation error for a specific item */
+export interface JSONValidationError {
+    index: number;
+    message: string;
+}
+/** Result of JSON validation */
+export interface JSONValidationResult {
+    valid: boolean;
+    errors: JSONValidationError[];
+    items: ImportableItem[];
+}
+/**
+ * Validate JSON data for dataset import
+ * @param data - Parsed JSON data
+ * @returns Validation result with errors and valid items
+ */
+export declare function validateJSONData(data: unknown): JSONValidationResult;

package/dist/src/domains/experiments/components/experiment-page-header.d.ts

@@ -0,0 +1,6 @@
+import { DatasetExperiment } from '@mastra/client-js';
+export type ExperimentPageHeaderProps = {
+    experimentId: string;
+    experiment: DatasetExperiment;
+};
+export declare function ExperimentPageHeader({ experimentId, experiment }: ExperimentPageHeaderProps): import("react/jsx-runtime").JSX.Element;

package/dist/src/domains/experiments/components/experiment-result-panel.d.ts

@@ -0,0 +1,9 @@
+import { DatasetExperimentResult } from '@mastra/client-js';
+export type ExperimentResultPanelProps = {
+    result: DatasetExperimentResult;
+    onPrevious?: () => void;
+    onNext?: () => void;
+    onClose: () => void;
+    onShowTrace?: () => void;
+};
+export declare function ExperimentResultPanel({ result, onPrevious, onNext, onClose, onShowTrace, }: ExperimentResultPanelProps): import("react/jsx-runtime").JSX.Element;

package/dist/src/domains/experiments/components/experiment-result-span-pane.d.ts

@@ -0,0 +1,8 @@
+export type ExperimentResultSpanPaneProps = {
+    traceId: string;
+    spanId: string;
+    onNext?: () => void;
+    onPrevious?: () => void;
+    onClose: () => void;
+};
+export declare function ExperimentResultSpanPane({ traceId, spanId, onNext, onPrevious, onClose, }: ExperimentResultSpanPaneProps): import("react/jsx-runtime").JSX.Element;

package/dist/src/domains/experiments/components/experiment-result-trace-panel.d.ts

@@ -0,0 +1,7 @@
+export type ExperimentResultTracePanelProps = {
+    traceId: string;
+    selectedSpanId?: string;
+    onSpanSelect?: (spanId: string | undefined) => void;
+    onClose: () => void;
+};
+export declare function ExperimentResultTracePanel({ traceId, selectedSpanId, onSpanSelect, onClose, }: ExperimentResultTracePanelProps): import("react/jsx-runtime").JSX.Element;

package/dist/src/domains/experiments/components/experiment-results-list-and-details.d.ts

@@ -0,0 +1,10 @@
+import { DatasetExperimentResult } from '@mastra/client-js';
+export type ExperimentResultsListAndDetailsProps = {
+    results: DatasetExperimentResult[];
+    isLoading: boolean;
+};
+/**
+ * Master-detail layout for experiment results.
+ * Shows results list on left, result detail panel on right when a result is selected.
+ */
+export declare function ExperimentResultsListAndDetails({ results, isLoading }: ExperimentResultsListAndDetailsProps): import("react/jsx-runtime").JSX.Element;

package/dist/src/domains/experiments/components/experiment-results-list.d.ts

@@ -0,0 +1,17 @@
+import { DatasetExperimentResult } from '@mastra/client-js';
+export type ExperimentResultsListProps = {
+    results: DatasetExperimentResult[];
+    isLoading: boolean;
+    featuredResultId: string | null;
+    onResultClick: (resultId: string) => void;
+    columns: {
+        name: string;
+        label: string;
+        size: string;
+    }[];
+};
+/**
+ * List component for experiment results - controlled by parent for selection state.
+ * Used by ExperimentResultsListAndDetails.
+ */
+export declare function ExperimentResultsList({ results, isLoading, featuredResultId, onResultClick, columns, }: ExperimentResultsListProps): import("react/jsx-runtime").JSX.Element;

package/dist/src/domains/experiments/components/experiment-stats.d.ts

@@ -0,0 +1,6 @@
+import { DatasetExperiment } from '@mastra/client-js';
+export interface ExperimentStatsProps {
+    experiment: DatasetExperiment;
+    className?: string;
+}
+export declare function ExperimentStats({ experiment, className }: ExperimentStatsProps): import("react/jsx-runtime").JSX.Element;