@crvouga/atlas 0.9.0 → 0.10.0

package/packages/visualizer/src/explorer/groups.test.ts

@@ -0,0 +1,87 @@
+import { catalogModel, TestHistory } from '@crvouga/atlas/reports/test-catalog';
+import type { LayerEvidence, LayerHeader, LayerRow } from '@crvouga/atlas/reports/evidence-types';
+import { expect, test } from 'bun:test';
+
+import { modelFromCatalog, withLiveProgress } from './catalog';
+import { environmentStatuses, environmentTally, groupTests } from './groups';
+import { explorerSearch, queryOf, toggled, values } from './search';
+import { testCatalog } from '@crvouga/atlas/reports/test-catalog';
+import type { EvidenceView } from '@crvouga/atlas/reports/evidence-view';
+
+function layer(id: string, environment: string, at: number, rows: Partial<LayerRow>[]): LayerEvidence {
+  const header: LayerHeader = {
+    id: id.padEnd(64, '0'), backend: 'local', producer: `p-${environment}`, packageDir: null, recordedAtMs: at, sha: 'a', branch: 'main', environment, runUrl: `run-${at}`,
+    parameters: {}, recording: null, live: false, counts: { passed: 0, failed: 0, running: 0, 'not-run': 0 }, execution: id
+  };
+  return {
+    id: header.id,
+    layer: header,
+    fingerprints: {},
+    rows: rows.map((row) => ({ kind: 'checks', id: 'x', title: 'X', status: 'passed', specPath: null, detail: '', measurements: [], testId: null, variant: {}, durationMs: null, ...row }))
+  };
+}
+
+const LAYERS = [
+  layer('a', 'api', 10, [
+    { id: 'find', title: 'Find', status: 'failed', specPath: 'specs/support/find.feature', durationMs: 100 },
+    { id: 'pay', title: 'Pay', status: 'passed', specPath: 'specs/billing/pay.feature', durationMs: 50 }
+  ]),
+  layer('b', 'desktop-web', 11, [{ id: 'find', title: 'Find', status: 'passed', specPath: 'specs/support/find.feature', durationMs: 900 }])
+];
+
+function model() {
+  const history = new TestHistory();
+  for (const entry of LAYERS) history.add(entry.layer, entry.rows);
+  return catalogModel(LAYERS, { history });
+}
+
+test('groups by spec in domain order, and by environment with each test counted by how it went there', () => {
+  const { tests } = testCatalog(model(), { limit: 100 });
+  const bySpec = groupTests(tests, 'spec');
+  expect(bySpec.map((group) => [group.parent, group.label])).toEqual([['billing', 'Pay'], ['support', 'Find']]);
+  const byEnv = groupTests(tests, 'environment');
+  const web = byEnv.find((group) => group.key === 'desktop-web')!;
+  expect(web.counts).toMatchObject({ passed: 1, failed: 0 });
+  expect(web.avgMs).toBe(900);
+  expect(byEnv.find((group) => group.key === 'api')!.counts).toMatchObject({ passed: 1, failed: 1 });
+  expect(environmentTally(tests, 'api').avgMs).toBe(75);
+  expect(groupTests(tests, 'status').map((group) => group.key)).toEqual(['failed', 'passed']);
+  const find = tests.find((test) => test.id === 'find')!;
+  expect(environmentStatuses(find)).toEqual([{ environment: 'api', status: 'failed' }, { environment: 'desktop-web', status: 'passed' }]);
+});
+
+test('a server catalog is queried like a model built in the page', () => {
+  const built = model();
+  const read = modelFromCatalog(testCatalog(built, { limit: 20_000 }));
+  expect(testCatalog(read, { q: 'billing' }).tests.map((test) => test.id)).toEqual(['pay']);
+  expect(testCatalog(read, { environment: ['desktop-web'] }).tests.map((test) => test.id)).toEqual(['find']);
+});
+
+test('live progress shows a test as running without rewriting recorded results', () => {
+  const built = model();
+  const pay = built.tests.find((test) => test.id === 'pay')!;
+  const view: EvidenceView = {
+    specs: new Map(),
+    unassigned: [
+      { key: pay.key, id: 'pay', title: 'Pay', specPath: pay.specPath, status: 'running', outcomes: [], diagnostics: [], latestAtMs: 20, live: true },
+      { key: JSON.stringify(['specs/new.feature', 'new']), id: 'new', title: 'New', specPath: 'specs/new.feature', status: 'running', outcomes: [], diagnostics: [], latestAtMs: 20, live: true }
+    ],
+    total: { status: 'none', counts: { passed: 0, failed: 0, running: 0, 'not-run': 0 }, total: 0, latestAtMs: 0 } as unknown as EvidenceView['total']
+  };
+  const live = withLiveProgress(built, view);
+  expect(live.byKey.get(pay.key)?.status).toBe('running');
+  expect(live.byKey.get(pay.key)?.outcomes).toEqual(pay.outcomes);
+  expect(live.tests.map((test) => test.id).sort()).toEqual(['find', 'new', 'pay']);
+  expect(live.summary.counts.running).toBe(2);
+  expect(withLiveProgress(built, { ...view, unassigned: [] })).toBe(built);
+});
+
+test('the address keeps filters as comma-separated text and drops what it cannot read', () => {
+  expect(explorerSearch({ q: 123, status: 'failed,flaky', group: 'nope', sort: 'slowest', test: ['specs/a.feature', 'a'] })).toEqual({
+    q: '123', status: 'failed,flaky', sort: 'slowest', test: JSON.stringify(['specs/a.feature', 'a'])
+  } as never);
+  expect(values(' api, desktop-web ,')).toEqual(['api', 'desktop-web']);
+  expect(toggled('api', 'ios')).toBe('api,ios');
+  expect(toggled('api', 'api')).toBeUndefined();
+  expect(queryOf({ env: 'api', status: 'failed' })).toMatchObject({ environment: ['api'], status: ['failed'], sort: 'spec' });
+});

package/packages/visualizer/src/explorer/groups.ts

@@ -0,0 +1,126 @@
+/**
+ * @module Explorer groups
+ *
+ * The explorer's list in groups (by spec, domain, environment, status or producer) with what each group's header says:
+ * how many tests, by current status, and their average duration. A test checked on two environments is in both
+ * environment groups. Groups keep the order of the sorted tests (the group holding the first test comes first), except
+ * when sorted by spec, where they are in domain and title order, and by status, where failures come first.
+ */
+import type { StatusCounts } from '@crvouga/atlas/reports/evidence-types';
+import type { EvidenceStatus } from '@crvouga/atlas/reports/explorer-types';
+import { environmentLabel } from '@crvouga/atlas/reports/layer-axes';
+import type { TestSummary } from '@crvouga/atlas/reports/test-catalog';
+
+import type { TestGroup } from './search';
+
+/** One group of tests and its tally. */
+export type TestGroupView = {
+  /** Stable within a grouping: what is remembered as open or closed. */
+  readonly key: string;
+  readonly label: string;
+  /** A second, quieter line: the spec's path. */
+  readonly detail: string | null;
+  /** The domain a spec group belongs to, for a heading above it. */
+  readonly parent: string | null;
+  /** What to filter by to see only this group: the filter and its value. */
+  readonly filter: { readonly field: 'spec' | 'domain' | 'env' | 'status' | 'producer'; readonly value: string } | null;
+  readonly tests: readonly TestSummary[];
+  readonly counts: StatusCounts;
+  /** The average of its tests' average durations, ms, or null when none was measured. */
+  readonly avgMs: number | null;
+};
+
+/** Order of statuses when grouping by status: what needs attention first. */
+export const STATUS_ORDER: readonly EvidenceStatus[] = ['failed', 'running', 'not-run', 'passed'];
+
+const NO_SPEC = '(no spec)';
+
+/** Counts by current status, and the mean of measured average durations. */
+export function tally(tests: readonly TestSummary[]): { counts: StatusCounts; avgMs: number | null } {
+  const counts: Record<EvidenceStatus, number> = { passed: 0, failed: 0, running: 0, 'not-run': 0 };
+  let total = 0, measured = 0;
+  for (const test of tests) {
+    counts[test.status] += 1;
+    if (test.stats.durations) { total += test.stats.durations.avgMs; measured += 1; }
+  }
+  return { counts, avgMs: measured ? Math.round(total / measured) : null };
+}
+
+/**
+ * The tally of one environment: each test counted by how it went there (a test failing on the API and passing on the
+ * web counts as passed for the web), and the mean of the durations of its current results there.
+ */
+export function environmentTally(tests: readonly TestSummary[], environment: string): { counts: StatusCounts; avgMs: number | null } {
+  const counts: Record<EvidenceStatus, number> = { passed: 0, failed: 0, running: 0, 'not-run': 0 };
+  let total = 0, measured = 0;
+  const env = environment === '(none)' ? null : environment;
+  for (const test of tests) {
+    const own = environmentStatuses(test).find((entry) => entry.environment === env);
+    counts[own?.status ?? test.status] += 1;
+    for (const outcome of test.outcomes) {
+      if (outcome.environment === env && outcome.durationMs !== null) { total += outcome.durationMs; measured += 1; }
+    }
+  }
+  return { counts, avgMs: measured ? Math.round(total / measured) : null };
+}
+
+type Keyed = { key: string; label: string; detail: string | null; parent: string | null; filter: TestGroupView['filter'] };
+
+function keysOf(test: TestSummary, by: TestGroup): Keyed[] {
+  switch (by) {
+    case 'spec':
+      return [test.spec
+        ? { key: test.spec.path, label: test.spec.title, detail: test.spec.path, parent: test.spec.domain || NO_SPEC, filter: { field: 'spec', value: test.spec.path } }
+        : { key: NO_SPEC, label: 'Tests without a spec', detail: null, parent: NO_SPEC, filter: null }];
+    case 'domain': {
+      const domain = test.spec?.domain || NO_SPEC;
+      return [{ key: domain, label: domain === NO_SPEC ? 'No spec' : domain, detail: null, parent: null, filter: { field: 'domain', value: domain } }];
+    }
+    case 'environment':
+      return test.environments.length
+        ? test.environments.map((env) => ({ key: env, label: environmentLabel(env), detail: env === environmentLabel(env) ? null : env, parent: null, filter: { field: 'env', value: env } }))
+        : [{ key: '(none)', label: 'No environment', detail: null, parent: null, filter: { field: 'env', value: '(none)' } }];
+    case 'status':
+      return [{ key: test.status, label: { passed: 'Passed', failed: 'Failed', running: 'Running', 'not-run': 'Not run' }[test.status], detail: null, parent: null, filter: { field: 'status', value: test.status } }];
+    case 'producer':
+      return test.producers.length
+        ? test.producers.map((producer) => ({ key: producer, label: producer, detail: null, parent: null, filter: { field: 'producer', value: producer } }))
+        : [{ key: '(none)', label: 'No producer', detail: null, parent: null, filter: null }];
+    case 'none':
+      return [{ key: 'all', label: 'All tests', detail: null, parent: null, filter: null }];
+  }
+}
+
+const text = (a: string, b: string) => (a < b ? -1 : a > b ? 1 : 0);
+
+/** The tests (already filtered and sorted) in groups. `bySpecOrder` keeps groups in domain and title order. */
+export function groupTests(tests: readonly TestSummary[], by: TestGroup, bySpecOrder = by === 'spec'): TestGroupView[] {
+  const groups = new Map<string, Keyed & { tests: TestSummary[] }>();
+  for (const test of tests) {
+    for (const keyed of keysOf(test, by)) {
+      const group = groups.get(keyed.key);
+      if (group) group.tests.push(test);
+      else groups.set(keyed.key, { ...keyed, tests: [test] });
+    }
+  }
+  let list = [...groups.values()];
+  if (by === 'status') list.sort((a, b) => STATUS_ORDER.indexOf(a.key as EvidenceStatus) - STATUS_ORDER.indexOf(b.key as EvidenceStatus));
+  else if (bySpecOrder && (by === 'spec' || by === 'domain')) {
+    const last = (value: string | null) => (value === NO_SPEC ? '￿' : (value ?? '').toLowerCase());
+    list = list.sort((a, b) => text(last(a.parent), last(b.parent)) || text(a.key === NO_SPEC ? '￿' : a.label.toLowerCase(), b.key === NO_SPEC ? '￿' : b.label.toLowerCase()));
+  }
+  return list.map((group) => ({ ...group, ...(by === 'environment' ? environmentTally(group.tests, group.key) : tally(group.tests)) }));
+}
+
+/** The worst current status per environment of a test, in the order its environments are listed. */
+export function environmentStatuses(test: TestSummary): { environment: string | null; status: EvidenceStatus }[] {
+  const rank: Record<EvidenceStatus, number> = { passed: 0, 'not-run': 1, running: 2, failed: 3 };
+  const seen = new Map<string | null, EvidenceStatus>();
+  for (const outcome of test.outcomes) {
+    const prior = seen.get(outcome.environment);
+    if (prior === undefined || rank[outcome.status] > rank[prior]) seen.set(outcome.environment, outcome.status);
+  }
+  // Live progress may say running where no recorded result does.
+  if (test.status === 'running' && ![...seen.values()].includes('running')) return [{ environment: null, status: 'running' }, ...[...seen].map(([environment, status]) => ({ environment, status }))];
+  return [...seen].map(([environment, status]) => ({ environment, status })).sort((a, b) => text(a.environment ?? '', b.environment ?? ''));
+}

package/packages/visualizer/src/explorer/navigate.ts

@@ -0,0 +1,36 @@
+/**
+ * @module Explorer navigation
+ *
+ * Changing what the explorer shows is changing the address of `/`: these helpers read and write the explorer's
+ * search parameters, keeping the rest of the address (the recorded run picked in the header) as it is.
+ */
+import { useNavigate, useSearch } from '@tanstack/react-router';
+import { useMemo } from 'react';
+
+import { explorerSearch, type ExplorerSearch } from './search';
+
+/** The explorer's search parameters, read from the address. */
+export function useExplorerSearch(): ExplorerSearch {
+  const raw = useSearch({ strict: false }) as Record<string, unknown>;
+  return useMemo(() => explorerSearch(raw), [raw]);
+}
+
+/** A change to the explorer's search: fields set to undefined are removed from the address. */
+export type ExplorerPatch = { -readonly [K in keyof ExplorerSearch]?: ExplorerSearch[K] | undefined };
+
+/** Returns `go(patch, { replace })`, which moves the explorer to the address with `patch` applied. */
+export function useExplorerNavigate() {
+  const navigate = useNavigate();
+  return (patch: ExplorerPatch, options: { replace?: boolean } = {}) =>
+    void navigate({
+      to: '/',
+      search: ((prev: Record<string, unknown>) => ({ ...prev, ...patch })) as never,
+      replace: options.replace ?? false,
+      resetScroll: false
+    });
+}
+
+/** The search of a link that applies `patch` to the current explorer address. */
+export function patched(patch: ExplorerPatch) {
+  return ((prev: Record<string, unknown>) => ({ ...prev, ...patch })) as never;
+}

package/packages/visualizer/src/explorer/parts.tsx

@@ -0,0 +1,59 @@
+/**
+ * @module Explorer parts
+ *
+ * Small pieces the explorer's list, its test detail and its runs view share: the project's title, a run's short name,
+ * the chips that say where a test ran and how it went there, and the badges for what its results carry.
+ */
+import { environmentLabel } from '@crvouga/atlas/reports/layer-axes';
+import type { TestSummary } from '@crvouga/atlas/reports/test-catalog';
+
+import { plural } from '../evidence/format';
+import { StatusMark } from '../evidence/marks';
+import { currentProject } from '../runtime';
+import styles from './explorer.module.css';
+import { environmentStatuses } from './groups';
+
+/** The project's name for its title: `?project=geviti-app` reads "Geviti App". */
+export function projectTitle(): string {
+  return currentProject()?.split('-').map((word) => (word[0]?.toUpperCase() ?? '') + word.slice(1)).join(' ') || 'Project reports';
+}
+
+/** A run key for a person: its CI run number, or `branch@sha` shortened. */
+export function runName(key: string): string {
+  const actions = /\/actions\/runs\/(\d+)/.exec(key);
+  if (actions) return `#${actions[1]}`;
+  if (/^https?:/.test(key)) return key.replace(/^https?:\/\//, '').slice(0, 40);
+  const [branch, sha] = key.split('@');
+  return [branch, sha?.slice(0, 7)].filter(Boolean).join(' @ ') || key;
+}
+
+/** Small badges for what a test's results carry: flaky, video, screenshots, a trace, steps. */
+export function Badges({ test }: { test: TestSummary }) {
+  const roles = test.evidence.roles;
+  const badges = [
+    test.stats.flaky ? { id: 'flaky', label: 'Flaky', title: test.stats.flakyReason } : null,
+    roles.includes('video') ? { id: 'video', label: 'Video', title: 'Has a video' } : null,
+    roles.includes('image') || roles.includes('screenshot') ? { id: 'image', label: 'Screenshots', title: 'Has screenshots' } : null,
+    roles.includes('trace') ? { id: 'trace', label: 'Trace', title: 'Has a trace' } : null,
+    test.evidence.steps > 0 ? { id: 'steps', label: plural(test.evidence.steps, 'step', 'steps'), title: 'Recorded steps' } : null,
+    test.live ? { id: 'live', label: 'Running now', title: 'A run is in progress' } : null
+  ].filter((badge): badge is { id: string; label: string; title: string } => badge !== null);
+  if (!badges.length) return null;
+  return <span className={styles.badges}>{badges.map((badge) => <span key={badge.id} data-badge={badge.id} title={badge.title}>{badge.label}</span>)}</span>;
+}
+
+/** Where a test ran and how it went there: one chip per environment. */
+export function EnvironmentChips({ test }: { test: TestSummary }) {
+  const environments = environmentStatuses(test);
+  if (!environments.length) return null;
+  return (
+    <span className={styles.envChips}>
+      {environments.map(({ environment, status }) => (
+        <span key={environment ?? 'none'} data-status={status} title={`${environmentLabel(environment)}: ${status}`}>
+          <StatusMark status={status} size={10} />
+          {environmentLabel(environment)}
+        </span>
+      ))}
+    </span>
+  );
+}

package/packages/visualizer/src/explorer/search.ts

@@ -0,0 +1,97 @@
+/**
+ * @module Explorer address
+ *
+ * Everything the test explorer shows is in the address of the `/` route, so a link reproduces the view: the open test,
+ * the words searched, the filters, the grouping, the order, and the Runs tab with the run opened in it. Filters that
+ * take several values are comma-separated (`status=failed,flaky`). Anything unreadable is dropped, never an error.
+ */
+import { TEST_SORTS, type TestQuery, type TestSort } from '@crvouga/atlas/reports/test-catalog';
+import { z } from 'zod/v4';
+
+/** How the explorer groups its tests. `spec` is the default. */
+export const TEST_GROUPS = ['spec', 'domain', 'environment', 'status', 'producer', 'none'] as const;
+/** One of {@link TEST_GROUPS}. */
+export type TestGroup = (typeof TEST_GROUPS)[number];
+
+/** A search value as text: the router reads `123` as a number and `["a"]` as an array, both of which are meant as text here. */
+const text = z
+  .preprocess((value) => (typeof value === 'number' || typeof value === 'boolean' ? String(value) : value !== null && typeof value === 'object' ? JSON.stringify(value) : value), z.string().min(1))
+  .optional()
+  .catch(undefined);
+
+/** The explorer's part of the `/` route's search: see the module comment. */
+export const ExplorerSearchFields = {
+  /** The open test, a `TestSummary.key`. */
+  test: text,
+  q: text,
+  status: text,
+  env: text,
+  producer: text,
+  domain: text,
+  spec: text,
+  tag: text,
+  /** Only the tests a CI run recorded (a `RunSummary.key`). Not `run`, which already names a recorded statechart run. */
+  inRun: text,
+  group: z.enum(TEST_GROUPS).optional().catch(undefined),
+  sort: z.enum(TEST_SORTS).optional().catch(undefined),
+  tab: z.enum(['runs']).optional().catch(undefined),
+  /** The run opened in the Runs tab. */
+  openRun: text
+};
+
+/** The explorer's search parameters as the route holds them. */
+export type ExplorerSearch = {
+  readonly test?: string;
+  readonly q?: string;
+  readonly status?: string;
+  readonly env?: string;
+  readonly producer?: string;
+  readonly domain?: string;
+  readonly spec?: string;
+  readonly tag?: string;
+  readonly inRun?: string;
+  readonly group?: TestGroup;
+  readonly sort?: TestSort;
+  readonly tab?: 'runs';
+  readonly openRun?: string;
+};
+
+/** The values of a comma-separated filter, empty when it is not set. */
+export function values(value: string | undefined): string[] {
+  return value ? value.split(',').map((item) => item.trim()).filter(Boolean) : [];
+}
+
+/** A list of values as one comma-separated parameter, or undefined (left out of the address) when empty. */
+export function joined(list: readonly string[]): string | undefined {
+  return list.length ? list.join(',') : undefined;
+}
+
+/** Adds a value to a comma-separated filter, or removes it when it is there. */
+export function toggled(value: string | undefined, item: string): string | undefined {
+  const list = values(value);
+  return joined(list.includes(item) ? list.filter((entry) => entry !== item) : [...list, item]);
+}
+
+/** The catalog query an address asks for, without the run (it is matched separately) and without paging. */
+export function queryOf(search: ExplorerSearch): TestQuery {
+  return {
+    ...(search.q ? { q: search.q } : {}),
+    status: values(search.status),
+    environment: values(search.env),
+    producer: values(search.producer),
+    domain: values(search.domain),
+    spec: values(search.spec),
+    tag: values(search.tag),
+    sort: search.sort ?? 'spec'
+  };
+}
+
+/** Only the explorer's own fields of a route's search, so other routes' parameters are not carried along. */
+export function explorerSearch(search: Record<string, unknown>): ExplorerSearch {
+  return z.object(ExplorerSearchFields).parse(search) as ExplorerSearch;
+}
+
+/** True when any filter or search narrows the list. */
+export function narrowed(search: ExplorerSearch): boolean {
+  return !!(search.q || search.status || search.env || search.producer || search.domain || search.spec || search.tag || search.inRun);
+}

package/packages/visualizer/src/find/Finder.tsx

@@ -209,6 +209,8 @@ export function Finder() {
         params: { kind },
         search: { run, spec: target.search.spec, check: target.search.check, view: target.search.view }
       });
+    } else if (target.to === '/' && target.search.test) {
+      void navigate({ to: '/', search: { run, test: target.search.test } });
     }
     setFinderOpen(false);
   };

package/packages/visualizer/src/find/corpus.ts

@@ -1,5 +1,5 @@
 import type { CheckSlot, EvidenceView } from '@crvouga/atlas/reports/evidence-view';
-import type { RunStatus } from '@crvouga/atlas/schema';
+import { isStatechartFile, type RunStatus } from '@crvouga/atlas/schema';
 
 import type { AtlasView, ItemStatus } from '../data/model';
 import { worstOf } from '../data/model/status';
@@ -65,6 +65,8 @@ export type CorpusSource = {
   readonly files: readonly CorpusFile[];
   readonly slots: readonly CorpusSlot[];
   readonly texts: ReadonlyMap<string, string>;
+  /** The project home is the test explorer (no statecharts): a check without a published spec opens there. */
+  readonly explorer?: boolean;
 };
 
 function itemStatus(status: ItemStatus): FindStatus {
@@ -128,7 +130,10 @@ function actionsIn(text: string): string[] {
   return [...new Set([...text.matchAll(ACTION)].map((match) => match[1]!))];
 }
 
-function runDoc(slot: CorpusSlot, title: string, kind: string | null, file: string): FindDoc {
+function runDoc(slot: CorpusSlot, title: string, kind: string | null, file: string, explorer = false): FindDoc {
+  if (explorer) {
+    return { id: `run:${slot.key}`, group: 'Runs', kind: 'run', title, subtitle: file, fields: fieldsOf(title, '', slot.detail, file), status: slot.status, related: [], target: { to: '/', search: { test: slot.key } }, recording: null };
+  }
   const recording = timelineTarget(kind, file, [slot]);
   return {
     id: `run:${slot.key}`,
@@ -222,11 +227,11 @@ export function buildCorpus(source: CorpusSource): FindDoc[] {
     }
   }
 
-  const pushRun = (slot: CorpusSlot, title: string, kind: string | null, file: string) => {
+  const pushRun = (slot: CorpusSlot, title: string, kind: string | null, file: string, explorer = false) => {
     const id = `run:${slot.key}`;
     if (seenRuns.has(id)) return;
     seenRuns.add(id);
-    docs.push(runDoc(slot, title, kind, file));
+    docs.push(runDoc(slot, title, kind, file, explorer));
   };
 
   for (const file of source.files) {
@@ -314,7 +319,8 @@ export function buildCorpus(source: CorpusSource): FindDoc[] {
 
   for (const slot of source.slots) {
     const file = slot.specPath ? specFile(slot.specPath) : '';
-    pushRun(slot, slot.title, file ? kindOfFile(file)?.id ?? null : null, file);
+    // Its spec was not published: in a project without statecharts the explorer has it, with everything recorded for it.
+    pushRun(slot, slot.title, file ? kindOfFile(file)?.id ?? null : null, file, source.explorer === true);
   }
   return docs;
 }
@@ -363,6 +369,7 @@ export function corpusFrom(view: AtlasView | null, files: readonly string[], tit
       : [],
     files: files.map((path) => ({ path, title: titleOf(path) })),
     slots,
-    texts
+    texts,
+    explorer: !files.some(isStatechartFile)
   });
 }

package/packages/visualizer/src/find/rank.ts

@@ -52,6 +52,8 @@ export type FindTarget = {
     readonly spec?: string;
     readonly check?: string;
     readonly view?: 'recording';
+    /** A test opened in the explorer of a project without statecharts (`TestSummary.key`). */
+    readonly test?: string;
   };
 };
 

package/packages/visualizer/src/evidence/project-home.tsx

@@ -1,45 +0,0 @@
-import { Link } from '@tanstack/react-router';
-import { lazy, Suspense, useState } from 'react';
-import { isStatechartFile } from '@crvouga/atlas/schema';
-import { useEvidence } from './evidence-context';
-import { CheckDetail, ResultRow, type CheckSelection } from './check-detail';
-import { TestFilter, useRunningFilter } from './test-filter';
-import { Bounded } from './marks';
-import { SPEC_KINDS, kindOfFile } from '../spec-kind';
-import { currentProject } from '../runtime';
-import styles from './evidence.module.css';
-const RecordingPage = lazy(() => import('./recording-page').then(module => ({ default: module.RecordingPage })));
-
-/** A project can contain any test runner or spec notation; statecharts are optional. */
-export function ProjectHome() {
-  const evidence = useEvidence();
-  const runningOnly = useRunningFilter();
-  const [selection, setSelection] = useState<CheckSelection>({});
-  const [selectedKey, setSelectedKey] = useState<string | null>(null);
-  const [recording, setRecording] = useState(false);
-  const [moment, setMoment] = useState<number | null>(null);
-  const kinds = SPEC_KINDS.map(kind => ({ kind, files: evidence.files.filter(kind.accepts) })).filter(entry => entry.files.length);
-  const checks = [...evidence.view.unassigned, ...[...evidence.view.specs].filter(([file]) => !kindOfFile(file) && !isStatechartFile(file)).flatMap(([, entry]) => entry.slots)];
-  const visible = checks.filter(slot => !runningOnly || slot.status === 'running');
-  return <article className={styles.page}>
-    <header className={styles.specHead}><h1 className={styles.title}>{currentProject()?.split('-').map(word => word[0]?.toUpperCase() + word.slice(1)).join(' ') || 'Project reports'}</h1></header>
-    {evidence.unavailable && <p role="alert" className={styles.notice}>{evidence.unavailable}</p>}
-    {kinds.length > 0 && <section className={styles.block}><h2 className={styles.blockTitle}>Specs</h2><ul className={styles.list}>{kinds.map(({ kind, files }) => <li key={kind.id}>
-      <Link className={styles.listRow} to="/specs/$kind" params={{ kind: kind.id }} search={{}}><strong>{kind.label}</strong><span>{files.length} {files.length === 1 ? kind.one : kind.many}</span></Link>
-    </li>)}</ul></section>}
-    {checks.length > 0 && <section className={styles.block}><h2 className={styles.blockTitle}>Tests</h2><TestFilter slots={checks} /><ul className={styles.results}>
-      <Bounded items={visible} size={40} more="More tests">{slot => <ResultRow key={slot.key} label={slot.title} slot={slot} open={selectedKey === slot.key} onToggle={() => { setSelectedKey(selectedKey === slot.key ? null : slot.key); setSelection({ check: slot.id }); setRecording(false); }}>
-        {recording ? <Suspense fallback={<p role="status">Loading the recording…</p>}><RecordingPage slot={slot} layerId={selection.layer} label={slot.title} back="Test report" moment={moment} onMoment={setMoment} onClose={() => setRecording(false)} /></Suspense>
-          : <CheckDetail slot={slot} layerId={selection.layer} reads="steps" select={patch => { setSelection({ check: patch.check ?? slot.id, layer: patch.layer ?? undefined }); if (patch.view === 'recording') { setRecording(true); setMoment(null); } }} />}
-      </ResultRow>}</Bounded>
-    </ul></section>}
-    {!kinds.length && !checks.length && <p className={styles.aside}>No reports yet. Publish tests and specs to this project to populate its report.</p>}
-  </article>;
-}
-
-export function ProjectSpecIndex() {
-  const { files } = useEvidence();
-  return <nav className={styles.index} aria-label="Project specs"><h2>Specs</h2><ul>{SPEC_KINDS.filter(kind => files.some(kind.accepts)).map(kind => <li key={kind.id}>
-    <Link className={styles.indexRow} to="/specs/$kind" params={{ kind: kind.id }} search={{}}>{kind.label}</Link>
-  </li>)}</ul></nav>;
-}