@gntik-ai/blocks 0.0.0-stage → 0.5.0

package/package.json

@@ -1,6 +1,65 @@
 {
   "name": "@gntik-ai/blocks",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.5.0",
+  "description": "gntik-ui blocks: page chrome, data display, tables, forms, feedback, billing, team and builder sections composed from @gntik-ai/ui.",
+  "license": "MIT",
+  "type": "module",
+  "sideEffects": [
+    "*.css"
+  ],
+  "files": [
+    "dist",
+    "src"
+  ],
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./package.json": "./package.json",
+    "./styles.css": "./src/styles.css"
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/",
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/gntik-ai/gntik-ui.git",
+    "directory": "packages/blocks"
+  },
+  "peerDependencies": {
+    "react": "^19.0.0",
+    "react-dom": "^19.0.0"
+  },
+  "dependencies": {
+    "@gntik-ai/charts": "0.5.0",
+    "@gntik-ai/editor": "0.5.0",
+    "@gntik-ai/flow": "0.5.0",
+    "@gntik-ai/icons": "0.5.0",
+    "@gntik-ai/tokens": "0.2.1",
+    "@gntik-ai/ui": "0.5.0",
+    "lucide-react": "^1.48.0"
+  },
+  "devDependencies": {
+    "@testing-library/jest-dom": "^7.0.1",
+    "@testing-library/react": "^16.3.3",
+    "@testing-library/user-event": "^14.6.7",
+    "@types/react": "^19.3.0",
+    "@types/react-dom": "^19.3.0",
+    "axe-core": "^4.13.0",
+    "jsdom": "^30.1.1",
+    "react": "^19.3.0",
+    "react-dom": "^19.3.0",
+    "tsdown": "^0.23.0",
+    "typescript": "~6.0.3",
+    "vitest": "^5.0.2"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "test": "vitest run"
+  }
 }

package/src/ai/AssistantCardGrid/AssistantCardGrid.test.tsx

@@ -0,0 +1,32 @@
+import { render, screen } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import { expectNoAxeViolations } from '../../test/a11y';
+import { AssistantCardGrid } from './AssistantCardGrid';
+
+describe('AssistantCardGrid', () => {
+  it('renders one card per assistant with status and runtime', async () => {
+    render(<AssistantCardGrid onCreate={() => {}} />);
+    expect(screen.getByRole('heading', { name: 'Assistants' })).toBeInTheDocument();
+    expect(screen.getAllByRole('listitem')).toHaveLength(6);
+    expect(screen.getByText('6 total · 2 active')).toBeInTheDocument();
+    expect(screen.getAllByText('Degraded')).toHaveLength(1);
+    expect(screen.getByText('reasoning-small · self-hosted')).toBeInTheDocument();
+    await expectNoAxeViolations();
+  });
+
+  it('calls onSelect and onCreate', async () => {
+    const user = userEvent.setup();
+    const onSelect = vi.fn();
+    const onCreate = vi.fn();
+    render(<AssistantCardGrid onSelect={onSelect} onCreate={onCreate} />);
+    await user.click(screen.getByRole('button', { name: 'Invoice checker' }));
+    expect(onSelect).toHaveBeenCalledWith(expect.objectContaining({ id: 'a3' }));
+    await user.click(screen.getByRole('button', { name: 'New assistant' }));
+    expect(onCreate).toHaveBeenCalledTimes(1);
+  });
+
+  it('shows an empty state', () => {
+    render(<AssistantCardGrid assistants={[]} />);
+    expect(screen.getByText('No assistants yet')).toBeInTheDocument();
+  });
+});

package/src/ai/AssistantCardGrid/AssistantCardGrid.tsx

@@ -0,0 +1,98 @@
+import { useId } from 'react';
+import { Bot, Plus } from '@gntik-ai/icons';
+import { Button, ClickableCard, EmptyState, StatusTag, cn, type StatusDefinition } from '@gntik-ai/ui';
+import { assistants as defaultAssistants, type Assistant, type AssistantStatus } from './fixtures';
+
+export type { Assistant, AssistantStatus } from './fixtures';
+
+export const ASSISTANT_STATUSES: Record<AssistantStatus, StatusDefinition> = {
+  active: { label: 'Active', tone: 'success' },
+  paused: { label: 'Paused', tone: 'neutral' },
+  draft: { label: 'Draft', tone: 'neutral' },
+  degraded: { label: 'Degraded', tone: 'warning' },
+  failed: { label: 'Failed', tone: 'destructive' },
+};
+
+export interface AssistantCardGridProps {
+  assistants?: Assistant[];
+  title?: string;
+  /** Called when a card is activated (cards with `href` also navigate). */
+  onSelect?: (assistant: Assistant) => void;
+  /** Shows a "New assistant" button. */
+  onCreate?: () => void;
+  /** Heading level of the section title (default h2); card names use the next level. */
+  titleAs?: 'h2' | 'h3';
+  className?: string;
+}
+
+/** Grid of assistants as clickable cards (1 → 2 → 3 columns). */
+export function AssistantCardGrid({
+  assistants = defaultAssistants,
+  title = 'Assistants',
+  onSelect,
+  onCreate,
+  titleAs: TitleTag = 'h2',
+  className,
+}: AssistantCardGridProps) {
+  const titleId = useId();
+  const active = assistants.filter((a) => a.status === 'active').length;
+  return (
+    <section aria-labelledby={titleId} className={cn('flex flex-col gap-4', className)}>
+      <div className="flex flex-wrap items-end justify-between gap-3">
+        <div>
+          <TitleTag id={titleId} className="text-[15px] font-semibold tracking-tight text-foreground">
+            {title}
+          </TitleTag>
+          <p className="text-[12.5px] text-muted-foreground">
+            {assistants.length} total · {active} active
+          </p>
+        </div>
+        {onCreate && (
+          <Button size="sm" icon={Plus} onClick={onCreate}>
+            New assistant
+          </Button>
+        )}
+      </div>
+      {assistants.length === 0 ? (
+        <EmptyState
+          icon={Bot}
+          title="No assistants yet"
+          titleAs={TitleTag === 'h2' ? 'h3' : 'h4'}
+          description="Create an assistant to automate a task with a model."
+          primaryAction={
+            onCreate ? (
+              <Button size="sm" icon={Plus} onClick={onCreate}>
+                New assistant
+              </Button>
+            ) : undefined
+          }
+        />
+      ) : (
+        <ul className="grid gap-3 sm:grid-cols-2 xl:grid-cols-3">
+          {assistants.map((a) => (
+            <li key={a.id} className="flex">
+              <ClickableCard
+                className="w-full"
+                titleAs={TitleTag === 'h2' ? 'h3' : 'h4'}
+                href={a.href}
+                onClick={() => onSelect?.(a)}
+                icon={<Bot aria-hidden />}
+                title={a.name}
+                description={a.description}
+                meta={
+                  <span className="flex flex-wrap items-center gap-x-2 gap-y-1.5">
+                    <StatusTag status={a.status} statuses={ASSISTANT_STATUSES} />
+                    <span className="font-mono text-[11px] text-muted-foreground">
+                      {a.model} · {a.runtime}
+                    </span>
+                    {a.updated && <span className="text-[11px] text-muted-foreground">Updated {a.updated}</span>}
+                  </span>
+                }
+              />
+            </li>
+          ))}
+        </ul>
+      )}
+    </section>
+  );
+}

package/src/ai/AssistantCardGrid/block.meta.ts

@@ -0,0 +1,10 @@
+import type { BlockMeta } from '../../meta';
+
+export const meta: BlockMeta = {
+  name: 'Assistant card grid',
+  family: 'ai',
+  status: 'beta',
+  description:
+    'Responsive grid of clickable assistant cards: name, description, model and runtime, status and last update, with a create action.',
+  uses: ['ClickableCard', 'StatusTag', 'Button', 'EmptyState'],
+};

package/src/ai/AssistantCardGrid/fixtures.ts

@@ -0,0 +1,72 @@
+export type AssistantStatus = 'active' | 'paused' | 'draft' | 'degraded' | 'failed';
+
+export interface Assistant {
+  id: string;
+  name: string;
+  description: string;
+  /** Model identifier, e.g. "general-large". */
+  model: string;
+  /** Where it runs, e.g. "openai-compatible" or "self-hosted". */
+  runtime: string;
+  status: AssistantStatus;
+  /** Relative update time, e.g. "2h ago". */
+  updated?: string;
+  /** Optional link to the assistant's page. */
+  href?: string;
+}
+
+export const assistants: Assistant[] = [
+  {
+    id: 'a1',
+    name: 'Support triage',
+    description: 'Classifies incoming tickets and drafts first replies.',
+    model: 'general-large',
+    runtime: 'openai-compatible',
+    status: 'active',
+    updated: '2h ago',
+  },
+  {
+    id: 'a2',
+    name: 'Release notes writer',
+    description: 'Summarises merged changes into customer-facing notes.',
+    model: 'general-medium',
+    runtime: 'Provider A',
+    status: 'active',
+    updated: 'yesterday',
+  },
+  {
+    id: 'a3',
+    name: 'Invoice checker',
+    description: 'Flags invoices whose totals do not match the usage report.',
+    model: 'reasoning-small',
+    runtime: 'self-hosted',
+    status: 'degraded',
+    updated: '3d ago',
+  },
+  {
+    id: 'a4',
+    name: 'Onboarding guide',
+    description: 'Answers setup questions from the product documentation.',
+    model: 'general-small',
+    runtime: 'self-hosted',
+    status: 'paused',
+    updated: '1w ago',
+  },
+  {
+    id: 'a5',
+    name: 'Data cleanup',
+    description: 'Normalises imported records before they reach the warehouse.',
+    model: 'general-medium',
+    runtime: 'openai-compatible',
+    status: 'draft',
+  },
+  {
+    id: 'a6',
+    name: 'Incident summariser',
+    description: 'Builds a timeline from alerts and chat during an incident.',
+    model: 'general-large',
+    runtime: 'Provider A',
+    status: 'failed',
+    updated: '5h ago',
+  },
+];

package/src/ai/EvaluationScorecard/EvaluationScorecard.test.tsx

@@ -0,0 +1,39 @@
+import { render, screen, within } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import { expectNoAxeViolations } from '../../test/a11y';
+import { EvaluationScorecard } from './EvaluationScorecard';
+
+const bodyRows = () => within(screen.getByRole('table')).getAllByRole('row').slice(1);
+
+describe('EvaluationScorecard', () => {
+  it('renders datasets × metrics with pass rates, deltas and flagged regressions', async () => {
+    render(<EvaluationScorecard />);
+    expect(bodyRows()).toHaveLength(5);
+    expect(screen.getByRole('columnheader', { name: /p95 latency/ })).toBeInTheDocument();
+    const billing = bodyRows().find((r) => r.textContent?.includes('billing-questions'))!;
+    expect(within(billing).getByText('2 regressions')).toBeInTheDocument();
+    expect(within(billing).getByText('80.8%')).toBeInTheDocument();
+    expect(within(billing).getAllByText(/\(regression\)/)).toHaveLength(2);
+    expect(within(billing).getByText(/\(below threshold\)/)).toBeInTheDocument();
+    const docs = bodyRows().find((r) => r.textContent?.includes('product-docs'))!;
+    expect(within(docs).getByText('1 regression')).toBeInTheDocument();
+    await expectNoAxeViolations();
+  });
+
+  it('filters to regressed datasets only', async () => {
+    const user = userEvent.setup();
+    render(<EvaluationScorecard />);
+    await user.click(screen.getByRole('button', { name: /Regressions/ }));
+    expect(bodyRows().map((r) => within(r).getAllByRole('cell')[0]?.textContent)).toEqual([
+      expect.stringContaining('billing-questions'),
+      expect.stringContaining('product-docs'),
+    ]);
+  });
+
+  it('shows an empty row when nothing regressed', async () => {
+    const user = userEvent.setup();
+    render(<EvaluationScorecard rows={[]} />);
+    await user.click(screen.getByRole('button', { name: /Regressions/ }));
+    expect(screen.getByText('No regressions against baseline.')).toBeInTheDocument();
+  });
+});

package/src/ai/EvaluationScorecard/EvaluationScorecard.tsx

@@ -0,0 +1,233 @@
+import { useId, useState } from 'react';
+import { ArrowDown, ArrowUp, Minus } from '@gntik-ai/icons';
+import {
+  Badge,
+  Table,
+  TableBody,
+  TableCell,
+  TableHead,
+  TableHeader,
+  TableRow,
+  Toggle,
+  ToggleGroup,
+  cn,
+} from '@gntik-ai/ui';
+import { evalMetrics, evalRows, type EvalMetric, type EvalRow } from './fixtures';
+
+export type { EvalMetric, EvalRow } from './fixtures';
+
+export interface EvaluationScorecardProps {
+  metrics?: EvalMetric[];
+  rows?: EvalRow[];
+  title?: string;
+  /** Label of the run compared against, e.g. "baseline · v12". */
+  baselineLabel?: string;
+  /** Pass-rate drop (ratio) that counts as a regression. */
+  passRateTolerance?: number;
+  /** Heading level of the title, to fit the page outline (default h3). */
+  titleAs?: 'h2' | 'h3' | 'h4';
+  className?: string;
+}
+
+type Trend = 'better' | 'worse' | 'flat';
+
+function formatValue(value: number, format: EvalMetric['format'] = 'percent') {
+  if (format === 'percent') return `${(value * 100).toFixed(1)}%`;
+  if (format === 'ms') return `${Math.round(value)}ms`;
+  return value.toFixed(2);
+}
+
+function formatDelta(delta: number, format: EvalMetric['format'] = 'percent') {
+  const sign = delta > 0 ? '+' : delta < 0 ? '−' : '±';
+  const abs = Math.abs(delta);
+  if (format === 'percent') return `${sign}${(abs * 100).toFixed(1)} pt`;
+  if (format === 'ms') return `${sign}${Math.round(abs)}ms`;
+  return `${sign}${abs.toFixed(2)}`;
+}
+
+function trendOf(delta: number, higherIsBetter: boolean, tolerance: number): Trend {
+  const signed = higherIsBetter ? delta : -delta;
+  if (signed < -tolerance) return 'worse';
+  if (signed > tolerance) return 'better';
+  return 'flat';
+}
+
+const TREND: Record<Trend, { className: string; sr: string }> = {
+  better: { className: 'text-success-text', sr: 'improved' },
+  worse: { className: 'text-destructive-text', sr: 'regression' },
+  flat: { className: 'text-muted-foreground', sr: 'unchanged' },
+};
+
+function Delta({
+  delta,
+  trend,
+  format,
+  increase,
+}: {
+  delta: number;
+  trend: Trend;
+  format: EvalMetric['format'];
+  increase: boolean;
+}) {
+  const t = TREND[trend];
+  const TrendIcon = trend === 'flat' ? Minus : increase ? ArrowUp : ArrowDown;
+  return (
+    <span className={cn('inline-flex items-center gap-0.5 font-mono text-[10.5px]', t.className)}>
+      <TrendIcon size={11} aria-hidden />
+      {formatDelta(delta, format)}
+      <span className="sr-only"> ({t.sr})</span>
+    </span>
+  );
+}
+
+function analyse(row: EvalRow, metrics: EvalMetric[], passRateTolerance: number) {
+  const passRate = row.samples > 0 ? row.passed / row.samples : 0;
+  const basePassRate = row.samples > 0 ? row.baselinePassed / row.samples : 0;
+  const passTrend = trendOf(passRate - basePassRate, true, passRateTolerance);
+  const cells = metrics.map((m) => {
+    const value = row.scores[m.id];
+    const base = row.baseline[m.id];
+    const higher = m.higherIsBetter ?? true;
+    const delta = value !== undefined && base !== undefined ? value - base : 0;
+    const trend = value !== undefined && base !== undefined ? trendOf(delta, higher, m.tolerance ?? 0) : 'flat';
+    const passes = value === undefined ? undefined : higher ? value >= m.threshold : value <= m.threshold;
+    return { metric: m, value, delta, trend, passes };
+  });
+  const regressions = cells.filter((c) => c.trend === 'worse').length + (passTrend === 'worse' ? 1 : 0);
+  return { passRate, basePassRate, passTrend, cells, regressions };
+}
+
+/** Evaluation results by dataset and metric, compared with a baseline run. */
+export function EvaluationScorecard({
+  metrics = evalMetrics,
+  rows = evalRows,
+  title = 'Evaluation results',
+  baselineLabel = 'baseline',
+  passRateTolerance = 0.02,
+  titleAs: TitleTag = 'h3',
+  className,
+}: EvaluationScorecardProps) {
+  const titleId = useId();
+  const [filter, setFilter] = useState<'all' | 'regressions'>('all');
+  const analysed = rows.map((row) => ({ row, ...analyse(row, metrics, passRateTolerance) }));
+  const regressed = analysed.filter((a) => a.regressions > 0);
+  const shown = filter === 'regressions' ? regressed : analysed;
+  const samples = rows.reduce((s, r) => s + r.samples, 0);
+  const overall = samples > 0 ? rows.reduce((s, r) => s + r.passed, 0) / samples : 0;
+  const overallBase = samples > 0 ? rows.reduce((s, r) => s + r.baselinePassed, 0) / samples : 0;
+  const overallTrend = trendOf(overall - overallBase, true, passRateTolerance / 2);
+
+  return (
+    <section
+      aria-labelledby={titleId}
+      className={cn('overflow-hidden rounded-lg border border-border bg-card shadow-sm', className)}
+    >
+      <header className="flex flex-col gap-3 border-b border-border px-4 py-3 sm:flex-row sm:items-center sm:justify-between">
+        <div>
+          <TitleTag id={titleId} className="text-[13.5px] font-semibold text-foreground">
+            {title}
+          </TitleTag>
+          <p className="mt-0.5 flex flex-wrap items-center gap-x-2 text-[12px] text-muted-foreground">
+            <span>
+              Pass rate <span className="font-mono font-semibold text-foreground">{formatValue(overall)}</span>
+            </span>
+            <Delta
+              delta={overall - overallBase}
+              trend={overallTrend}
+              format="percent"
+              increase={overall >= overallBase}
+            />
+            <span>
+              vs {baselineLabel} · {samples.toLocaleString('en-US')} samples
+            </span>
+          </p>
+        </div>
+        <ToggleGroup
+          aria-label="Show datasets"
+          size="sm"
+          value={[filter]}
+          onValueChange={(v) => v[0] && setFilter(v[0] as 'all' | 'regressions')}
+        >
+          <Toggle value="all">
+            All <span className="font-mono text-[10.5px] opacity-70">{rows.length}</span>
+          </Toggle>
+          <Toggle value="regressions">
+            Regressions <span className="font-mono text-[10.5px] opacity-70">{regressed.length}</span>
+          </Toggle>
+        </ToggleGroup>
+      </header>
+      <Table density="compact" containerLabel={title}>
+        <TableHeader>
+          <TableRow>
+            <TableHead>Dataset</TableHead>
+            <TableHead align="right">Pass rate</TableHead>
+            {metrics.map((m) => (
+              <TableHead key={m.id} align="right">
+                {m.label}
+                <span className="block font-mono text-[10px] font-normal text-muted-foreground">
+                  {(m.higherIsBetter ?? true) ? '≥' : '≤'} {formatValue(m.threshold, m.format)}
+                </span>
+              </TableHead>
+            ))}
+          </TableRow>
+        </TableHeader>
+        <TableBody>
+          {shown.length === 0 ? (
+            <TableRow>
+              <TableCell colSpan={metrics.length + 2} className="py-6 text-center text-muted-foreground">
+                No regressions against {baselineLabel}.
+              </TableCell>
+            </TableRow>
+          ) : (
+            shown.map(({ row, passRate, basePassRate, passTrend, cells, regressions }) => (
+              <TableRow key={row.id} data-regressed={regressions > 0 || undefined}>
+                <TableCell>
+                  <div className="flex flex-wrap items-center gap-2">
+                    <span className="font-mono text-[12.5px] text-foreground">{row.dataset}</span>
+                    {regressions > 0 && (
+                      <Badge tone="destructive" size="sm">
+                        {regressions} {regressions === 1 ? 'regression' : 'regressions'}
+                      </Badge>
+                    )}
+                  </div>
+                  <span className="text-[11px] text-muted-foreground">
+                    {row.passed}/{row.samples} passed
+                  </span>
+                </TableCell>
+                <TableCell align="right">
+                  <span className="block font-mono text-[12.5px] text-foreground">{formatValue(passRate)}</span>
+                  <Delta
+                    delta={passRate - basePassRate}
+                    trend={passTrend}
+                    format="percent"
+                    increase={passRate >= basePassRate}
+                  />
+                </TableCell>
+                {cells.map(({ metric, value, delta, trend, passes }) => (
+                  <TableCell key={metric.id} align="right">
+                    {value === undefined ? (
+                      <span className="text-muted-foreground">—</span>
+                    ) : (
+                      <>
+                        <span
+                          className={cn(
+                            'block font-mono text-[12.5px]',
+                            passes ? 'text-foreground' : 'text-warning-text',
+                          )}
+                        >
+                          {formatValue(value, metric.format)}
+                          {!passes && <span className="sr-only"> (below threshold)</span>}
+                        </span>
+                        <Delta delta={delta} trend={trend} format={metric.format} increase={delta >= 0} />
+                      </>
+                    )}
+                  </TableCell>
+                ))}
+              </TableRow>
+            ))
+          )}
+        </TableBody>
+      </Table>
+    </section>
+  );
+}

package/src/ai/EvaluationScorecard/block.meta.ts

@@ -0,0 +1,10 @@
+import type { BlockMeta } from '../../meta';
+
+export const meta: BlockMeta = {
+  name: 'Evaluation scorecard',
+  family: 'ai',
+  status: 'beta',
+  description:
+    'Evaluation run as a datasets × metrics table: pass rate, scores against thresholds, deltas vs the baseline and flagged regressions, with a regressions-only filter.',
+  uses: ['Table', 'Badge', 'ToggleGroup', 'Toggle'],
+};

package/src/ai/EvaluationScorecard/fixtures.ts

@@ -0,0 +1,79 @@
+export interface EvalMetric {
+  id: string;
+  label: string;
+  /** Minimum (or maximum, when lower is better) value that passes. */
+  threshold: number;
+  /** Defaults to true; false for costs and latencies. */
+  higherIsBetter?: boolean;
+  /** How values are shown: ratio as a percentage, or milliseconds. */
+  format?: 'percent' | 'ms' | 'number';
+  /** Change vs baseline that counts as a regression (same unit as the values). */
+  tolerance?: number;
+}
+
+export interface EvalRow {
+  id: string;
+  dataset: string;
+  samples: number;
+  /** Samples that passed every check in this run. */
+  passed: number;
+  /** Samples that passed in the baseline run. */
+  baselinePassed: number;
+  scores: Record<string, number>;
+  baseline: Record<string, number>;
+}
+
+export const evalMetrics: EvalMetric[] = [
+  { id: 'accuracy', label: 'Accuracy', threshold: 0.85, format: 'percent', tolerance: 0.02 },
+  { id: 'faithfulness', label: 'Faithfulness', threshold: 0.8, format: 'percent', tolerance: 0.02 },
+  { id: 'relevance', label: 'Relevance', threshold: 0.8, format: 'percent', tolerance: 0.02 },
+  { id: 'latency', label: 'p95 latency', threshold: 2000, higherIsBetter: false, format: 'ms', tolerance: 150 },
+];
+
+export const evalRows: EvalRow[] = [
+  {
+    id: 'r1',
+    dataset: 'support-faq',
+    samples: 240,
+    passed: 221,
+    baselinePassed: 214,
+    scores: { accuracy: 0.93, faithfulness: 0.91, relevance: 0.89, latency: 1420 },
+    baseline: { accuracy: 0.9, faithfulness: 0.9, relevance: 0.88, latency: 1510 },
+  },
+  {
+    id: 'r2',
+    dataset: 'billing-questions',
+    samples: 120,
+    passed: 97,
+    baselinePassed: 106,
+    scores: { accuracy: 0.84, faithfulness: 0.86, relevance: 0.82, latency: 1650 },
+    baseline: { accuracy: 0.89, faithfulness: 0.87, relevance: 0.83, latency: 1600 },
+  },
+  {
+    id: 'r3',
+    dataset: 'product-docs',
+    samples: 310,
+    passed: 284,
+    baselinePassed: 281,
+    scores: { accuracy: 0.92, faithfulness: 0.88, relevance: 0.9, latency: 1880 },
+    baseline: { accuracy: 0.91, faithfulness: 0.88, relevance: 0.9, latency: 1700 },
+  },
+  {
+    id: 'r4',
+    dataset: 'edge-cases',
+    samples: 80,
+    passed: 58,
+    baselinePassed: 55,
+    scores: { accuracy: 0.76, faithfulness: 0.79, relevance: 0.81, latency: 2210 },
+    baseline: { accuracy: 0.73, faithfulness: 0.78, relevance: 0.8, latency: 2250 },
+  },
+  {
+    id: 'r5',
+    dataset: 'multilingual',
+    samples: 150,
+    passed: 132,
+    baselinePassed: 131,
+    scores: { accuracy: 0.88, faithfulness: 0.85, relevance: 0.86, latency: 1540 },
+    baseline: { accuracy: 0.88, faithfulness: 0.86, relevance: 0.85, latency: 1530 },
+  },
+];