@crvouga/atlas 1.6.0 → 1.8.0

package/packages/visualizer/src/evidence/behavior-panel.tsx

@@ -6,12 +6,9 @@
  * record: run, environment, source, attempts). Also the coverage summary of the whole feature. A recording is always
  * labelled as illustrative evidence with its own status, provenance and revision; it never stands for approval.
  */
-import type { EvidenceHolder } from '@crvouga/atlas/reports/evidence-detail';
-import { isVideoAttachment } from '@crvouga/atlas/reports/evidence-detail';
 import { effectiveScope } from '@crvouga/atlas/reports/evidence-scope';
 import type { EvidenceResult } from '@crvouga/atlas/reports/layer-merge';
 import { environmentLabel } from '@crvouga/atlas/reports/layer-axes';
-import type { Attachment } from '@crvouga/atlas/schema';
 import { Alert, Badge, Box, Group, List, Paper, Stack, Tabs, Text, Title } from '@mantine/core';
 import { useMemo, type ReactNode } from 'react';
 
@@ -23,6 +20,7 @@ import { ScopeNotice } from './evidence-scope';
 import { plural, statusWord, useNow } from './format';
 import { exampleIndexFor, exampleRows, fillExample, type FeatureStep } from './gherkin';
 import { Origin, StatusMark } from './marks';
+import { outcomeHeadline, videosIn } from './outcome';
 
 /** The short, readable form of a spec fingerprint (`<length>:<hash>:<hash>`): its length and the start of its hash. */
 export function shortRevision(fingerprint: string): string {
@@ -80,19 +78,6 @@ function expectedSteps(steps: readonly FeatureStep[]): FeatureStep[] {
   return at < 0 ? [] : steps.slice(at);
 }
 
-function videosIn(holder: EvidenceHolder | undefined): Attachment[] {
-  if (!holder) return [];
-  const own = (holder.attachments ?? []).filter(isVideoAttachment);
-  return [
-    ...own,
-    ...(holder.steps ?? []).flatMap((step) => (step.attachments ?? []).filter(isVideoAttachment)),
-    ...(holder.attempts ?? []).flatMap((attempt) => [
-      ...(attempt.attachments ?? []).filter(isVideoAttachment),
-      ...(attempt.steps ?? []).flatMap((step) => (step.attachments ?? []).filter(isVideoAttachment))
-    ])
-  ];
-}
-
 /** The recording of one result, read only when this is on screen. */
 function Player({ result }: { result: EvidenceResult }) {
   const detail = useCheckDetail(result.layer, result.row);
@@ -171,6 +156,13 @@ export function BehaviorPanel({
   const steps = useMemo(() => (entry ? fillExample(scenario.steps, entry) : scenario.steps), [scenario, entry]);
   const expected = expectedSteps(steps);
   const named = example !== null && entry === null;
+  // The coverage state is the check's combined status; this says what the recording or result shown here recorded, apart from it.
+  const outcome =
+    subject && behavior.slot ? (
+      <Text component="div" fw={600} data-outcome-headline>
+        {outcomeHeadline({ layer: subject.layer, row: subject.row }, behavior.slot).text}
+      </Text>
+    ) : null;
   return (
     <Tabs
       defaultValue={start ?? (demo ? 'watch' : state === 'running' || behavior.slot?.live ? 'inspect' : 'read')}
@@ -190,6 +182,7 @@ export function BehaviorPanel({
               {COVERAGE[state].meaning}
             </Text>
           </Group>
+          {outcome}
           {example !== null && (
             <Text component="div" c="dimmed">
               Example: {example}
@@ -209,6 +202,7 @@ export function BehaviorPanel({
             <CoverageBadge state={state} />
             {behavior.representative && <Badge variant="outline">Representative demo</Badge>}
           </Group>
+          {outcome}
           {expected.length > 0 && (
             <Box component="section" aria-label="Expected outcome">
               <Title order={4} mb="xs">

package/packages/visualizer/src/evidence/check-detail.tsx

@@ -2,6 +2,7 @@ import { recordingPaths } from '@crvouga/atlas/reports/evidence-types';
 import { checkHistory, type CheckSlot, type HistoryEntry } from '@crvouga/atlas/reports/evidence-view';
 import { flattenFrames } from '@crvouga/atlas/reports/frames';
 import { environmentLabel } from '@crvouga/atlas/reports/layer-axes';
+import { boundaryOf, isProductLatency } from '@crvouga/atlas/reports/latency';
 import type { EvidenceResult } from '@crvouga/atlas/reports/layer-merge';
 import type { ReportStep, RunReport } from '@crvouga/atlas/reports/report-types';
 import { Accordion, Alert, Anchor, Box, Button, Code, Flex, Group, List, Stack, Table, Text, Title } from '@mantine/core';
@@ -9,12 +10,14 @@ import { useQuery } from '@tanstack/react-query';
 import { useMemo, useState, type ReactNode } from 'react';
 import { TestProgress, useTestProgress } from '../live/test-progress';
 import { reportJson } from './api';
-import { ResultEvidence } from './artifacts';
+import { ResultEvidence, useCheckDetail } from './artifacts';
 import { useEvidence } from './evidence-context';
 import { ago, duration, plural, statusWord, useNow } from './format';
 import type { FeatureExamples, FeatureStep } from './gherkin';
 import { Bounded, Origin, StatusMark } from './marks';
 import { ModelTrace } from './model-trace';
+import { OutcomeSummary } from './outcome-summary';
+import { failedReportStep, failedStep, recordOf, sourceLabels, type ResultRecord } from './outcome';
 import { recordedModelStates } from './quint';
 /** What the address says is open: a check, and optionally one particular layer's record of it. */
 export type CheckSelection = {
@@ -49,13 +52,6 @@ function environmentMarks(slot: CheckSlot) {
   if (seen.size < 2) return [];
   return [...seen].map(([id, status]) => ({ id, status }));
 }
-function outcomeName(outcome: EvidenceResult) {
-  const environment = outcome.layer.environment ? environmentLabel(outcome.layer.environment) : '';
-  const parameters = Object.entries(outcome.parameters)
-    .map(([name, value]) => `${name}: ${value}`)
-    .join(', ');
-  return [environment, parameters].filter(Boolean).join(' · ') || outcome.layer.producer;
-}
 export function ResultRow({
   label,
   slot,
@@ -93,7 +89,7 @@ export function ResultRow({
                   <Flex component="span" display="inline-flex" gap="xs" align="center" wrap="wrap">
                     {marks.map((mark) => (
                       <Text key={mark.id || 'unspecified'} data-status={mark.status} span inherit>
-                        {environmentLabel(mark.id || null)}
+                        {environmentLabel(mark.id || null)} {statusWord(mark.status).toLowerCase()}
                       </Text>
                     ))}
                   </Flex>
@@ -276,6 +272,14 @@ type Props = {
   pinned?: HistoryEntry;
   /** Choosing a run in the history always names its layer, even when that result is a current one, so the choice stays pinned. */
   pin?: boolean;
+  /** The layer id of the current source the address selected (without pinning a run). Used with `onSource`; otherwise the choice is local. */
+  source?: string;
+  /** Called with the layer id when a source is chosen (null for the newest), so the page can keep the choice in its address. */
+  onSource?: (layerId: string | null) => void;
+  /** Whether the outcome summary states its own heading. False when the page already shows it. */
+  headline?: boolean;
+  /** Every record of this check the page knows (a node's history of it), when the layers held here are only the winners. */
+  records?: readonly ResultRecord[];
 };
 /** Everything recorded for one check: the chosen result, how it went, and every other run of it. */
 export function CheckDetail(props: Props) {
@@ -306,16 +310,28 @@ export function CheckDetail(props: Props) {
     </>
   );
 }
-function RecordedCheckDetail({ slot, layerId, select, reads, written, pinned, pin }: Props) {
+function RecordedCheckDetail({ slot, layerId, select, reads, written, pinned, pin, source, onSource, headline = true, records }: Props) {
   const { evidence, backends, ready, pending } = useEvidence();
   const now = useNow();
   const [variant, setVariant] = useState(0);
   const history = useMemo(() => checkHistory(evidence, slot.specPath, slot.id), [evidence, slot.specPath, slot.id]);
-  const winner = slot.outcomes[Math.min(variant, slot.outcomes.length - 1)]!;
+  const sourceAt = onSource && source ? slot.outcomes.findIndex((outcome) => outcome.layer.id === source) : -1;
+  const index = Math.min(onSource ? Math.max(sourceAt, 0) : variant, slot.outcomes.length - 1);
+  const winner = slot.outcomes[index]!;
   const earlier = pinned ?? (layerId ? history.find((entry) => entry.layer.id === layerId) : undefined);
   const chosen: HistoryEntry = earlier ?? { layer: winner.layer, row: winner.row };
   const superseded = !slot.outcomes.some((outcome) => outcome.layer.id === chosen.layer.id);
   const { paths, report } = useRecordedReport(chosen);
+  const recorded = useCheckDetail(chosen.layer, chosen.row);
+  const point = useMemo(
+    () => (chosen.row.status === 'failed' ? (failedStep(recorded.data?.check.steps) ?? failedReportStep(report.data)) : undefined),
+    [chosen.row.status, recorded.data, report.data]
+  );
+  const labels = sourceLabels(slot.outcomes, now);
+  const choose = (at: number) => {
+    setVariant(at);
+    onSource?.(at === 0 ? null : slot.outcomes[at]!.layer.id);
+  };
   const moments = report.data ? flattenFrames(report.data.steps).length : 0;
   const timings = superseded ? [] : slot.diagnostics.filter((entry) => entry.layer.id === chosen.layer.id || slot.diagnostics.length === 1);
   const note = superseded ? 'An earlier result. A newer run replaced it in the combined report.' : qualification(winner.warning);
@@ -328,12 +344,32 @@ function RecordedCheckDetail({ slot, layerId, select, reads, written, pinned, pi
       : '';
   return (
     <Stack gap="sm" miw={0}>
+      <OutcomeSummary
+        slot={slot}
+        selected={chosen}
+        history={records && records.length > history.length ? records : history.map(recordOf)}
+        point={point}
+        detail={recorded.data}
+        now={now}
+        showHeadline={headline}
+        choose={(layer) => {
+          const at = slot.outcomes.findIndex((outcome) => outcome.layer.id === layer);
+          if (at >= 0) choose(at);
+          else select({ layer });
+        }}
+      />
       {slot.outcomes.length > 1 && !earlier && (
         <Flex role="group" aria-label="Environments" gap="xs" align="center" wrap="wrap">
-          {slot.outcomes.map((outcome, index) => (
-            <Button key={outcome.key} type="button" aria-pressed={index === variant} onClick={() => setVariant(index)} variant="light">
+          {slot.outcomes.map((outcome, at) => (
+            <Button
+              key={outcome.key}
+              type="button"
+              aria-pressed={at === index}
+              onClick={() => choose(at)}
+              variant="light"
+            >
               <StatusMark status={outcome.row.status} size={12} />
-              {outcomeName(outcome)}
+              {labels[at]!.text}
             </Button>
           ))}
         </Flex>
@@ -400,6 +436,14 @@ function RecordedCheckDetail({ slot, layerId, select, reads, written, pinned, pi
                   against an allowance of {measurement.limit} {measurement.unit}
                 </Text>
               )}
+              {isProductLatency(measurement) && (
+                <Text span inherit c="dimmed">
+                  {' '}
+                  · product latency, {boundaryOf(measurement).label}
+                  {boundaryOf(measurement).state === 'partial' && ` (partial: not ${boundaryOf(measurement).intended})`}
+                  {measurement.outcome !== undefined && measurement.outcome !== 'observed' && ` · ${measurement.outcome}: waited at least this long`}
+                </Text>
+              )}
             </Text>
           );
         })
@@ -410,7 +454,7 @@ function RecordedCheckDetail({ slot, layerId, select, reads, written, pinned, pi
           {moments > 0 && (
             <Button
               type="button"
-              onClick={() => select({ view: 'recording', check: slot.id, layer: earlier || variant > 0 ? chosen.layer.id : null })}
+              onClick={() => select({ view: 'recording', check: slot.id, layer: earlier || index > 0 ? chosen.layer.id : null })}
               variant="filled"
             >
               Open recording{' '}

package/packages/visualizer/src/evidence/outcome-summary.tsx

@@ -0,0 +1,208 @@
+/**
+ * @module Outcome summary
+ *
+ * What the selected result says, stated apart from the other current sources, and the failure explained before its
+ * raw output: the heading names the selected source's outcome and what the other scoped sources recorded (each one
+ * click away), whether the behavior was reached, the recorded expected and observed values, the closest video and
+ * step, the chronology of the source, and who is to blame, which stays unknown unless the producer declared it. The
+ * original diagnostics remain below, untouched.
+ */
+import type { CheckSlot, HistoryEntry } from '@crvouga/atlas/reports/evidence-view';
+import type { CheckDetail } from '@crvouga/atlas/reports/evidence-detail';
+import { effectiveScope, scopeBadges } from '@crvouga/atlas/reports/evidence-scope';
+import { Badge, Box, Button, Flex, List, Paper, Stack, Text, Title } from '@mantine/core';
+
+import { ago, duration, shortSha, statusWord } from './format';
+import { StatusMark } from './marks';
+import {
+  chronology,
+  failureNote,
+  outcomeHeadline,
+  passedAfterFailure,
+  recordOf,
+  type ResultRecord,
+  reachOf,
+  sourceLabels,
+  videosIn,
+  type FailurePoint
+} from './outcome';
+
+const BLAME: Record<string, string> = {
+  product: 'the product',
+  'test-harness': 'the test harness',
+  environment: 'the environment'
+};
+
+/**
+ * The outcome of the selected result in words, the other current sources beside it, and, for a failure, where and
+ * how it failed. `point` is the failed step found in the recording (undefined when none was recorded); `detail` is the
+ * check's full record, for its videos and scope. `choose` selects one of the other current sources; `showHeadline`
+ * is false when the page already shows the heading.
+ */
+export function OutcomeSummary({
+  slot,
+  selected,
+  history,
+  point,
+  detail,
+  now,
+  choose,
+  showHeadline = true
+}: {
+  slot: CheckSlot;
+  selected: HistoryEntry;
+  history: readonly ResultRecord[];
+  point: FailurePoint | undefined;
+  detail: CheckDetail | undefined;
+  now: number;
+  choose: (layerId: string) => void;
+  showHeadline?: boolean;
+}) {
+  const headline = outcomeHeadline(selected, slot);
+  const failed = selected.row.status === 'failed';
+  const reach = failed ? reachOf(point) : undefined;
+  const note = point?.note ?? failureNote(detail?.check.extensions);
+  const every = sourceLabels(slot.outcomes, now);
+  const labels = headline.others.map((outcome) => every[slot.outcomes.indexOf(outcome)]!);
+  const video = point?.videos[0] ?? videosIn(detail?.check)[0];
+  const scope = video ? effectiveScope(video.scope, detail?.check.scope, detail?.inheritedScope) : undefined;
+  const timeline = chronology(recordOf(selected), history);
+  return (
+    <Paper component="section" aria-label="Outcome summary" data-outcome={selected.row.status} withBorder p="md">
+      <Stack gap="sm" miw={0}>
+        {showHeadline && (
+          <Title order={3} data-outcome-headline>
+            {headline.text}
+          </Title>
+        )}
+        {headline.others.length > 0 && (
+          <Stack gap="xs" component="section" aria-label="Other current sources">
+            <Text component="div" c="dimmed">
+              Other current sources of this check
+            </Text>
+            <List listStyleType="none" spacing="xs">
+              {headline.others.map((outcome, index) => (
+                <List.Item key={outcome.key}>
+                  <Button type="button" variant="light" onClick={() => choose(outcome.layer.id)} aria-label={`Open ${labels[index]!.text}`}>
+                    <StatusMark status={outcome.row.status} size={12} />
+                    <Text span inherit>
+                      {labels[index]!.text}
+                    </Text>
+                  </Button>
+                </List.Item>
+              ))}
+            </List>
+          </Stack>
+        )}
+        {reach && (
+          <Flex gap="xs" align="center" wrap="wrap" data-reach={reach.state}>
+            <Badge variant={reach.state === 'setup-failed' ? 'filled' : 'light'} color={reach.state === 'unknown' ? 'gray' : 'red'}>
+              {reach.state === 'setup-failed'
+                ? 'Behavior not verified'
+                : reach.state === 'expectation-failed'
+                  ? 'Expectation not met'
+                  : 'Failure point unknown'}
+            </Badge>
+            <Text span inherit>
+              {reach.text}
+            </Text>
+          </Flex>
+        )}
+        {failed && (note?.expected !== undefined || note?.actual !== undefined) && (
+          <Box component="dl" aria-label="Expected and observed" m={0}>
+            {note?.expected !== undefined && (
+              <>
+                <Text component="dt" fw={600}>
+                  Expected
+                </Text>
+                <Text component="dd" m={0}>
+                  {note.expected}
+                </Text>
+              </>
+            )}
+            {note?.actual !== undefined && (
+              <>
+                <Text component="dt" fw={600}>
+                  Observed
+                </Text>
+                <Text component="dd" m={0}>
+                  {note.actual}
+                </Text>
+              </>
+            )}
+          </Box>
+        )}
+        {failed && (point || video) && (
+          <Stack gap="xs" component="section" aria-label="Closest evidence">
+            {point && (
+              <Text component="div">
+                Closest step:{' '}
+                <Text span inherit fw={600}>
+                  {point.name}
+                </Text>
+                {point.offsetMs !== undefined && (
+                  <Text span inherit c="dimmed">
+                    {' '}
+                    at {duration(point.offsetMs) || '0 ms'} into the check
+                  </Text>
+                )}
+              </Text>
+            )}
+            {video && (
+              <Text component="div">
+                Closest video:{' '}
+                <Text span inherit fw={600}>
+                  {video.description ?? video.name}
+                </Text>
+                <Text span inherit c="dimmed">
+                  {' '}
+                  {point?.videos.length ? 'attached to that step' : 'recorded for the whole check'}
+                  {' · '}
+                  {scopeBadges(scope)
+                    .map((badge) => badge.text)
+                    .join(', ')}
+                </Text>
+              </Text>
+            )}
+          </Stack>
+        )}
+        {failed && (
+          <Text component="div" c="dimmed" data-attribution={note?.attribution ?? 'unknown'}>
+            Cause:{' '}
+            {note?.attribution
+              ? `${BLAME[note.attribution]}, as declared by the producer`
+              : 'unknown. Nothing recorded says whether the product, the test harness or the environment is at fault.'}
+          </Text>
+        )}
+        {timeline.length > 0 && (
+          <Stack gap="xs" component="section" aria-label="Chronology of this source">
+            <Text component="div" c="dimmed">
+              Records of this source, oldest first
+            </Text>
+            <List listStyleType="none" spacing="xs" type="ordered">
+              {timeline.map(({ record, selected: current }) => (
+                <List.Item key={`${record.layer}|${record.kind}`} aria-current={current || undefined} data-status={record.status}>
+                  <Flex gap="xs" align="center" wrap="wrap">
+                    <StatusMark status={record.status} size={12} />
+                    <Text span inherit fw={current ? 600 : undefined}>
+                      {statusWord(record.status)}
+                    </Text>
+                    <Text span inherit c="dimmed">
+                      {ago(record.at, now)} · {shortSha(record.sha) ?? 'revision not recorded'}
+                      {current ? ' · selected' : ''}
+                    </Text>
+                  </Flex>
+                </List.Item>
+              ))}
+            </List>
+            {passedAfterFailure(timeline) && (
+              <Text component="div" role="status">
+                The latest run passed after an earlier failure. Nothing recorded shows that the failure was fixed or why it passed.
+              </Text>
+            )}
+          </Stack>
+        )}
+      </Stack>
+    </Paper>
+  );
+}

package/packages/visualizer/src/evidence/outcome.test.ts

@@ -0,0 +1,129 @@
+import type { LayerHeader, LayerRow } from '@crvouga/atlas/reports/evidence-types';
+import type { CheckSlot } from '@crvouga/atlas/reports/evidence-view';
+import type { EvidenceResult } from '@crvouga/atlas/reports/layer-merge';
+import { expect, test } from 'bun:test';
+
+import {
+  chronology,
+  failedStep,
+  failureNote,
+  outcomeHeadline,
+  passedAfterFailure,
+  phaseOf,
+  reachOf,
+  recordOf,
+  selectedResult,
+  sourceLabels,
+  type ResultRecord
+} from './outcome';
+
+const header = (id: string, at: number, extra: Partial<LayerHeader> = {}): LayerHeader => ({
+  id, backend: 'b', producer: 'p', packageDir: null, recordedAtMs: at, sha: null, branch: null, environment: 'desktop-web', runUrl: null,
+  parameters: {}, recording: null, live: false, counts: { passed: 0, failed: 0, running: 0, 'not-run': 0 }, execution: id, ...extra
+});
+const row = (status: LayerRow['status']): LayerRow => ({
+  kind: 'checks', id: 'x', title: 'X', status, specPath: null, detail: '', measurements: [], testId: null, variant: {}, durationMs: null
+});
+const result = (id: string, status: LayerRow['status'], extra: Partial<LayerHeader> = {}): EvidenceResult => ({
+  key: id, slot: 's', layer: header(id, 1, extra), parameters: {}, warning: null, row: row(status)
+});
+const slot = (status: CheckSlot['status'], outcomes: EvidenceResult[]): CheckSlot => ({
+  key: 's', id: 'x', title: 'X', specPath: null, status, outcomes, diagnostics: [], latestAtMs: 1, live: false
+});
+const entry = (r: EvidenceResult) => ({ layer: r.layer, row: r.row });
+
+test('the heading names the selected outcome before the other sources, and never reads it as the combined status', () => {
+  const passed = result('a', 'passed');
+  const failed = result('b', 'failed', { environment: 'api' });
+  const both = slot('failed', [passed, failed]);
+  expect(outcomeHeadline(entry(passed), both).text).toBe('Selected result passed; another scoped source failed');
+  expect(outcomeHeadline(entry(failed), both).text).toBe('Selected result failed; the other scoped source: 1 passed');
+  expect(outcomeHeadline(entry(passed), slot('passed', [passed])).text).toBe('Selected result passed');
+  expect(outcomeHeadline(entry(result('c', 'running')), slot('running', [result('c', 'running')])).text).toBe('Selected result is still running');
+  expect(outcomeHeadline(entry(passed), slot('failed', [passed, failed, result('d', 'failed')])).text).toContain('2 other scoped sources failed');
+});
+
+test('an earlier result says so and names what the combined report now shows', () => {
+  const current = result('new', 'passed');
+  const old = result('old', 'failed');
+  const headline = outcomeHeadline(entry(old), slot('passed', [current]));
+  expect(headline.current).toBe(false);
+  expect(headline.text).toBe('This earlier result failed; the combined report now shows passed across its current source');
+});
+
+test('the selected result is the pinned run, else the named source, else the newest', () => {
+  const a = result('a', 'passed');
+  const b = result('b', 'failed');
+  const both = slot('failed', [a, b]);
+  expect(selectedResult(both)?.layer.id).toBe('a');
+  expect(selectedResult(both, undefined, 'b')?.layer.id).toBe('b');
+  expect(selectedResult(both, undefined, 'unknown')?.layer.id).toBe('a');
+  expect(selectedResult(both, entry(b), 'a')?.layer.id).toBe('b');
+  expect(selectedResult(slot('passed', []))).toBeUndefined();
+});
+
+test('sources that share a name are told apart by status, revision and their place among them', () => {
+  const labels = sourceLabels(
+    [result('a', 'passed', { sha: 'b'.repeat(40), producer: 'one' }), result('b', 'failed', { sha: 'a'.repeat(40), producer: 'two' }), result('c', 'passed', { environment: 'api' })],
+    1_000
+  );
+  expect(labels.map((label) => label.text)).toEqual([
+    'Desktop web · Passed · just now · bbbbbbb · result 1 of 2 from one',
+    'Desktop web · Failed · just now · aaaaaaa · result 2 of 2 from two',
+    'Api · Passed · just now · revision not recorded'
+  ]);
+});
+
+test('the phase comes from the recorded kind, never from the wording', () => {
+  expect(phaseOf('hook')).toBe('setup');
+  expect(phaseOf('Given')).toBe('setup');
+  expect(phaseOf('then')).toBe('behavior');
+  expect(phaseOf('action')).toBe('unspecified');
+  expect(phaseOf(undefined)).toBe('unspecified');
+  const point = failedStep([{ name: 'setup failed to connect', status: 'failed', offsetMs: 0 }]);
+  expect(point?.phase).toBe('unspecified');
+  expect(reachOf(point).state).toBe('unknown');
+  expect(reachOf(undefined).state).toBe('unknown');
+  expect(reachOf(failedStep([{ name: 'Seed', kind: 'hook', status: 'failed' }])).state).toBe('setup-failed');
+  expect(reachOf(failedStep([{ name: 'Check', kind: 'assertion', status: 'failed' }])).state).toBe('expectation-failed');
+});
+
+test('the failed step is the first innermost one in time order', () => {
+  const point = failedStep([
+    { id: 'late', name: 'Late', status: 'failed', offsetMs: 900 },
+    { id: 'group', name: 'Group', status: 'failed', offsetMs: 100 },
+    { id: 'leaf', parentId: 'group', name: 'Leaf', status: 'failed', offsetMs: 150, detail: 'nope' },
+    { name: 'Fine', status: 'passed', offsetMs: 0 }
+  ]);
+  expect(point?.name).toBe('Leaf');
+  expect(point?.detail).toBe('nope');
+  expect(failedStep([{ name: 'ok', status: 'passed' }])).toBeUndefined();
+  expect(failedStep(undefined)).toBeUndefined();
+});
+
+test('only a producer-declared failure is read, and only a known attribution counts', () => {
+  expect(failureNote({ 'atlas.failure': { expected: 200, actual: { status: 500 }, attribution: 'environment' } })).toEqual({
+    expected: '200',
+    actual: '{"status":500}',
+    attribution: 'environment'
+  });
+  expect(failureNote({ 'atlas.failure': { attribution: 'the intern' } })).toBeUndefined();
+  expect(failureNote({ other: {} })).toBeUndefined();
+  expect(failureNote(undefined)).toBeUndefined();
+});
+
+test('a chronology is only told for one source whose outcome changed, oldest first, without declaring a cause', () => {
+  const record = (layer: string, status: ResultRecord['status'], at: number, env: string | null = 'desktop-web'): ResultRecord => ({
+    ...recordOf(entry(result(layer, status, { environment: env, recordedAtMs: at }))),
+    at
+  });
+  const early = record('1', 'failed', 100);
+  const late = record('2', 'passed', 200);
+  const timeline = chronology(late, [late, early, record('3', 'passed', 150, 'api')]);
+  expect(timeline.map((each) => each.record.layer)).toEqual(['1', '2']);
+  expect(timeline[1]!.selected).toBe(true);
+  expect(passedAfterFailure(timeline)).toBe(true);
+  expect(passedAfterFailure(chronology(early, [early, late]).slice().reverse())).toBe(false);
+  expect(chronology(late, [late])).toEqual([]);
+  expect(chronology(late, [late, record('4', 'passed', 50)])).toEqual([]);
+});