@crvouga/atlas 0.15.0 → 0.17.0

package/dist/reports/src/report-cli.js

@@ -43,6 +43,7 @@ export const REPORT_USAGE = `atlas report — layered evidence for any kind of s
                        [--param key=value]... [--kind <k>] [--title <t>] [--recorded-at <iso|ms>]
                        [--attach [role=]<file>]... [--label key=value]... [--link [name=]<url>]...
                        [--attach-root <dir>]... [--max-attachment-mb <n>] [--max-total-attachment-mb <n>]
+                       [--require-recordings]
   atlas report stream  [--store <dir|s3://…|https://atlas.example.com>] --producer <name> [--environment <name>]
                        [--branch <b>] [--sha <s>] [--run-url <u>] [--kind <k>] [--param key=value]...
                        [--run-id <id>] [--run-title <t>]
@@ -79,6 +80,10 @@ export const REPORT_USAGE = `atlas report — layered evidence for any kind of s
             Files a report names (CTRF attachments, JUnit [[ATTACHMENT|path]] lines) come from the report's own
             folder and each --attach-root, and never from a hidden file or a link out: a report is data from a
             test run, not instructions. One that is missing or not allowed is skipped with a warning.
+            --require-recordings   exit 1 when a check that declared recordingExpectation "required" has no
+                              uploaded video (absent, left out as too large or not allowed, or refused). The layer is
+                              still written and the checks keep their results; only this command fails. The receipt of
+                              what was uploaded (counts, sizes, checksums) is in the JSON result under layer.recordings.
             From a checkout with uncommitted changes the layer is marked "modified".
   stream    Send checks as they finish: one JSON object per line on standard input (the fields of one
             check: id, title, status, and any evidence). Each second's worth becomes one layer, so a server
@@ -310,7 +315,7 @@ export async function reportMain(argv, io = { out: text => process.stdout.write(
         const json = wantsJson(rest);
         const result = {
             ok: true, store: target.label,
-            layer: { id: layer.id, producer, environment: layer.environment ?? null, checks: ingested.checks.length, passed: counts.passed, failed: counts.failed, notRun: counts.other, linkedToSpec: linkedCount, ...(freshness ? { freshness } : {}), attachmentFiles: attachedFiles, attachmentBytes: attachedBytes },
+            layer: { id: layer.id, producer, environment: layer.environment ?? null, checks: ingested.checks.length, passed: counts.passed, failed: counts.failed, notRun: counts.other, linkedToSpec: linkedCount, ...(freshness ? { freshness } : {}), attachmentFiles: attachedFiles, attachmentBytes: attachedBytes, ...(layer.recordings ? { recordings: layer.recordings } : {}) },
             warnings: warnings.map(warning => `attachment skipped: ${warning}`)
         };
         if (!json)
@@ -318,6 +323,19 @@ export async function reportMain(argv, io = { out: text => process.stdout.write(
         if (!json)
             for (const warning of warnings)
                 io.out(`! attachment skipped: ${warning}\n`);
+        // Recording completeness is reported apart from the checks' results. Only --require-recordings turns a gap into a failing exit.
+        const gaps = (layer.recordings?.items ?? []).filter(item => item.state !== 'uploaded' && item.state !== 'referenced' && item.state !== 'not-applicable');
+        const strict = rest.includes('--require-recordings');
+        if (layer.recordings) {
+            result.recordings = { strict, complete: gaps.length === 0, expected: layer.recordings.expected, uploaded: layer.recordings.uploaded, gaps: gaps.map(({ check, state, reason }) => ({ check, state, ...(reason ? { reason } : {}) })) };
+            if (!json) {
+                io.out(`Recordings: ${layer.recordings.uploaded + layer.recordings.referenced} of ${layer.recordings.expected} expected published${layer.recordings.notApplicable ? `, ${layer.recordings.notApplicable} not applicable` : ''}\n`);
+                for (const gap of gaps)
+                    io.out(`! recording ${gap.state}: ${gap.check}${gap.reason ? ` (${gap.reason})` : ''}\n`);
+            }
+            if (strict && gaps.length)
+                result.ok = false;
+        }
         if (specsDirectory) {
             const files = await collectSpecFiles(path.resolve(base, specsDirectory));
             // A spec named with --spec that the directory does not hold (or whose kind is not a spec file) is published too.
@@ -343,7 +361,7 @@ export async function reportMain(argv, io = { out: text => process.stdout.write(
         }
         if (json)
             io.out(`${JSON.stringify(result, null, 2)}\n`);
-        return 0;
+        return result.ok ? 0 : 1;
     }
     if (command === 'stream') {
         const target = writeStoreOf(value(rest, 'store'), base, env);

package/dist/reports/src/report-status.d.ts

@@ -26,6 +26,8 @@ export type StatusOptions = {
  * each required environment with no checks (the name is normalised, so `iOS` means `ios`), then every notice of the
  * report (an unreadable layer or backend). `failing` lists each failed or running winner, in a fixed order that does
  * not depend on read order; diagnostic `performance` checks are left out unless nothing else was recorded.
+ * `recordings` reports recording completeness of the same results apart from `ok`: an incomplete or unknown
+ * completeness never changes the gate (use `atlas report publish --require-recordings` to fail on a missing video).
  *
  * @example
  * const status = reportStatus(await combineBackends(backends), { requireEnvironments: ['ios'] });

package/dist/reports/src/report-status.js

@@ -12,6 +12,7 @@ import { REPORT_STATUS_SCHEMA_VERSION } from '../../schema/src/layer.js';
 import { countResults } from './compose.js';
 import { normalizeEnvironment } from './layer-axes.js';
 import { isDiagnosticKind } from './layer-merge.js';
+import { recordingCompleteness } from './recording-receipt.js';
 /** Total string order by code unit. */
 const compare = (a, b) => (a < b ? -1 : a > b ? 1 : 0);
 /**
@@ -23,6 +24,8 @@ const compare = (a, b) => (a < b ? -1 : a > b ? 1 : 0);
  * each required environment with no checks (the name is normalised, so `iOS` means `ios`), then every notice of the
  * report (an unreadable layer or backend). `failing` lists each failed or running winner, in a fixed order that does
  * not depend on read order; diagnostic `performance` checks are left out unless nothing else was recorded.
+ * `recordings` reports recording completeness of the same results apart from `ok`: an incomplete or unknown
+ * completeness never changes the gate (use `atlas report publish --require-recordings` to fail on a missing video).
  *
  * @example
  * const status = reportStatus(await combineBackends(backends), { requireEnvironments: ['ios'] });
@@ -85,7 +88,12 @@ export function reportStatus(report, options = {}) {
             ...report.combined.specs.map(entry => specOutcome(entry.spec.path, entry.spec.title, entry.spec.kind, entry.results)),
             ...(report.combined.unassigned.length ? [specOutcome(null, 'No spec', 'unassigned', report.combined.unassigned)] : [])
         ],
-        failing
+        failing,
+        // Apart from `ok`: whether the expected videos were published says nothing about whether the checks passed.
+        recordings: recordingCompleteness(outcomes.map(result => ({
+            spec: result.row.specPath, check: result.row.id, environment: result.layer.environment, layer: result.layer.id,
+            hasReceipt: result.layer.recordings !== undefined, ...(result.row.recording ? { recording: result.row.recording } : {})
+        })))
     };
 }
 /** `spec › check`, unless the check's id already starts with its spec. */
@@ -120,6 +128,14 @@ export function formatStatusText(status) {
         const where = [item.environment, item.branch, item.sha?.slice(0, 7)].filter(Boolean).join(' · ');
         lines.push(`✗ ${item.status === 'running' ? '[running] ' : ''}${label(item)}${where ? `  (${where})` : ''}${item.detail ? `\n    ${item.detail.split('\n')[0]}` : ''}`);
     }
+    const recordings = status.recordings;
+    // Quiet for a report that never mentioned recordings; the JSON says `unknown` explicitly.
+    if (recordings && !(recordings.state === 'unknown' && recordings.expected === 0 && recordings.notApplicable === 0)) {
+        const published = recordings.uploaded + recordings.referenced;
+        lines.push(`· recordings: ${recordings.state} — ${published} of ${recordings.expected} expected published${recordings.notApplicable ? `, ${recordings.notApplicable} not applicable` : ''}${recordings.layersWithoutReceipt ? `, ${recordings.layersWithoutReceipt} layer${recordings.layersWithoutReceipt === 1 ? '' : 's'} unknown` : ''}`);
+        for (const gap of recordings.gaps)
+            lines.push(`  ! recording ${gap.state}: ${label({ spec: gap.spec, check: gap.check })}${gap.reason ? ` (${gap.reason})` : ''}`);
+    }
     for (const notice of status.notices)
         lines.push(`! ${notice}`);
     for (const reason of status.reasons)

package/dist/reports/src/reports-explorer-route.d.ts

@@ -82,6 +82,7 @@ export declare function createReportsExplorerApp(deps: ReportsExplorerDeps): imp
                         height?: number | undefined;
                         durationMs?: number | undefined;
                         description?: string | undefined;
+                        omitted?: string | undefined;
                         tags?: string[] | undefined;
                         at?: {
                             [x: string]: import("hono/utils/types").JSONValue;
@@ -126,6 +127,7 @@ export declare function createReportsExplorerApp(deps: ReportsExplorerDeps): imp
                                 height?: number | undefined;
                                 durationMs?: number | undefined;
                                 description?: string | undefined;
+                                omitted?: string | undefined;
                                 tags?: string[] | undefined;
                                 at?: {
                                     [x: string]: import("hono/utils/types").JSONValue;
@@ -183,6 +185,7 @@ export declare function createReportsExplorerApp(deps: ReportsExplorerDeps): imp
                             height?: number | undefined;
                             durationMs?: number | undefined;
                             description?: string | undefined;
+                            omitted?: string | undefined;
                             tags?: string[] | undefined;
                             at?: {
                                 [x: string]: import("hono/utils/types").JSONValue;
@@ -250,6 +253,7 @@ export declare function createReportsExplorerApp(deps: ReportsExplorerDeps): imp
                             height?: number | undefined;
                             durationMs?: number | undefined;
                             description?: string | undefined;
+                            omitted?: string | undefined;
                             tags?: string[] | undefined;
                             at?: {
                                 [x: string]: import("hono/utils/types").JSONValue;
@@ -356,6 +360,7 @@ export declare function createReportsExplorerApp(deps: ReportsExplorerDeps): imp
                             height?: number | undefined;
                             durationMs?: number | undefined;
                             description?: string | undefined;
+                            omitted?: string | undefined;
                             tags?: string[] | undefined;
                             at?: {
                                 [x: string]: import("hono/utils/types").JSONValue;
@@ -400,6 +405,7 @@ export declare function createReportsExplorerApp(deps: ReportsExplorerDeps): imp
                                     height?: number | undefined;
                                     durationMs?: number | undefined;
                                     description?: string | undefined;
+                                    omitted?: string | undefined;
                                     tags?: string[] | undefined;
                                     at?: {
                                         [x: string]: import("hono/utils/types").JSONValue;
@@ -457,6 +463,7 @@ export declare function createReportsExplorerApp(deps: ReportsExplorerDeps): imp
                                 height?: number | undefined;
                                 durationMs?: number | undefined;
                                 description?: string | undefined;
+                                omitted?: string | undefined;
                                 tags?: string[] | undefined;
                                 at?: {
                                     [x: string]: import("hono/utils/types").JSONValue;
@@ -524,6 +531,7 @@ export declare function createReportsExplorerApp(deps: ReportsExplorerDeps): imp
                                 height?: number | undefined;
                                 durationMs?: number | undefined;
                                 description?: string | undefined;
+                                omitted?: string | undefined;
                                 tags?: string[] | undefined;
                                 at?: {
                                     [x: string]: import("hono/utils/types").JSONValue;

package/dist/reports/src/reports-route.d.ts

@@ -120,6 +120,7 @@ export declare function createReportsApp(deps: ReportsAppDeps): import("hono/hon
                         height?: number | undefined;
                         durationMs?: number | undefined;
                         description?: string | undefined;
+                        omitted?: string | undefined;
                         tags?: string[] | undefined;
                         at?: {
                             [x: string]: import("hono/utils/types").JSONValue;
@@ -164,6 +165,7 @@ export declare function createReportsApp(deps: ReportsAppDeps): import("hono/hon
                                 height?: number | undefined;
                                 durationMs?: number | undefined;
                                 description?: string | undefined;
+                                omitted?: string | undefined;
                                 tags?: string[] | undefined;
                                 at?: {
                                     [x: string]: import("hono/utils/types").JSONValue;
@@ -221,6 +223,7 @@ export declare function createReportsApp(deps: ReportsAppDeps): import("hono/hon
                             height?: number | undefined;
                             durationMs?: number | undefined;
                             description?: string | undefined;
+                            omitted?: string | undefined;
                             tags?: string[] | undefined;
                             at?: {
                                 [x: string]: import("hono/utils/types").JSONValue;
@@ -288,6 +291,7 @@ export declare function createReportsApp(deps: ReportsAppDeps): import("hono/hon
                             height?: number | undefined;
                             durationMs?: number | undefined;
                             description?: string | undefined;
+                            omitted?: string | undefined;
                             tags?: string[] | undefined;
                             at?: {
                                 [x: string]: import("hono/utils/types").JSONValue;
@@ -394,6 +398,7 @@ export declare function createReportsApp(deps: ReportsAppDeps): import("hono/hon
                             height?: number | undefined;
                             durationMs?: number | undefined;
                             description?: string | undefined;
+                            omitted?: string | undefined;
                             tags?: string[] | undefined;
                             at?: {
                                 [x: string]: import("hono/utils/types").JSONValue;
@@ -438,6 +443,7 @@ export declare function createReportsApp(deps: ReportsAppDeps): import("hono/hon
                                     height?: number | undefined;
                                     durationMs?: number | undefined;
                                     description?: string | undefined;
+                                    omitted?: string | undefined;
                                     tags?: string[] | undefined;
                                     at?: {
                                         [x: string]: import("hono/utils/types").JSONValue;
@@ -495,6 +501,7 @@ export declare function createReportsApp(deps: ReportsAppDeps): import("hono/hon
                                 height?: number | undefined;
                                 durationMs?: number | undefined;
                                 description?: string | undefined;
+                                omitted?: string | undefined;
                                 tags?: string[] | undefined;
                                 at?: {
                                     [x: string]: import("hono/utils/types").JSONValue;
@@ -562,6 +569,7 @@ export declare function createReportsApp(deps: ReportsAppDeps): import("hono/hon
                                 height?: number | undefined;
                                 durationMs?: number | undefined;
                                 description?: string | undefined;
+                                omitted?: string | undefined;
                                 tags?: string[] | undefined;
                                 at?: {
                                     [x: string]: import("hono/utils/types").JSONValue;

package/dist/reports/src/test-catalog.d.ts

@@ -1,5 +1,5 @@
 import type { EvidenceStatus, SpecEntry } from './explorer-types.js';
-import type { EvidenceSummary, LayerEvidence, LayerHeader, LayerRow, StatusCounts } from './evidence-types.js';
+import type { EvidenceSummary, LayerEvidence, LayerHeader, LayerRow, StatusCounts, VideoCounts, VideoRef } from './evidence-types.js';
 import { RecordedSpecs } from './recorded-specs.js';
 /** The version of the documents this module writes (`TestCatalog`, `TestHistoryDocument`, `RunList`, `RunDetail`). Only optional fields are added within it. */
 export declare const TEST_CATALOG_VERSION = 1;
@@ -258,13 +258,26 @@ export type RunSummary = {
         readonly environment: string | null;
         readonly detail: string;
     }[];
+    /**
+     * Its videos, from the run's layers and from the last result of each test: references, distinct playable recordings
+     * and references that cannot be played. Absent when it has none, and in a report that carries no video information.
+     */
+    readonly videos?: VideoCounts;
+};
+/** What `runList` can be asked. */
+export type RunQuery = {
+    /** Only runs that have at least one playable video recording. `total` then counts only those. */
+    readonly video?: boolean;
 };
 /** `GET /api/reports/runs`: runs, newest first. */
 export type RunList = {
     readonly schemaVersion: typeof TEST_CATALOG_VERSION;
     readonly version: string;
+    /** Runs that matched, before `limit`. */
     readonly total: number;
     readonly runs: readonly RunSummary[];
+    /** How many of all runs (whatever was asked, before `limit`) have a playable video recording. */
+    readonly withVideo?: number;
 };
 /** One test's last result within one run. */
 export type RunResult = {
@@ -279,6 +292,8 @@ export type RunResult = {
     readonly at: number;
     readonly layer: string;
     readonly detail: string;
+    /** Every video its evidence references, with who holds it (check, retry attempt or step). Absent when there is none. */
+    readonly videos?: readonly VideoRef[];
 };
 /** `GET /api/reports/runs/detail`: one run and every result it recorded. */
 export type RunDetail = {
@@ -380,8 +395,14 @@ export declare function matchesQuery(model: CatalogModel, test: TestSummary, que
 export declare function testCatalog(model: CatalogModel, query?: TestQuery): TestCatalog;
 /** One test and its recorded results, or null when the report has no test with that key. */
 export declare function testHistory(model: CatalogModel, key: string): TestHistoryDocument | null;
-/** Every run the history knows of, newest first, `limit` at most (default 100). */
-export declare function runList(history: TestHistory, version: string, limit?: number): RunList;
+/** Whether a run has at least one playable video recording. */
+export declare function hasVideo(run: Pick<RunSummary, 'videos'>): boolean;
+/**
+ * Every run the history knows of, newest first, `limit` at most (default 100). With `query.video` only the runs that
+ * have a playable video recording: the filter and `total` apply to every run before `limit`, and nothing is read from
+ * any recording's bytes. `withVideo` always counts every run that has one.
+ */
+export declare function runList(history: TestHistory, version: string, limit?: number, query?: RunQuery): RunList;
 /** One run with every result it recorded, or null when no run has that key. */
 export declare function runDetail(history: TestHistory, version: string, key: string): RunDetail | null;
 /** Reads a `TestQuery` from URL search parameters: `q`, `sort`, `offset`, `limit`, `run`, and repeatable or comma-separated `status`, `environment`, `producer`, `domain`, `spec`, `tag`, `artifactTag`, and `inherited=1`. */

package/dist/reports/src/test-catalog.js

@@ -21,6 +21,7 @@
  * @see docs/server.md#reading-the-report-as-an-agent
  */
 import { displayTag, normalizeTag, normalizeTags } from './artifact-tags.js';
+import { videoCounts } from './evidence-detail.js';
 import { checkSlots } from './evidence-view.js';
 import { combineEvidence, emptyCounts, slotKey, specPath as normalSpecPath } from './layer-merge.js';
 import { RecordedSpecs } from './recorded-specs.js';
@@ -126,7 +127,7 @@ export class TestHistory {
         const key = runKey(layer);
         let run = this.#runs.get(key);
         if (!run) {
-            run = { key, runUrl: layer.runUrl, branch: layer.branch, sha: layer.sha, start: layer.recordedAtMs, end: layer.recordedAtMs, firstAt: layer.recordedAtMs, first: layer.id, producers: new Set(), environments: new Set(), layers: 0, runId: layer.run?.id, title: undefined, titledAt: 0, titledBy: '', freshness: undefined };
+            run = { key, runUrl: layer.runUrl, branch: layer.branch, sha: layer.sha, start: layer.recordedAtMs, end: layer.recordedAtMs, firstAt: layer.recordedAtMs, first: layer.id, producers: new Set(), environments: new Set(), layers: 0, runId: layer.run?.id, title: undefined, titledAt: 0, titledBy: '', freshness: undefined, videos: [] };
             this.#runs.set(key, run);
         }
         // A run is told by its first layer (by time, then id), whatever order its layers arrive in.
@@ -153,6 +154,8 @@ export class TestHistory {
         if (layer.environment)
             run.environments.add(layer.environment);
         run.layers += 1;
+        if (layer.evidence?.videos)
+            run.videos.push(...layer.evidence.videos);
         const origin = originOf(layer, backend);
         for (const row of rows) {
             // "Still running" is progress, not history: a test running now shows it as its current outcome.
@@ -240,6 +243,7 @@ export class TestHistory {
         const results = cells.map(({ i, r }) => ({
             key: i.slot, id: i.id, title: i.title, specPath: i.specPath, environment: r.o.environment, producer: r.o.producer,
             status: r.s, durationMs: r.d, at: r.o.at, layer: r.o.layer, detail: shortDetail(r.t),
+            ...(r.e?.videos ? { videos: r.e.videos } : {}),
         }));
         results.sort((a, b) => FAILURE_RANK[b.status] - FAILURE_RANK[a.status] || compareText(a.specPath ?? '', b.specPath ?? '') || compareText(a.title, b.title) || compareText(a.environment ?? '', b.environment ?? '') || compareText(a.producer, b.producer) || compareText(a.key, b.key));
         return { run: runSummary(run, cells), results };
@@ -254,7 +258,10 @@ function runSummary(run, cells) {
     const tests = new Set();
     let total = 0, measured = false;
     const failed = [];
+    const videos = [...run.videos];
     for (const cell of cells) {
+        if (cell.r.e?.videos)
+            videos.push(...cell.r.e.videos);
         counts[cell.r.s] += 1;
         tests.add(cell.i.slot);
         if (cell.r.d !== null) {
@@ -265,6 +272,7 @@ function runSummary(run, cells) {
             failed.push(cell);
     }
     failed.sort((a, b) => compareText(a.i.slot, b.i.slot) || compareText(a.r.o.place, b.r.o.place) || compareText(a.r.k, b.r.k));
+    const video = videoCounts(videos);
     const failing = failed.slice(0, 20).map(cell => ({ key: cell.i.slot, title: cell.i.title, environment: cell.r.o.environment, detail: (cell.r.t.split('\n')[0] ?? '').slice(0, 500) }));
     return {
         key: run.key, ...(run.runId ? { runId: run.runId } : {}), ...(run.title ? { title: run.title } : {}), ...(run.freshness ? { freshness: run.freshness } : {}),
@@ -272,6 +280,7 @@ function runSummary(run, cells) {
         startedAtMs: run.start, endedAtMs: run.end, spanMs: run.end - run.start,
         producers: [...run.producers].sort(), environments: [...run.environments].sort(),
         layers: run.layers, tests: tests.size, counts, totalDurationMs: measured ? total : null, failing,
+        ...(video ? { videos: video } : {}),
     };
 }
 function compareText(a, b) {
@@ -571,10 +580,20 @@ export function testHistory(model, key) {
         return null;
     return { schemaVersion: TEST_CATALOG_VERSION, version: model.version, test, history: model.history?.of(key) ?? test.outcomes };
 }
-/** Every run the history knows of, newest first, `limit` at most (default 100). */
-export function runList(history, version, limit = 100) {
-    const runs = history.runs();
-    return { schemaVersion: TEST_CATALOG_VERSION, version, total: runs.length, runs: runs.slice(0, Math.max(0, limit)) };
+/** Whether a run has at least one playable video recording. */
+export function hasVideo(run) {
+    return (run.videos?.recordings ?? 0) > 0;
+}
+/**
+ * Every run the history knows of, newest first, `limit` at most (default 100). With `query.video` only the runs that
+ * have a playable video recording: the filter and `total` apply to every run before `limit`, and nothing is read from
+ * any recording's bytes. `withVideo` always counts every run that has one.
+ */
+export function runList(history, version, limit = 100, query = {}) {
+    const all = history.runs();
+    const withVideo = all.filter(hasVideo).length;
+    const runs = query.video ? all.filter(hasVideo) : all;
+    return { schemaVersion: TEST_CATALOG_VERSION, version, total: runs.length, runs: runs.slice(0, Math.max(0, limit)), withVideo };
 }
 /** One run with every result it recorded, or null when no run has that key. */
 export function runDetail(history, version, key) {
@@ -687,6 +706,12 @@ export function historyMarkdown(document) {
         ...document.history.map(e => `| ${iso(e.at)} | ${e.environment ?? '—'} | ${e.status} | ${formatMs(e.durationMs)} | ${cell(e.branch ?? '—')} | ${e.sha?.slice(0, 10) ?? '—'} | ${cell(e.detail.split('\n')[0] ?? '')} |`),
     ].join('\n')}\n`;
 }
+/** Video counts in a few words: `2 (3 references)`, with how many cannot be played, or `—` when there are none. */
+function videosText(videos) {
+    if (!videos)
+        return '—';
+    return `${videos.recordings}${videos.references !== videos.recordings ? ` (${videos.references} references)` : ''}${videos.unavailable ? `, ${videos.unavailable} unavailable` : ''}`;
+}
 /** What to say beside a commit that was not recorded from a clean checkout: nothing, ` (modified)` or ` (origin unknown)`. */
 function freshnessNote(freshness) {
     return freshness === 'modified' ? ' (modified: local changes)' : freshness === 'unknown' ? ' (origin unknown)' : '';
@@ -696,9 +721,9 @@ export function runsMarkdown(list) {
     return `${[
         `# Runs (${list.runs.length} of ${list.total})`,
         '',
-        '| Ended | Branch | Commit | Environments | Tests | Passed | Failed | Not run | Span | Run |',
-        '|---|---|---|---|---:|---:|---:|---:|---:|---|',
-        ...list.runs.map(r => `| ${iso(r.endedAtMs)} | ${cell(r.branch ?? '—')} | ${r.sha?.slice(0, 10) ?? '—'}${freshnessNote(r.freshness)} | ${r.environments.join(', ') || '—'} | ${r.tests} | ${r.counts.passed} | ${r.counts.failed} | ${r.counts['not-run']} | ${formatMs(r.spanMs)} | ${cell(r.title ? `${r.title} (${r.key})` : r.key)} |`),
+        '| Ended | Branch | Commit | Environments | Tests | Passed | Failed | Not run | Span | Videos | Run |',
+        '|---|---|---|---|---:|---:|---:|---:|---:|---|---|',
+        ...list.runs.map(r => `| ${iso(r.endedAtMs)} | ${cell(r.branch ?? '—')} | ${r.sha?.slice(0, 10) ?? '—'}${freshnessNote(r.freshness)} | ${r.environments.join(', ') || '—'} | ${r.tests} | ${r.counts.passed} | ${r.counts.failed} | ${r.counts['not-run']} | ${formatMs(r.spanMs)} | ${videosText(r.videos)} | ${cell(r.title ? `${r.title} (${r.key})` : r.key)} |`),
     ].join('\n')}\n`;
 }
 /** One run as Markdown. */
@@ -712,9 +737,10 @@ export function runMarkdown(detail) {
         `- ${iso(run.startedAtMs)} to ${iso(run.endedAtMs)} (${formatMs(run.spanMs)}); ${run.layers} layers from ${run.producers.join(', ')}`,
         `- Environments: ${run.environments.join(', ') || '—'}`,
         `- ${run.tests} tests: ${counted(run.counts)}${run.totalDurationMs === null ? '' : `; ${formatMs(run.totalDurationMs)} of test time`}`,
+        ...(run.videos ? [`- Videos: ${videosText(run.videos)}`] : []),
         '',
-        '| Status | Test | Spec | Environment | Duration | Detail |',
-        '|---|---|---|---|---:|---|',
-        ...detail.results.map(r => `| ${r.status} | ${cell(r.title)} | ${cell(r.specPath ?? '—')} | ${r.environment ?? '—'} | ${formatMs(r.durationMs)} | ${cell(r.detail.split('\n')[0] ?? '')} |`),
+        '| Status | Test | Spec | Environment | Duration | Videos | Detail |',
+        '|---|---|---|---|---:|---|---|',
+        ...detail.results.map(r => `| ${r.status} | ${cell(r.title)} | ${cell(r.specPath ?? '—')} | ${r.environment ?? '—'} | ${formatMs(r.durationMs)} | ${videosText(videoCounts(r.videos))} | ${cell(r.detail.split('\n')[0] ?? '')} |`),
     ].join('\n')}\n`;
 }