@crvouga/atlas 1.17.0 → 1.18.0

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

@@ -23,7 +23,8 @@
  * @see docs/server.md#reading-the-report-as-an-agent
  */
 import { displayTag, normalizeTag, normalizeTags } from './artifact-tags.js';
-import { facetsOf, forRuns, labelList, matchesFilter, outcomeOfCounts, splitList, usedFilters } from './artifact-query.js';
+import { facetsOf, forArtifacts, forRuns, labelList, matchesFilter, outcomeOfCounts, splitList, usedFilters } from './artifact-query.js';
+import { runRecordings } from './recording-receipt.js';
 import { videoCounts } from './evidence-detail.js';
 import { productLatency } from './latency.js';
 import { matchesScope, scopeTokens, UNKNOWN_SCOPE } from './evidence-scope.js';
@@ -148,7 +149,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, videos: [], attachments: 0, members: [], evidence: { tags: new Set(), artifactTags: new Set(), roles: new Set(), labels: new Set() } };
+            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: [], receipts: [], attachments: 0, members: [], evidence: { tags: new Set(), artifactTags: new Set(), roles: new Set(), labels: new Set() } };
             this.#runs.set(key, run);
         }
         // A run is told by its first layer (by time, then id), whatever order its layers arrive in.
@@ -177,6 +178,7 @@ export class TestHistory {
         run.layers += 1;
         if (layer.evidence?.videos)
             run.videos.push(...layer.evidence.videos);
+        run.receipts.push(layer.recordings);
         const held = layer.evidence?.attachments ?? 0;
         run.attachments += held;
         const layerVideos = videoCounts(layer.evidence?.videos);
@@ -376,6 +378,7 @@ function runSummary(run, cells) {
     }
     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 recordings = runRecordings(run.receipts);
     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 } : {}),
@@ -384,6 +387,7 @@ function runSummary(run, cells) {
         producers: [...run.producers].sort(), environments: [...run.environments].sort(),
         layers: run.layers, tests: tests.size, counts, totalDurationMs: measured ? total : null, failing,
         ...(video ? { videos: video } : {}),
+        ...(recordings ? { recordings } : {}),
         ...(run.attachments ? { attachments: run.attachments } : {}),
         ...(carried.artifactTags.size ? { artifactTags: [...carried.artifactTags].sort() } : {}),
         ...(carried.roles.size ? { types: typesOf(carried.roles, (video?.recordings ?? 0) > 0) } : {}),
@@ -737,7 +741,7 @@ export function fieldsOfRun(run) {
         text: [run.title ?? '', run.key, run.branch ?? '', run.sha ?? '', ...run.producers, ...run.environments, ...artifactTags, ...(run.tags ?? []), ...labels].join('\n').toLowerCase(),
         artifactTags, tags: [...new Set([...(run.tags ?? []), ...artifactTags])], types, media: types.map(type => ({ type, tags: artifactTags })), labels,
         environments: run.environments, producers: run.producers, branches: run.branch ? [run.branch] : [], shas: run.sha ? [run.sha.toLowerCase()] : [],
-        outcomes: [outcomeOfCounts(run.counts)], at: run.endedAtMs,
+        outcomes: [outcomeOfCounts(run.counts)], recordings: [run.recordings?.state ?? 'unknown'], at: run.endedAtMs,
     };
 }
 /**
@@ -752,7 +756,9 @@ export function fieldsOfRun(run) {
  * list.results.map(r => [r.title, r.run, r.sha, r.status]);
  * ```
  */
-export function artifactList(history, version, query = {}, page = {}) {
+export function artifactList(history, version, asked = {}, page = {}) {
+    // Recording completeness is a property of a run: a recorded result is not asked about it.
+    const query = forArtifacts(asked);
     const domains = new Map();
     const domainOf = (path) => {
         if (path === null)

package/dist/schema/src/api.d.ts

@@ -90,6 +90,7 @@ export declare const VideoRefSchema: z.ZodObject<{
     tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
     recording: z.ZodOptional<z.ZodString>;
     available: z.ZodBoolean;
+    reason: z.ZodOptional<z.ZodString>;
     scope: z.ZodOptional<z.ZodObject<{
         surface: z.ZodOptional<z.ZodString>;
         deviceKind: z.ZodOptional<z.ZodString>;
@@ -115,6 +116,7 @@ export declare const VideoCountsSchema: z.ZodObject<{
     references: z.ZodNumber;
     recordings: z.ZodNumber;
     unavailable: z.ZodNumber;
+    missing: z.ZodOptional<z.ZodNumber>;
 }, z.core.$loose>;
 /** What a result carries beyond its outcome, as counts and short facts. Present only when there is something. */
 export declare const EvidenceSummarySchema: z.ZodObject<{
@@ -141,6 +143,7 @@ export declare const EvidenceSummarySchema: z.ZodObject<{
         tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
         recording: z.ZodOptional<z.ZodString>;
         available: z.ZodBoolean;
+        reason: z.ZodOptional<z.ZodString>;
         scope: z.ZodOptional<z.ZodObject<{
             surface: z.ZodOptional<z.ZodString>;
             deviceKind: z.ZodOptional<z.ZodString>;
@@ -217,6 +220,7 @@ export declare const LayerHeaderSchema: z.ZodObject<{
             tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
             recording: z.ZodOptional<z.ZodString>;
             available: z.ZodBoolean;
+            reason: z.ZodOptional<z.ZodString>;
             scope: z.ZodOptional<z.ZodObject<{
                 surface: z.ZodOptional<z.ZodString>;
                 deviceKind: z.ZodOptional<z.ZodString>;
@@ -304,6 +308,7 @@ export declare const LayerRowSchema: z.ZodObject<{
             tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
             recording: z.ZodOptional<z.ZodString>;
             available: z.ZodBoolean;
+            reason: z.ZodOptional<z.ZodString>;
             scope: z.ZodOptional<z.ZodObject<{
                 surface: z.ZodOptional<z.ZodString>;
                 deviceKind: z.ZodOptional<z.ZodString>;
@@ -409,6 +414,7 @@ export declare const LayerRowsSchema: z.ZodObject<{
                 tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
                 recording: z.ZodOptional<z.ZodString>;
                 available: z.ZodBoolean;
+                reason: z.ZodOptional<z.ZodString>;
                 scope: z.ZodOptional<z.ZodObject<{
                     surface: z.ZodOptional<z.ZodString>;
                     deviceKind: z.ZodOptional<z.ZodString>;
@@ -516,6 +522,7 @@ export declare const LayerEvidenceSchema: z.ZodObject<{
                 tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
                 recording: z.ZodOptional<z.ZodString>;
                 available: z.ZodBoolean;
+                reason: z.ZodOptional<z.ZodString>;
                 scope: z.ZodOptional<z.ZodObject<{
                     surface: z.ZodOptional<z.ZodString>;
                     deviceKind: z.ZodOptional<z.ZodString>;
@@ -617,6 +624,7 @@ export declare const LayerEvidenceSchema: z.ZodObject<{
                 tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
                 recording: z.ZodOptional<z.ZodString>;
                 available: z.ZodBoolean;
+                reason: z.ZodOptional<z.ZodString>;
                 scope: z.ZodOptional<z.ZodObject<{
                     surface: z.ZodOptional<z.ZodString>;
                     deviceKind: z.ZodOptional<z.ZodString>;
@@ -713,6 +721,7 @@ export declare const EffectiveEvidenceSchema: z.ZodObject<{
                     tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
                     recording: z.ZodOptional<z.ZodString>;
                     available: z.ZodBoolean;
+                    reason: z.ZodOptional<z.ZodString>;
                     scope: z.ZodOptional<z.ZodObject<{
                         surface: z.ZodOptional<z.ZodString>;
                         deviceKind: z.ZodOptional<z.ZodString>;
@@ -814,6 +823,7 @@ export declare const EffectiveEvidenceSchema: z.ZodObject<{
                     tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
                     recording: z.ZodOptional<z.ZodString>;
                     available: z.ZodBoolean;
+                    reason: z.ZodOptional<z.ZodString>;
                     scope: z.ZodOptional<z.ZodObject<{
                         surface: z.ZodOptional<z.ZodString>;
                         deviceKind: z.ZodOptional<z.ZodString>;
@@ -931,6 +941,7 @@ export declare const EffectiveDeltaSchema: z.ZodObject<{
                     tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
                     recording: z.ZodOptional<z.ZodString>;
                     available: z.ZodBoolean;
+                    reason: z.ZodOptional<z.ZodString>;
                     scope: z.ZodOptional<z.ZodObject<{
                         surface: z.ZodOptional<z.ZodString>;
                         deviceKind: z.ZodOptional<z.ZodString>;
@@ -1032,6 +1043,7 @@ export declare const EffectiveDeltaSchema: z.ZodObject<{
                     tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
                     recording: z.ZodOptional<z.ZodString>;
                     available: z.ZodBoolean;
+                    reason: z.ZodOptional<z.ZodString>;
                     scope: z.ZodOptional<z.ZodObject<{
                         surface: z.ZodOptional<z.ZodString>;
                         deviceKind: z.ZodOptional<z.ZodString>;
@@ -1141,6 +1153,7 @@ export declare const EvidencePageSchema: z.ZodObject<{
                 tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
                 recording: z.ZodOptional<z.ZodString>;
                 available: z.ZodBoolean;
+                reason: z.ZodOptional<z.ZodString>;
                 scope: z.ZodOptional<z.ZodObject<{
                     surface: z.ZodOptional<z.ZodString>;
                     deviceKind: z.ZodOptional<z.ZodString>;
@@ -1721,6 +1734,7 @@ export declare const ReviewSnapshotSchema: z.ZodObject<{
         tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
         recording: z.ZodOptional<z.ZodString>;
         available: z.ZodBoolean;
+        reason: z.ZodOptional<z.ZodString>;
         scope: z.ZodOptional<z.ZodObject<{
             surface: z.ZodOptional<z.ZodString>;
             deviceKind: z.ZodOptional<z.ZodString>;
@@ -1784,6 +1798,7 @@ export declare const ReviewEntrySchema: z.ZodObject<{
             tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
             recording: z.ZodOptional<z.ZodString>;
             available: z.ZodBoolean;
+            reason: z.ZodOptional<z.ZodString>;
             scope: z.ZodOptional<z.ZodObject<{
                 surface: z.ZodOptional<z.ZodString>;
                 deviceKind: z.ZodOptional<z.ZodString>;
@@ -1866,6 +1881,7 @@ export declare const ReviewCollectionSchema: z.ZodObject<{
                 tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
                 recording: z.ZodOptional<z.ZodString>;
                 available: z.ZodBoolean;
+                reason: z.ZodOptional<z.ZodString>;
                 scope: z.ZodOptional<z.ZodObject<{
                     surface: z.ZodOptional<z.ZodString>;
                     deviceKind: z.ZodOptional<z.ZodString>;
@@ -2025,6 +2041,7 @@ export declare const ReviewCollectionDetailSchema: z.ZodObject<{
                     tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
                     recording: z.ZodOptional<z.ZodString>;
                     available: z.ZodBoolean;
+                    reason: z.ZodOptional<z.ZodString>;
                     scope: z.ZodOptional<z.ZodObject<{
                         surface: z.ZodOptional<z.ZodString>;
                         deviceKind: z.ZodOptional<z.ZodString>;
@@ -2156,6 +2173,7 @@ export declare const ReviewManifestSchema: z.ZodObject<{
                 tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
                 recording: z.ZodOptional<z.ZodString>;
                 available: z.ZodBoolean;
+                reason: z.ZodOptional<z.ZodString>;
                 scope: z.ZodOptional<z.ZodObject<{
                     surface: z.ZodOptional<z.ZodString>;
                     deviceKind: z.ZodOptional<z.ZodString>;
@@ -2284,6 +2302,7 @@ export declare const TestResultEntrySchema: z.ZodObject<{
             tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
             recording: z.ZodOptional<z.ZodString>;
             available: z.ZodBoolean;
+            reason: z.ZodOptional<z.ZodString>;
             scope: z.ZodOptional<z.ZodObject<{
                 surface: z.ZodOptional<z.ZodString>;
                 deviceKind: z.ZodOptional<z.ZodString>;
@@ -2394,6 +2413,7 @@ export declare const TestSummarySchema: z.ZodObject<{
                 tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
                 recording: z.ZodOptional<z.ZodString>;
                 available: z.ZodBoolean;
+                reason: z.ZodOptional<z.ZodString>;
                 scope: z.ZodOptional<z.ZodObject<{
                     surface: z.ZodOptional<z.ZodString>;
                     deviceKind: z.ZodOptional<z.ZodString>;
@@ -2700,6 +2720,7 @@ export declare const TestCatalogSchema: z.ZodObject<{
                     tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
                     recording: z.ZodOptional<z.ZodString>;
                     available: z.ZodBoolean;
+                    reason: z.ZodOptional<z.ZodString>;
                     scope: z.ZodOptional<z.ZodObject<{
                         surface: z.ZodOptional<z.ZodString>;
                         deviceKind: z.ZodOptional<z.ZodString>;
@@ -2938,6 +2959,7 @@ export declare const TestHistorySchema: z.ZodObject<{
                     tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
                     recording: z.ZodOptional<z.ZodString>;
                     available: z.ZodBoolean;
+                    reason: z.ZodOptional<z.ZodString>;
                     scope: z.ZodOptional<z.ZodObject<{
                         surface: z.ZodOptional<z.ZodString>;
                         deviceKind: z.ZodOptional<z.ZodString>;
@@ -3066,6 +3088,7 @@ export declare const TestHistorySchema: z.ZodObject<{
                 tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
                 recording: z.ZodOptional<z.ZodString>;
                 available: z.ZodBoolean;
+                reason: z.ZodOptional<z.ZodString>;
                 scope: z.ZodOptional<z.ZodObject<{
                     surface: z.ZodOptional<z.ZodString>;
                     deviceKind: z.ZodOptional<z.ZodString>;
@@ -3267,6 +3290,21 @@ export declare const ReportRunSchema: z.ZodObject<{
         references: z.ZodNumber;
         recordings: z.ZodNumber;
         unavailable: z.ZodNumber;
+        missing: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$loose>>;
+    recordings: z.ZodOptional<z.ZodObject<{
+        state: z.ZodEnum<{
+            unknown: "unknown";
+            complete: "complete";
+            incomplete: "incomplete";
+            "none-expected": "none-expected";
+        }>;
+        expected: z.ZodNumber;
+        published: z.ZodNumber;
+        skipped: z.ZodNumber;
+        unresolved: z.ZodNumber;
+        notApplicable: z.ZodNumber;
+        layersWithoutReceipt: z.ZodNumber;
     }, z.core.$loose>>;
     attachments: z.ZodOptional<z.ZodNumber>;
     artifactTags: z.ZodOptional<z.ZodArray<z.ZodString>>;
@@ -3313,6 +3351,10 @@ export declare const QueryFacetsSchema: z.ZodObject<{
         value: z.ZodString;
         count: z.ZodNumber;
     }, z.core.$loose>>>;
+    recordings: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        value: z.ZodString;
+        count: z.ZodNumber;
+    }, z.core.$loose>>>;
 }, z.core.$loose>;
 /** `GET /api/reports/runs`: runs, newest first. */
 export declare const RunListSchema: z.ZodObject<{
@@ -3354,6 +3396,21 @@ export declare const RunListSchema: z.ZodObject<{
             references: z.ZodNumber;
             recordings: z.ZodNumber;
             unavailable: z.ZodNumber;
+            missing: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$loose>>;
+        recordings: z.ZodOptional<z.ZodObject<{
+            state: z.ZodEnum<{
+                unknown: "unknown";
+                complete: "complete";
+                incomplete: "incomplete";
+                "none-expected": "none-expected";
+            }>;
+            expected: z.ZodNumber;
+            published: z.ZodNumber;
+            skipped: z.ZodNumber;
+            unresolved: z.ZodNumber;
+            notApplicable: z.ZodNumber;
+            layersWithoutReceipt: z.ZodNumber;
         }, z.core.$loose>>;
         attachments: z.ZodOptional<z.ZodNumber>;
         artifactTags: z.ZodOptional<z.ZodArray<z.ZodString>>;
@@ -3396,6 +3453,10 @@ export declare const RunListSchema: z.ZodObject<{
             value: z.ZodString;
             count: z.ZodNumber;
         }, z.core.$loose>>>;
+        recordings: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            value: z.ZodString;
+            count: z.ZodNumber;
+        }, z.core.$loose>>>;
     }, z.core.$loose>>;
 }, z.core.$loose>;
 /** One recorded result that carries evidence: where and when it was recorded and what it carries. */
@@ -3435,6 +3496,7 @@ export declare const ArtifactResultSchema: z.ZodObject<{
         tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
         recording: z.ZodOptional<z.ZodString>;
         available: z.ZodBoolean;
+        reason: z.ZodOptional<z.ZodString>;
         scope: z.ZodOptional<z.ZodObject<{
             surface: z.ZodOptional<z.ZodString>;
             deviceKind: z.ZodOptional<z.ZodString>;
@@ -3505,6 +3567,7 @@ export declare const ArtifactListSchema: z.ZodObject<{
             tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
             recording: z.ZodOptional<z.ZodString>;
             available: z.ZodBoolean;
+            reason: z.ZodOptional<z.ZodString>;
             scope: z.ZodOptional<z.ZodObject<{
                 surface: z.ZodOptional<z.ZodString>;
                 deviceKind: z.ZodOptional<z.ZodString>;
@@ -3566,6 +3629,10 @@ export declare const ArtifactListSchema: z.ZodObject<{
             value: z.ZodString;
             count: z.ZodNumber;
         }, z.core.$loose>>>;
+        recordings: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            value: z.ZodString;
+            count: z.ZodNumber;
+        }, z.core.$loose>>>;
     }, z.core.$loose>;
 }, z.core.$loose>;
 /** `GET /api/reports/runs/detail`: one run and its last result for every test, environment and producer it recorded. */
@@ -3607,6 +3674,21 @@ export declare const RunDetailSchema: z.ZodObject<{
             references: z.ZodNumber;
             recordings: z.ZodNumber;
             unavailable: z.ZodNumber;
+            missing: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$loose>>;
+        recordings: z.ZodOptional<z.ZodObject<{
+            state: z.ZodEnum<{
+                unknown: "unknown";
+                complete: "complete";
+                incomplete: "incomplete";
+                "none-expected": "none-expected";
+            }>;
+            expected: z.ZodNumber;
+            published: z.ZodNumber;
+            skipped: z.ZodNumber;
+            unresolved: z.ZodNumber;
+            notApplicable: z.ZodNumber;
+            layersWithoutReceipt: z.ZodNumber;
         }, z.core.$loose>>;
         attachments: z.ZodOptional<z.ZodNumber>;
         artifactTags: z.ZodOptional<z.ZodArray<z.ZodString>>;
@@ -3639,6 +3721,7 @@ export declare const RunDetailSchema: z.ZodObject<{
             tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
             recording: z.ZodOptional<z.ZodString>;
             available: z.ZodBoolean;
+            reason: z.ZodOptional<z.ZodString>;
             scope: z.ZodOptional<z.ZodObject<{
                 surface: z.ZodOptional<z.ZodString>;
                 deviceKind: z.ZodOptional<z.ZodString>;
@@ -3676,6 +3759,7 @@ export declare const RunDetailSchema: z.ZodObject<{
             references: z.ZodNumber;
             recordings: z.ZodNumber;
             unavailable: z.ZodNumber;
+            missing: z.ZodOptional<z.ZodNumber>;
         }, z.core.$loose>>;
     }, z.core.$loose>>>;
 }, z.core.$loose>;

package/dist/schema/src/api.js

@@ -71,13 +71,15 @@ export const VideoRefSchema = z.looseObject({
     tags: z.array(z.string()).optional().describe('The normalized tags of this attachment itself. Absent when it has none (and in documents of older servers)'),
     recording: z.string().optional().describe('What identifies the bytes; references with the same value are one recording. Absent when it cannot be played'),
     available: z.boolean().describe('False when the reference names no bytes: no bundle key, address or inline text, or a bundle key that the layer\'s own bundle does not hold'),
+    reason: z.string().optional().describe('Why it is unavailable, when the report can tell: `not-in-bundle` is a file the layer names but does not hold (stored, then gone). An open vocabulary: treat an unknown reason as plain unavailable'),
     scope: EvidenceScopeSchema.optional().describe('What this recording shows as its producer declared it: its own `scope`, else its attempt\'s, check\'s, part\'s or layer\'s. Absent: the scope is unknown, never live, physical or audible')
 });
 /** Video references as counts: how many are referenced, how many distinct recordings can be played, how many cannot. */
 export const VideoCountsSchema = z.looseObject({
     references: z.number().int().nonnegative().describe('Every reference to a video; identical bytes referenced twice count twice'),
     recordings: z.number().int().nonnegative().describe('Distinct playable recordings'),
-    unavailable: z.number().int().nonnegative().describe('References that name no bytes, or bytes the layer does not hold')
+    unavailable: z.number().int().nonnegative().describe('References that name no bytes, or bytes the layer does not hold'),
+    missing: z.number().int().positive().optional().describe('Of `unavailable`, those that name a file the layer\'s bundle does not hold (stored, then gone). Absent when there are none')
 });
 /** What a result carries beyond its outcome, as counts and short facts. Present only when there is something. */
 export const EvidenceSummarySchema = z.looseObject({
@@ -625,6 +627,12 @@ export const ReportRunSchema = z.looseObject({
     totalDurationMs: z.number().nullable(),
     failing: z.array(z.looseObject({ key: z.string(), title: z.string(), environment: z.string().nullable(), detail: z.string() })),
     videos: VideoCountsSchema.optional().describe('Its videos, from its layers and the last result of each test. Absent when it has none or the report carries no video information'),
+    recordings: z.looseObject({
+        state: z.enum(['complete', 'incomplete', 'none-expected', 'unknown']).describe('`incomplete` when an expected recording was skipped or unresolved; else `unknown` when a layer declared no expectations; else `complete` when something was expected and `none-expected` when nothing was'),
+        expected: z.number().int().nonnegative(), published: z.number().int().nonnegative().describe('Of the expected recordings, uploaded or referenced by address'),
+        skipped: z.number().int().nonnegative(), unresolved: z.number().int().nonnegative(), notApplicable: z.number().int().nonnegative(),
+        layersWithoutReceipt: z.number().int().nonnegative().describe('Layers of the run that declared no recording expectations: nothing is claimed for them')
+    }).optional().describe('Whether the recordings its layers expected were published, apart from its outcomes. Absent when no layer declared an expectation: its completeness is unknown, never complete. Matched by the `recordings` filter'),
     attachments: z.number().int().positive().optional().describe('Files attached to the run itself, in its layers, not to a check. Absent when there are none'),
     artifactTags: z.array(z.string()).optional().describe('The normalized tags of the attachments of its results, sorted and distinct. Absent when none is tagged, and in reports of older servers'),
     tags: z.array(z.string()).optional().describe('The tags of its checks and layers, which its attachments inherit (what `inherited=1` also matches). Absent when none'),
@@ -637,7 +645,8 @@ export const QueryFacetValueSchema = z.looseObject({ value: z.string(), count: z
 export const QueryFacetsSchema = z.looseObject({
     artifactTags: z.array(QueryFacetValueSchema), types: z.array(QueryFacetValueSchema), labels: z.array(QueryFacetValueSchema).describe('Values are `key=value`'),
     environments: z.array(QueryFacetValueSchema), producers: z.array(QueryFacetValueSchema), branches: z.array(QueryFacetValueSchema), outcomes: z.array(QueryFacetValueSchema),
-    domains: z.array(QueryFacetValueSchema).optional().describe('Only for artifacts: runs have no domain')
+    domains: z.array(QueryFacetValueSchema).optional().describe('Only for artifacts: runs have no domain'),
+    recordings: z.array(QueryFacetValueSchema).optional().describe('Only for runs: `complete`, `incomplete`, `none-expected` and `unknown` with how many runs have each. Absent on servers that predate the filter')
 });
 /** `GET /api/reports/runs`: runs, newest first. */
 export const RunListSchema = z.looseObject({

package/dist/schema/src/cli-results.d.ts

@@ -1,7 +1,7 @@
 /**
  * @module Command results (`--format json`)
  *
- * What `atlas report publish`, `stream`, `merge` and `doctor` print on standard output with `--format json` (alias
+ * What `atlas report publish`, `stream`, `merge`, `doctor` and `verify-recordings` print on standard output with `--format json` (alias
  * `--json`), and what any `atlas` command prints on standard error for a command that was wrong: one JSON document,
  * so an agent or a script never has to parse prose. (`status` and `policy` already print documents:
  * `ReportStatusSchema`, and an IAM policy.) Each is also published as a JSON Schema.
@@ -152,6 +152,36 @@ export declare const DoctorResultSchema: z.ZodObject<{
         }, z.core.$loose>>;
     }, z.core.$loose>>;
 }, z.core.$loose>;
+/** A published video that could not be read back from the store as published (see `atlas report verify-recordings`). */
+export declare const RecordingGapSchema: z.ZodObject<{
+    layer: z.ZodString;
+    check: z.ZodNullable<z.ZodString>;
+    name: z.ZodString;
+    bundleKey: z.ZodString;
+    problem: z.ZodString;
+    reason: z.ZodString;
+}, z.core.$loose>;
+/**
+ * What `atlas report verify-recordings --format json` prints: whether the videos the layers published can still be read
+ * back from the store as they were published. It describes stored bytes, never playback in a browser, and it never changes
+ * a check\'s result.
+ */
+export declare const VerifyRecordingsResultSchema: z.ZodObject<{
+    ok: z.ZodBoolean;
+    layers: z.ZodNumber;
+    checked: z.ZodNumber;
+    verified: z.ZodNumber;
+    referenced: z.ZodNumber;
+    gaps: z.ZodArray<z.ZodObject<{
+        layer: z.ZodString;
+        check: z.ZodNullable<z.ZodString>;
+        name: z.ZodString;
+        bundleKey: z.ZodString;
+        problem: z.ZodString;
+        reason: z.ZodString;
+    }, z.core.$loose>>;
+    notices: z.ZodArray<z.ZodString>;
+}, z.core.$loose>;
 /** What any `atlas` command prints on standard error, with `--format json`, when the command itself was wrong (exit code 2). */
 export declare const CommandErrorSchema: z.ZodObject<{
     ok: z.ZodLiteral<false>;
@@ -532,6 +562,26 @@ export declare const CLI_RESULTS: {
             }, z.core.$loose>>;
         }, z.core.$loose>;
     };
+    readonly verifyRecordings: {
+        readonly command: "atlas report verify-recordings";
+        readonly schemaName: "verify-recordings-result";
+        readonly schema: z.ZodObject<{
+            ok: z.ZodBoolean;
+            layers: z.ZodNumber;
+            checked: z.ZodNumber;
+            verified: z.ZodNumber;
+            referenced: z.ZodNumber;
+            gaps: z.ZodArray<z.ZodObject<{
+                layer: z.ZodString;
+                check: z.ZodNullable<z.ZodString>;
+                name: z.ZodString;
+                bundleKey: z.ZodString;
+                problem: z.ZodString;
+                reason: z.ZodString;
+            }, z.core.$loose>>;
+            notices: z.ZodArray<z.ZodString>;
+        }, z.core.$loose>;
+    };
     readonly error: {
         readonly command: "a command that was wrong (standard error)";
         readonly schemaName: "command-error";

package/dist/schema/src/cli-results.js

@@ -1,7 +1,7 @@
 /**
  * @module Command results (`--format json`)
  *
- * What `atlas report publish`, `stream`, `merge` and `doctor` print on standard output with `--format json` (alias
+ * What `atlas report publish`, `stream`, `merge`, `doctor` and `verify-recordings` print on standard output with `--format json` (alias
  * `--json`), and what any `atlas` command prints on standard error for a command that was wrong: one JSON document,
  * so an agent or a script never has to parse prose. (`status` and `policy` already print documents:
  * `ReportStatusSchema`, and an IAM policy.) Each is also published as a JSON Schema.
@@ -75,6 +75,29 @@ export const DoctorResultSchema = z.looseObject({
     ok: z.boolean().describe('True when every check of every store passed (otherwise the exit code is 1)'),
     stores: z.array(z.looseObject({ id: z.string(), checks: z.array(DoctorCheckSchema) }))
 });
+/** A published video that could not be read back from the store as published (see `atlas report verify-recordings`). */
+export const RecordingGapSchema = z.looseObject({
+    layer: z.string().describe('The layer that holds the video'),
+    check: z.string().nullable().describe('The check that holds it, or null for a video attached to the layer or a part'),
+    name: z.string().describe('The attachment\'s name'),
+    bundleKey: z.string().describe('Its key in the layer\'s bundle (`attachments/<sha256>`)'),
+    problem: z.string().describe('`not-in-bundle` (the layer names a file its bundle does not list), `blob-missing` (a blob holding it is gone: a 404 when played), `unreadable` (the store could not be read: not proof it is gone), `size-mismatch`, `checksum-mismatch` or `undecodable` (empty, or not the container its media type names). An open vocabulary: treat an unknown problem as a gap'),
+    reason: z.string().describe('A short explanation without tokens, paths or payload')
+});
+/**
+ * What `atlas report verify-recordings --format json` prints: whether the videos the layers published can still be read
+ * back from the store as they were published. It describes stored bytes, never playback in a browser, and it never changes
+ * a check\'s result.
+ */
+export const VerifyRecordingsResultSchema = z.looseObject({
+    ok: z.boolean().describe('True when no layer has a gap and every layer could be read (otherwise the exit code is 1). Test results are unaffected either way'),
+    layers: z.number().int().nonnegative().describe('Layers examined'),
+    checked: z.number().int().nonnegative().describe('Videos read back from the store (those that name a bundle key)'),
+    verified: z.number().int().nonnegative().describe('Of those, the ones that passed every check'),
+    referenced: z.number().int().nonnegative().describe('Videos given only by address, which Atlas holds no bytes for and does not check'),
+    gaps: z.array(RecordingGapSchema).describe('Every video that is missing, unreadable, corrupt or not the container it claims. Re-publish the layer\'s recordings to repair them'),
+    notices: z.array(z.string()).describe('Layers that could not be read at all: their recordings are unknown, never verified')
+});
 /** What any `atlas` command prints on standard error, with `--format json`, when the command itself was wrong (exit code 2). */
 export const CommandErrorSchema = z.looseObject({
     ok: z.literal(false),
@@ -142,5 +165,6 @@ export const CLI_RESULTS = {
     merge: { command: 'atlas report merge', schemaName: 'merge-result', schema: MergeResultSchema },
     doctor: { command: 'atlas report doctor', schemaName: 'doctor-result', schema: DoctorResultSchema },
     status: { command: 'atlas report status', schemaName: 'report-status', schema: ReportStatusSchema },
+    verifyRecordings: { command: 'atlas report verify-recordings', schemaName: 'verify-recordings-result', schema: VerifyRecordingsResultSchema },
     error: { command: 'a command that was wrong (standard error)', schemaName: 'command-error', schema: CommandErrorSchema }
 };

package/dist/server/src/openapi.js

@@ -427,6 +427,7 @@ const BASE_OPERATIONS = [
             { name: 'branch', in: 'query', description: 'Branches.', schema: str },
             { name: 'sha', in: 'query', description: 'Revisions: a full commit id or a prefix of at least seven characters.', schema: str },
             { name: 'outcome', in: 'query', description: 'Statuses: `passed`, `failed`, `running`, `not-run`. A run\'s outcome is `failed` when any result failed, else `running`, else `passed`, else `not-run`.', schema: str },
+            { name: 'recordings', in: 'query', description: 'Recording completeness of the run, apart from its outcome: `complete`, `incomplete`, `none-expected` or `unknown` (a run whose layers declared no recording expectations is `unknown`, never `complete`). Repeatable or comma-separated. Answered from the layers\' receipts; no recording is read. A server that does not know it ignores it and does not name it in `filters`.', schema: str },
             { name: 'q', in: 'query', description: 'Words that must all appear in the title, id, spec, branch, producer, environment, tags or labels.', schema: str },
             { name: 'since', in: 'query', description: 'Only records at or after this time: epoch milliseconds or an ISO date (a date alone is UTC). A result\'s recording time; a run\'s end.', schema: str },
             { name: 'until', in: 'query', description: 'Only records at or before this time (same forms as `since`).', schema: str },

package/docs/agents.md

@@ -163,6 +163,7 @@ JSON Schema (`@crvouga/atlas/schemas/<name>.schema.json`, draft 2020-12):
 | `atlas report merge` | `merge-result` |
 | `atlas report doctor` | `doctor-result` |
 | `atlas report status` | `report-status` |
+| `atlas report verify-recordings` | `verify-recordings-result` |
 | `a command that was wrong (standard error)` | `command-error` |
 <!-- /generated:json-command-schemas -->
 

package/docs/reference/cli.md

@@ -105,6 +105,8 @@ atlas report — layered evidence for any kind of spec
                        [--specs <dir>] [--format text|json|markdown]
                        [--require-environments a,b] [--require-all-specs]
                        [--branch <name>]... [--ignore-modified]
+  atlas report verify-recordings [--store <dir|s3://…|id=url>]... [--backends <module>] [--layer <id>]...
+                       [--limit <n>] [--branch <name>]... [--ignore-modified] [--format text|json]
   atlas report merge   [--store …]... [--backends <module>] --into <dir|s3://…>
   atlas report doctor  [--store …]... [--role publisher|reader|both]
   atlas report policy  --store s3://bucket/prefix [--role publisher|reader|both]
@@ -148,6 +150,13 @@ atlas report — layered evidence for any kind of spec
             --require-all-specs    fail while any spec has no results
             --branch <name>        only layers recorded on this branch (repeatable)
             --ignore-modified      leave out layers from modified checkouts and unknown origins
+  verify-recordings   Read back the videos the layers published and check they are still there as published: the
+            layer still lists the file, its blob is still stored, its size and SHA-256 are the recorded ones, and it
+            begins like the container its media type names. Exit 1 when any video is missing, unreadable, corrupt or
+            not that container, naming the layer and check; test results are never changed. This checks stored bytes,
+            not playback in a browser. Videos given only by address are counted, not checked.
+            --layer <id>   only the layer whose id starts with this (repeatable; at least 7 digits)
+            --limit <n>    only the newest n layers
   merge     Copy the layers of several stores into one.
   doctor    Check that a store works: credentials, listing, writing, and what it holds.
   policy    Print the least-privilege IAM policy for publishers, readers, or both.
@@ -156,8 +165,8 @@ atlas report — layered evidence for any kind of spec
                        { id, label?, store } (or a function returning it): a device lab, anything
                        that implements ObjectStore.
 
-  --format json (alias --json)   publish, stream, merge, doctor and status print one JSON document instead of prose
-                       (schemas: publish-result, stream-result, merge-result, doctor-result, report-status). A command
+  --format json (alias --json)   publish, stream, merge, doctor, status and verify-recordings print one JSON document instead of prose
+                       (schemas: publish-result, stream-result, merge-result, doctor-result, report-status, verify-recordings-result). A command
                        that is wrong is {"ok":false,"error":{"message":…,"code":"usage"}} on standard error.
   A store may be an Atlas server (https://…): ATLAS_STORE=https://atlas.example.com, with ATLAS_TOKEN.
 

package/docs/reference/http-api.md

@@ -833,6 +833,7 @@ Every run, newest first: layers grouped by their CI run URL (else branch and com
 - `branch` (query): Branches.
 - `sha` (query): Revisions: a full commit id or a prefix of at least seven characters.
 - `outcome` (query): Statuses: `passed`, `failed`, `running`, `not-run`. A run's outcome is `failed` when any result failed, else `running`, else `passed`, else `not-run`.
+- `recordings` (query): Recording completeness of the run, apart from its outcome: `complete`, `incomplete`, `none-expected` or `unknown` (a run whose layers declared no recording expectations is `unknown`, never `complete`). Repeatable or comma-separated. Answered from the layers' receipts; no recording is read. A server that does not know it ignores it and does not name it in `filters`.
 - `q` (query): Words that must all appear in the title, id, spec, branch, producer, environment, tags or labels.
 - `since` (query): Only records at or after this time: epoch milliseconds or an ISO date (a date alone is UTC). A result's recording time; a run's end.
 - `until` (query): Only records at or before this time (same forms as `since`).
@@ -861,6 +862,7 @@ Scoped to one project. The same project may be selected on the unprefixed API us
 - `branch` (query): Branches.
 - `sha` (query): Revisions: a full commit id or a prefix of at least seven characters.
 - `outcome` (query): Statuses: `passed`, `failed`, `running`, `not-run`. A run's outcome is `failed` when any result failed, else `running`, else `passed`, else `not-run`.
+- `recordings` (query): Recording completeness of the run, apart from its outcome: `complete`, `incomplete`, `none-expected` or `unknown` (a run whose layers declared no recording expectations is `unknown`, never `complete`). Repeatable or comma-separated. Answered from the layers' receipts; no recording is read. A server that does not know it ignores it and does not name it in `filters`.
 - `q` (query): Words that must all appear in the title, id, spec, branch, producer, environment, tags or labels.
 - `since` (query): Only records at or after this time: epoch milliseconds or an ISO date (a date alone is UTC). A result's recording time; a run's end.
 - `until` (query): Only records at or before this time (same forms as `since`).