@crvouga/atlas 0.14.0 → 0.16.0

package/packages/server/openapi.json

@@ -2,7 +2,7 @@
   "openapi": "3.1.0",
   "info": {
     "title": "Atlas server API",
-    "version": "1.4.0",
+    "version": "1.5.0",
     "summary": "Take in test results from every environment, keep them, and show everyone the combined report, live.",
     "description": "One Atlas node serves multiple projects. Clients select a project using ?project=<slug>, X-Atlas-Project, or /api/projects/<slug>/… . Each project has independent specs, layers, recordings, status, and event streams. Within each project, the newest completed result of every check wins its slot. Unqualified requests address the legacy default project.\n\n**Authentication.** With tokens configured, send `Authorization: Bearer <token>`. Roles: `read` < `publish` < `admin`. Uploading needs a Bearer token; a browser's HTTP Basic sign-in (any user name, the token as the password) is accepted for reading only. A server with no tokens is open and listens on this machine only unless told otherwise.\n\n**Errors** are [RFC 9457](https://www.rfc-editor.org/rfc/rfc9457) problem documents (`application/problem+json`) with a `detail` that says what to do. `401` send a token, `403` that token may not, `409` upload what this depends on first or you are changing something immutable, `413` too large, `422` not valid, `503` still starting (retry after `Retry-After`).\n\n**Compatibility.** Within `/api` the API only grows: optional parameters, optional response fields, new events. Ignore what you do not know.\n\nGuides: `/llms.txt`. Source: https://github.com/crvouga/atlas.",
     "license": {
@@ -3058,6 +3058,29 @@
               "type": "string"
             }
           },
+          {
+            "required": false,
+            "name": "artifactTag",
+            "in": "query",
+            "description": "Only tests with an attachment tagged this (`demo` and `#demo` are the same tag), not counting tags inherited from a check or run: the exact artifact query. `inherited=1` widens it to the tags inherited from the check and run. Repeatable or comma-separated.",
+            "example": "demo",
+            "schema": {
+              "type": "string"
+            }
+          },
+          {
+            "required": false,
+            "name": "inherited",
+            "in": "query",
+            "description": "With `artifactTag`: `1` also matches the tags an attachment inherits from its check and run, so a recording without a tag of its own under a run tagged `demo` is found. Without it the query is exact.",
+            "schema": {
+              "type": "string",
+              "enum": [
+                "1",
+                "true"
+              ]
+            }
+          },
           {
             "required": false,
             "name": "run",
@@ -3274,6 +3297,29 @@
               "type": "string"
             }
           },
+          {
+            "required": false,
+            "name": "artifactTag",
+            "in": "query",
+            "description": "Only tests with an attachment tagged this (`demo` and `#demo` are the same tag), not counting tags inherited from a check or run: the exact artifact query. `inherited=1` widens it to the tags inherited from the check and run. Repeatable or comma-separated.",
+            "example": "demo",
+            "schema": {
+              "type": "string"
+            }
+          },
+          {
+            "required": false,
+            "name": "inherited",
+            "in": "query",
+            "description": "With `artifactTag`: `1` also matches the tags an attachment inherits from its check and run, so a recording without a tag of its own under a run tagged `demo` is found. Without it the query is exact.",
+            "schema": {
+              "type": "string",
+              "enum": [
+                "1",
+                "true"
+              ]
+            }
+          },
           {
             "required": false,
             "name": "run",
@@ -3801,6 +3847,298 @@
         }
       }
     },
+    "/api/reports/artifact-tags": {
+      "get": {
+        "operationId": "getArtifactTags",
+        "tags": [
+          "Report"
+        ],
+        "summary": "Reviewer tags of attachments: every recorded edit",
+        "description": "The audit trail of tags that reviewers added to and removed from attachments after upload, oldest first. Each entry says which attachment (`target`), which normalized tags were added and removed, the name of the token that made the edit (`by`, never the token) and when (`atMs`). The layers themselves are never rewritten, so a producer's own `tags` on an attachment stay as uploaded; fold the entries (oldest first, the last edit of a tag wins) to get the reviewer tags that stand now. Tags are normalized: `#Demo` and `demo` are `demo`.\n\nRole needed: `read`.",
+        "x-atlas-role": "read",
+        "security": [
+          {
+            "bearer": []
+          },
+          {
+            "basic": []
+          }
+        ],
+        "parameters": [
+          {
+            "required": false,
+            "name": "project",
+            "in": "query",
+            "description": "Project slug. Alternatively send X-Atlas-Project or use the project-prefixed route. Omit for the default project. Conflicting selectors are refused.",
+            "example": "todo-app",
+            "schema": {
+              "type": "string",
+              "pattern": "^[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$",
+              "maxLength": 64
+            }
+          }
+        ],
+        "responses": {
+          "200": {
+            "description": "The edits.",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/ArtifactTags"
+                }
+              }
+            }
+          },
+          "401": {
+            "description": "No token, or an unknown one. Send `Authorization: Bearer <token>`.",
+            "content": {
+              "application/problem+json": {
+                "schema": {
+                  "$ref": "#/components/schemas/Problem"
+                }
+              }
+            }
+          }
+        }
+      },
+      "post": {
+        "operationId": "editArtifactTags",
+        "tags": [
+          "Report"
+        ],
+        "summary": "Tag or untag one attachment after upload",
+        "description": "Records one edit of the reviewer tags of one attachment, by the name of the publish (or admin) token that sends it. It adds an immutable entry to the audit trail and changes nothing else: not the layer, not the movie, not any result. The tags it removes are reviewer tags only; a producer's tags are part of the layer and stay. A reader-only token, a browser sign-in box and an anonymous reader are refused. Name the attachment as `artifactRef` does (`id:<id>`, else `key:<bundleKey>`, else `name:<name>`).\n\nRole needed: `publish`.",
+        "x-atlas-role": "publish",
+        "security": [
+          {
+            "bearer": []
+          }
+        ],
+        "parameters": [
+          {
+            "required": false,
+            "name": "project",
+            "in": "query",
+            "description": "Project slug. Alternatively send X-Atlas-Project or use the project-prefixed route. Omit for the default project. Conflicting selectors are refused.",
+            "example": "todo-app",
+            "schema": {
+              "type": "string",
+              "pattern": "^[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$",
+              "maxLength": 64
+            }
+          }
+        ],
+        "requestBody": {
+          "required": true,
+          "description": "The attachment and the tags to add and remove. At most 20 of each, 64 KiB.",
+          "content": {
+            "application/json": {
+              "schema": {
+                "$ref": "#/components/schemas/ArtifactTagEdit"
+              }
+            }
+          }
+        },
+        "responses": {
+          "201": {
+            "description": "The recorded entry.",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/ArtifactTagEntry"
+                }
+              }
+            }
+          },
+          "401": {
+            "description": "No token, or an unknown one. Send `Authorization: Bearer <token>`.",
+            "content": {
+              "application/problem+json": {
+                "schema": {
+                  "$ref": "#/components/schemas/Problem"
+                }
+              }
+            }
+          },
+          "403": {
+            "description": "The token is known but its role may not do this.",
+            "content": {
+              "application/problem+json": {
+                "schema": {
+                  "$ref": "#/components/schemas/Problem"
+                }
+              }
+            }
+          },
+          "413": {
+            "description": "Request too large.",
+            "content": {
+              "application/problem+json": {
+                "schema": {
+                  "$ref": "#/components/schemas/Problem"
+                }
+              }
+            }
+          },
+          "422": {
+            "description": "Not a tag edit: a bad target, an empty or over-long tag, or nothing to change.",
+            "content": {
+              "application/problem+json": {
+                "schema": {
+                  "$ref": "#/components/schemas/Problem"
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/api/projects/{project}/reports/artifact-tags": {
+      "get": {
+        "operationId": "getArtifactTagsForProject",
+        "tags": [
+          "Report"
+        ],
+        "summary": "Reviewer tags of attachments: every recorded edit",
+        "description": "The audit trail of tags that reviewers added to and removed from attachments after upload, oldest first. Each entry says which attachment (`target`), which normalized tags were added and removed, the name of the token that made the edit (`by`, never the token) and when (`atMs`). The layers themselves are never rewritten, so a producer's own `tags` on an attachment stay as uploaded; fold the entries (oldest first, the last edit of a tag wins) to get the reviewer tags that stand now. Tags are normalized: `#Demo` and `demo` are `demo`.\n\nScoped to one project. The same project may be selected on the unprefixed API using ?project= or X-Atlas-Project. Unknown projects return 404 on reads and are created by an authenticated upload.\n\nRole needed: `read`.",
+        "x-atlas-role": "read",
+        "security": [
+          {
+            "bearer": []
+          },
+          {
+            "basic": []
+          }
+        ],
+        "parameters": [
+          {
+            "required": true,
+            "name": "project",
+            "in": "path",
+            "description": "Project slug. Alternatively send X-Atlas-Project or use the project-prefixed route. Omit for the default project. Conflicting selectors are refused.",
+            "example": "todo-app",
+            "schema": {
+              "type": "string",
+              "pattern": "^[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$",
+              "maxLength": 64
+            }
+          }
+        ],
+        "responses": {
+          "200": {
+            "description": "The edits.",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/ArtifactTags"
+                }
+              }
+            }
+          },
+          "401": {
+            "description": "No token, or an unknown one. Send `Authorization: Bearer <token>`.",
+            "content": {
+              "application/problem+json": {
+                "schema": {
+                  "$ref": "#/components/schemas/Problem"
+                }
+              }
+            }
+          }
+        }
+      },
+      "post": {
+        "operationId": "editArtifactTagsForProject",
+        "tags": [
+          "Report"
+        ],
+        "summary": "Tag or untag one attachment after upload",
+        "description": "Records one edit of the reviewer tags of one attachment, by the name of the publish (or admin) token that sends it. It adds an immutable entry to the audit trail and changes nothing else: not the layer, not the movie, not any result. The tags it removes are reviewer tags only; a producer's tags are part of the layer and stay. A reader-only token, a browser sign-in box and an anonymous reader are refused. Name the attachment as `artifactRef` does (`id:<id>`, else `key:<bundleKey>`, else `name:<name>`).\n\nScoped to one project. The same project may be selected on the unprefixed API using ?project= or X-Atlas-Project. Unknown projects return 404 on reads and are created by an authenticated upload.\n\nRole needed: `publish`.",
+        "x-atlas-role": "publish",
+        "security": [
+          {
+            "bearer": []
+          }
+        ],
+        "parameters": [
+          {
+            "required": true,
+            "name": "project",
+            "in": "path",
+            "description": "Project slug. Alternatively send X-Atlas-Project or use the project-prefixed route. Omit for the default project. Conflicting selectors are refused.",
+            "example": "todo-app",
+            "schema": {
+              "type": "string",
+              "pattern": "^[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$",
+              "maxLength": 64
+            }
+          }
+        ],
+        "requestBody": {
+          "required": true,
+          "description": "The attachment and the tags to add and remove. At most 20 of each, 64 KiB.",
+          "content": {
+            "application/json": {
+              "schema": {
+                "$ref": "#/components/schemas/ArtifactTagEdit"
+              }
+            }
+          }
+        },
+        "responses": {
+          "201": {
+            "description": "The recorded entry.",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/ArtifactTagEntry"
+                }
+              }
+            }
+          },
+          "401": {
+            "description": "No token, or an unknown one. Send `Authorization: Bearer <token>`.",
+            "content": {
+              "application/problem+json": {
+                "schema": {
+                  "$ref": "#/components/schemas/Problem"
+                }
+              }
+            }
+          },
+          "403": {
+            "description": "The token is known but its role may not do this.",
+            "content": {
+              "application/problem+json": {
+                "schema": {
+                  "$ref": "#/components/schemas/Problem"
+                }
+              }
+            }
+          },
+          "413": {
+            "description": "Request too large.",
+            "content": {
+              "application/problem+json": {
+                "schema": {
+                  "$ref": "#/components/schemas/Problem"
+                }
+              }
+            }
+          },
+          "422": {
+            "description": "Not a tag edit: a bad target, an empty or over-long tag, or nothing to change.",
+            "content": {
+              "application/problem+json": {
+                "schema": {
+                  "$ref": "#/components/schemas/Problem"
+                }
+              }
+            }
+          }
+        }
+      }
+    },
     "/api/reports/runs": {
       "get": {
         "operationId": "getReportRuns",
@@ -3808,7 +4146,7 @@
           "Report"
         ],
         "summary": "The runs that recorded the report",
-        "description": "Every run, newest first: layers grouped by their CI run URL (else branch and commit), with their environments, producers, how many tests they recorded, their results by status, the time they spanned and up to twenty failures. Send `format=markdown` for Markdown.\n\nRole needed: `read`.",
+        "description": "Every run, newest first: layers grouped by their CI run URL (else branch and commit), with their environments, producers, how many tests they recorded, their results by status, the time they spanned, up to twenty failures and their video counts (references, distinct playable recordings, unavailable). Send `format=markdown` for Markdown.\n\nRole needed: `read`.",
         "x-atlas-role": "read",
         "security": [
           {
@@ -3829,6 +4167,15 @@
               "minimum": 0
             }
           },
+          {
+            "required": false,
+            "name": "video",
+            "in": "query",
+            "description": "`true` to list only runs that have a playable video recording. Applied to every run before `limit`; `total` counts the matches. A server that does not know it answers with every run.",
+            "schema": {
+              "type": "boolean"
+            }
+          },
           {
             "required": false,
             "name": "format",
@@ -3899,7 +4246,7 @@
           "Report"
         ],
         "summary": "The runs that recorded the report",
-        "description": "Every run, newest first: layers grouped by their CI run URL (else branch and commit), with their environments, producers, how many tests they recorded, their results by status, the time they spanned and up to twenty failures. Send `format=markdown` for Markdown.\n\nScoped to one project. The same project may be selected on the unprefixed API using ?project= or X-Atlas-Project. Unknown projects return 404 on reads and are created by an authenticated upload.\n\nRole needed: `read`.",
+        "description": "Every run, newest first: layers grouped by their CI run URL (else branch and commit), with their environments, producers, how many tests they recorded, their results by status, the time they spanned, up to twenty failures and their video counts (references, distinct playable recordings, unavailable). Send `format=markdown` for Markdown.\n\nScoped to one project. The same project may be selected on the unprefixed API using ?project= or X-Atlas-Project. Unknown projects return 404 on reads and are created by an authenticated upload.\n\nRole needed: `read`.",
         "x-atlas-role": "read",
         "security": [
           {
@@ -3932,6 +4279,15 @@
               "minimum": 0
             }
           },
+          {
+            "required": false,
+            "name": "video",
+            "in": "query",
+            "description": "`true` to list only runs that have a playable video recording. Applied to every run before `limit`; `total` counts the matches. A server that does not know it answers with every run.",
+            "schema": {
+              "type": "boolean"
+            }
+          },
           {
             "required": false,
             "name": "format",
@@ -7451,6 +7807,13 @@
                               "type": "string"
                             }
                           },
+                          "artifactTags": {
+                            "description": "Normalized tags of the attachments themselves, sorted and distinct. Absent when no attachment is tagged; never inherited from a check or run",
+                            "type": "array",
+                            "items": {
+                              "type": "string"
+                            }
+                          },
                           "labels": {
                             "type": "object",
                             "propertyNames": {
@@ -7465,6 +7828,47 @@
                             "items": {
                               "type": "string"
                             }
+                          },
+                          "videos": {
+                            "description": "Its references to videos and who holds each. Absent when it has none, and in reports written before this was recorded",
+                            "type": "array",
+                            "items": {
+                              "type": "object",
+                              "properties": {
+                                "name": {
+                                  "type": "string",
+                                  "description": "The attachment name"
+                                },
+                                "owner": {
+                                  "type": "string",
+                                  "description": "Who holds it: `layer`, `check`, `attempt` or `step`. An open vocabulary: treat an unknown owner as a check"
+                                },
+                                "attempt": {
+                                  "description": "The retry attempt that holds it, or that holds the step that does",
+                                  "type": "integer",
+                                  "minimum": 0,
+                                  "maximum": 9007199254740991
+                                },
+                                "step": {
+                                  "description": "The name of the step that holds it",
+                                  "type": "string"
+                                },
+                                "recording": {
+                                  "description": "What identifies the bytes; references with the same value are one recording. Absent when it cannot be played",
+                                  "type": "string"
+                                },
+                                "available": {
+                                  "type": "boolean",
+                                  "description": "False when the reference names no bytes (no bundle key, address or inline text)"
+                                }
+                              },
+                              "required": [
+                                "name",
+                                "owner",
+                                "available"
+                              ],
+                              "additionalProperties": {}
+                            }
                           }
                         },
                         "required": [
@@ -7677,6 +8081,13 @@
                             "type": "string"
                           }
                         },
+                        "artifactTags": {
+                          "description": "Normalized tags of the attachments themselves, sorted and distinct. Absent when no attachment is tagged; never inherited from a check or run",
+                          "type": "array",
+                          "items": {
+                            "type": "string"
+                          }
+                        },
                         "labels": {
                           "type": "object",
                           "propertyNames": {
@@ -7691,6 +8102,47 @@
                           "items": {
                             "type": "string"
                           }
+                        },
+                        "videos": {
+                          "description": "Its references to videos and who holds each. Absent when it has none, and in reports written before this was recorded",
+                          "type": "array",
+                          "items": {
+                            "type": "object",
+                            "properties": {
+                              "name": {
+                                "type": "string",
+                                "description": "The attachment name"
+                              },
+                              "owner": {
+                                "type": "string",
+                                "description": "Who holds it: `layer`, `check`, `attempt` or `step`. An open vocabulary: treat an unknown owner as a check"
+                              },
+                              "attempt": {
+                                "description": "The retry attempt that holds it, or that holds the step that does",
+                                "type": "integer",
+                                "minimum": 0,
+                                "maximum": 9007199254740991
+                              },
+                              "step": {
+                                "description": "The name of the step that holds it",
+                                "type": "string"
+                              },
+                              "recording": {
+                                "description": "What identifies the bytes; references with the same value are one recording. Absent when it cannot be played",
+                                "type": "string"
+                              },
+                              "available": {
+                                "type": "boolean",
+                                "description": "False when the reference names no bytes (no bundle key, address or inline text)"
+                              }
+                            },
+                            "required": [
+                              "name",
+                              "owner",
+                              "available"
+                            ],
+                            "additionalProperties": {}
+                          }
                         }
                       },
                       "required": [
@@ -7924,6 +8376,13 @@
                               "type": "string"
                             }
                           },
+                          "artifactTags": {
+                            "description": "Normalized tags of the attachments themselves, sorted and distinct. Absent when no attachment is tagged; never inherited from a check or run",
+                            "type": "array",
+                            "items": {
+                              "type": "string"
+                            }
+                          },
                           "labels": {
                             "type": "object",
                             "propertyNames": {
@@ -7938,6 +8397,47 @@
                             "items": {
                               "type": "string"
                             }
+                          },
+                          "videos": {
+                            "description": "Its references to videos and who holds each. Absent when it has none, and in reports written before this was recorded",
+                            "type": "array",
+                            "items": {
+                              "type": "object",
+                              "properties": {
+                                "name": {
+                                  "type": "string",
+                                  "description": "The attachment name"
+                                },
+                                "owner": {
+                                  "type": "string",
+                                  "description": "Who holds it: `layer`, `check`, `attempt` or `step`. An open vocabulary: treat an unknown owner as a check"
+                                },
+                                "attempt": {
+                                  "description": "The retry attempt that holds it, or that holds the step that does",
+                                  "type": "integer",
+                                  "minimum": 0,
+                                  "maximum": 9007199254740991
+                                },
+                                "step": {
+                                  "description": "The name of the step that holds it",
+                                  "type": "string"
+                                },
+                                "recording": {
+                                  "description": "What identifies the bytes; references with the same value are one recording. Absent when it cannot be played",
+                                  "type": "string"
+                                },
+                                "available": {
+                                  "type": "boolean",
+                                  "description": "False when the reference names no bytes (no bundle key, address or inline text)"
+                                }
+                              },
+                              "required": [
+                                "name",
+                                "owner",
+                                "available"
+                              ],
+                              "additionalProperties": {}
+                            }
                           }
                         },
                         "required": [
@@ -8150,6 +8650,13 @@
                             "type": "string"
                           }
                         },
+                        "artifactTags": {
+                          "description": "Normalized tags of the attachments themselves, sorted and distinct. Absent when no attachment is tagged; never inherited from a check or run",
+                          "type": "array",
+                          "items": {
+                            "type": "string"
+                          }
+                        },
                         "labels": {
                           "type": "object",
                           "propertyNames": {
@@ -8164,6 +8671,47 @@
                           "items": {
                             "type": "string"
                           }
+                        },
+                        "videos": {
+                          "description": "Its references to videos and who holds each. Absent when it has none, and in reports written before this was recorded",
+                          "type": "array",
+                          "items": {
+                            "type": "object",
+                            "properties": {
+                              "name": {
+                                "type": "string",
+                                "description": "The attachment name"
+                              },
+                              "owner": {
+                                "type": "string",
+                                "description": "Who holds it: `layer`, `check`, `attempt` or `step`. An open vocabulary: treat an unknown owner as a check"
+                              },
+                              "attempt": {
+                                "description": "The retry attempt that holds it, or that holds the step that does",
+                                "type": "integer",
+                                "minimum": 0,
+                                "maximum": 9007199254740991
+                              },
+                              "step": {
+                                "description": "The name of the step that holds it",
+                                "type": "string"
+                              },
+                              "recording": {
+                                "description": "What identifies the bytes; references with the same value are one recording. Absent when it cannot be played",
+                                "type": "string"
+                              },
+                              "available": {
+                                "type": "boolean",
+                                "description": "False when the reference names no bytes (no bundle key, address or inline text)"
+                              }
+                            },
+                            "required": [
+                              "name",
+                              "owner",
+                              "available"
+                            ],
+                            "additionalProperties": {}
+                          }
                         }
                       },
                       "required": [
@@ -8802,6 +9350,13 @@
                       "description": {
                         "type": "string"
                       },
+                      "tags": {
+                        "description": "Free labels of this one attachment, such as `demo`: shown as `#demo`, searchable, and normalized by `normalizeTag` (a leading `#` and letter case never matter). Unlike the tags of a check they say nothing about its result",
+                        "type": "array",
+                        "items": {
+                          "type": "string"
+                        }
+                      },
                       "at": {
                         "type": "object",
                         "properties": {
@@ -9039,6 +9594,13 @@
                             "description": {
                               "type": "string"
                             },
+                            "tags": {
+                              "description": "Free labels of this one attachment, such as `demo`: shown as `#demo`, searchable, and normalized by `normalizeTag` (a leading `#` and letter case never matter). Unlike the tags of a check they say nothing about its result",
+                              "type": "array",
+                              "items": {
+                                "type": "string"
+                              }
+                            },
                             "at": {
                               "type": "object",
                               "properties": {
@@ -9313,6 +9875,13 @@
                                   "description": {
                                     "type": "string"
                                   },
+                                  "tags": {
+                                    "description": "Free labels of this one attachment, such as `demo`: shown as `#demo`, searchable, and normalized by `normalizeTag` (a leading `#` and letter case never matter). Unlike the tags of a check they say nothing about its result",
+                                    "type": "array",
+                                    "items": {
+                                      "type": "string"
+                                    }
+                                  },
                                   "at": {
                                     "type": "object",
                                     "properties": {
@@ -9523,6 +10092,13 @@
                             "description": {
                               "type": "string"
                             },
+                            "tags": {
+                              "description": "Free labels of this one attachment, such as `demo`: shown as `#demo`, searchable, and normalized by `normalizeTag` (a leading `#` and letter case never matter). Unlike the tags of a check they say nothing about its result",
+                              "type": "array",
+                              "items": {
+                                "type": "string"
+                              }
+                            },
                             "at": {
                               "type": "object",
                               "properties": {
@@ -9903,6 +10479,13 @@
                 "description": {
                   "type": "string"
                 },
+                "tags": {
+                  "description": "Free labels of this one attachment, such as `demo`: shown as `#demo`, searchable, and normalized by `normalizeTag` (a leading `#` and letter case never matter). Unlike the tags of a check they say nothing about its result",
+                  "type": "array",
+                  "items": {
+                    "type": "string"
+                  }
+                },
                 "at": {
                   "type": "object",
                   "properties": {
@@ -10363,6 +10946,13 @@
                         "type": "string"
                       }
                     },
+                    "artifactTags": {
+                      "description": "Normalized tags of the attachments themselves, sorted and distinct. Absent when no attachment is tagged; never inherited from a check or run",
+                      "type": "array",
+                      "items": {
+                        "type": "string"
+                      }
+                    },
                     "labels": {
                       "type": "object",
                       "propertyNames": {
@@ -10377,6 +10967,47 @@
                       "items": {
                         "type": "string"
                       }
+                    },
+                    "videos": {
+                      "description": "Its references to videos and who holds each. Absent when it has none, and in reports written before this was recorded",
+                      "type": "array",
+                      "items": {
+                        "type": "object",
+                        "properties": {
+                          "name": {
+                            "type": "string",
+                            "description": "The attachment name"
+                          },
+                          "owner": {
+                            "type": "string",
+                            "description": "Who holds it: `layer`, `check`, `attempt` or `step`. An open vocabulary: treat an unknown owner as a check"
+                          },
+                          "attempt": {
+                            "description": "The retry attempt that holds it, or that holds the step that does",
+                            "type": "integer",
+                            "minimum": 0,
+                            "maximum": 9007199254740991
+                          },
+                          "step": {
+                            "description": "The name of the step that holds it",
+                            "type": "string"
+                          },
+                          "recording": {
+                            "description": "What identifies the bytes; references with the same value are one recording. Absent when it cannot be played",
+                            "type": "string"
+                          },
+                          "available": {
+                            "type": "boolean",
+                            "description": "False when the reference names no bytes (no bundle key, address or inline text)"
+                          }
+                        },
+                        "required": [
+                          "name",
+                          "owner",
+                          "available"
+                        ],
+                        "additionalProperties": {}
+                      }
                     }
                   },
                   "required": [
@@ -10590,6 +11221,13 @@
                         "type": "string"
                       }
                     },
+                    "artifactTags": {
+                      "description": "Normalized tags of the attachments themselves, sorted and distinct. Absent when no attachment is tagged; never inherited from a check or run",
+                      "type": "array",
+                      "items": {
+                        "type": "string"
+                      }
+                    },
                     "labels": {
                       "type": "object",
                       "propertyNames": {
@@ -10604,6 +11242,47 @@
                       "items": {
                         "type": "string"
                       }
+                    },
+                    "videos": {
+                      "description": "Its references to videos and who holds each. Absent when it has none, and in reports written before this was recorded",
+                      "type": "array",
+                      "items": {
+                        "type": "object",
+                        "properties": {
+                          "name": {
+                            "type": "string",
+                            "description": "The attachment name"
+                          },
+                          "owner": {
+                            "type": "string",
+                            "description": "Who holds it: `layer`, `check`, `attempt` or `step`. An open vocabulary: treat an unknown owner as a check"
+                          },
+                          "attempt": {
+                            "description": "The retry attempt that holds it, or that holds the step that does",
+                            "type": "integer",
+                            "minimum": 0,
+                            "maximum": 9007199254740991
+                          },
+                          "step": {
+                            "description": "The name of the step that holds it",
+                            "type": "string"
+                          },
+                          "recording": {
+                            "description": "What identifies the bytes; references with the same value are one recording. Absent when it cannot be played",
+                            "type": "string"
+                          },
+                          "available": {
+                            "type": "boolean",
+                            "description": "False when the reference names no bytes (no bundle key, address or inline text)"
+                          }
+                        },
+                        "required": [
+                          "name",
+                          "owner",
+                          "available"
+                        ],
+                        "additionalProperties": {}
+                      }
                     }
                   },
                   "required": [
@@ -10821,6 +11500,13 @@
                     "description": {
                       "type": "string"
                     },
+                    "tags": {
+                      "description": "Free labels of this one attachment, such as `demo`: shown as `#demo`, searchable, and normalized by `normalizeTag` (a leading `#` and letter case never matter). Unlike the tags of a check they say nothing about its result",
+                      "type": "array",
+                      "items": {
+                        "type": "string"
+                      }
+                    },
                     "at": {
                       "type": "object",
                       "properties": {
@@ -11049,6 +11735,13 @@
                           "description": {
                             "type": "string"
                           },
+                          "tags": {
+                            "description": "Free labels of this one attachment, such as `demo`: shown as `#demo`, searchable, and normalized by `normalizeTag` (a leading `#` and letter case never matter). Unlike the tags of a check they say nothing about its result",
+                            "type": "array",
+                            "items": {
+                              "type": "string"
+                            }
+                          },
                           "at": {
                             "type": "object",
                             "properties": {
@@ -11314,6 +12007,13 @@
                                 "description": {
                                   "type": "string"
                                 },
+                                "tags": {
+                                  "description": "Free labels of this one attachment, such as `demo`: shown as `#demo`, searchable, and normalized by `normalizeTag` (a leading `#` and letter case never matter). Unlike the tags of a check they say nothing about its result",
+                                  "type": "array",
+                                  "items": {
+                                    "type": "string"
+                                  }
+                                },
                                 "at": {
                                   "type": "object",
                                   "properties": {
@@ -11514,6 +12214,13 @@
                           "description": {
                             "type": "string"
                           },
+                          "tags": {
+                            "description": "Free labels of this one attachment, such as `demo`: shown as `#demo`, searchable, and normalized by `normalizeTag` (a leading `#` and letter case never matter). Unlike the tags of a check they say nothing about its result",
+                            "type": "array",
+                            "items": {
+                              "type": "string"
+                            }
+                          },
                           "at": {
                             "type": "object",
                             "properties": {
@@ -11643,44 +12350,262 @@
                         "additionalProperties": {}
                       }
                     },
-                    "extensions": {
-                      "type": "object",
-                      "propertyNames": {
-                        "type": "string",
-                        "minLength": 1
-                      },
-                      "additionalProperties": {}
+                    "extensions": {
+                      "type": "object",
+                      "propertyNames": {
+                        "type": "string",
+                        "minLength": 1
+                      },
+                      "additionalProperties": {}
+                    }
+                  },
+                  "required": [
+                    "index",
+                    "status"
+                  ],
+                  "additionalProperties": {}
+                }
+              }
+            },
+            "required": [
+              "id",
+              "title",
+              "status",
+              "detail",
+              "measurements"
+            ],
+            "additionalProperties": {}
+          },
+          "run": {
+            "type": "object",
+            "properties": {},
+            "additionalProperties": {},
+            "description": "What the run as a whole carries: its logs, links, labels, annotations and extensions"
+          }
+        },
+        "required": [
+          "layer",
+          "kind",
+          "check",
+          "run"
+        ],
+        "additionalProperties": {}
+      },
+      "ArtifactTagEdit": {
+        "type": "object",
+        "properties": {
+          "target": {
+            "type": "object",
+            "properties": {
+              "layer": {
+                "type": "string",
+                "pattern": "^[0-9a-f]{64}$",
+                "description": "The id of the archived layer that holds the check"
+              },
+              "check": {
+                "type": "string",
+                "minLength": 1,
+                "description": "The check's id"
+              },
+              "kind": {
+                "description": "The kind of the part holding the check, when the same id exists in several parts",
+                "type": "string",
+                "minLength": 1
+              },
+              "artifact": {
+                "type": "string",
+                "minLength": 1,
+                "maxLength": 1024,
+                "description": "The attachment: `id:<id>` when it has an id, else `key:<bundleKey>`, else `name:<name>` (see `artifactRef`)"
+              }
+            },
+            "required": [
+              "layer",
+              "check",
+              "artifact"
+            ],
+            "additionalProperties": {}
+          },
+          "add": {
+            "description": "Tags to add. `demo` and `#demo` are the same tag",
+            "maxItems": 20,
+            "type": "array",
+            "items": {
+              "type": "string"
+            }
+          },
+          "remove": {
+            "description": "Reviewer tags to remove. Tags the producer wrote are part of the immutable layer and stay",
+            "maxItems": 20,
+            "type": "array",
+            "items": {
+              "type": "string"
+            }
+          }
+        },
+        "required": [
+          "target"
+        ],
+        "additionalProperties": {}
+      },
+      "ArtifactTagEntry": {
+        "type": "object",
+        "properties": {
+          "id": {
+            "type": "string",
+            "description": "Unique and time-ordered"
+          },
+          "target": {
+            "type": "object",
+            "properties": {
+              "layer": {
+                "type": "string",
+                "pattern": "^[0-9a-f]{64}$",
+                "description": "The id of the archived layer that holds the check"
+              },
+              "check": {
+                "type": "string",
+                "minLength": 1,
+                "description": "The check's id"
+              },
+              "kind": {
+                "description": "The kind of the part holding the check, when the same id exists in several parts",
+                "type": "string",
+                "minLength": 1
+              },
+              "artifact": {
+                "type": "string",
+                "minLength": 1,
+                "maxLength": 1024,
+                "description": "The attachment: `id:<id>` when it has an id, else `key:<bundleKey>`, else `name:<name>` (see `artifactRef`)"
+              }
+            },
+            "required": [
+              "layer",
+              "check",
+              "artifact"
+            ],
+            "additionalProperties": {}
+          },
+          "add": {
+            "type": "array",
+            "items": {
+              "type": "string"
+            },
+            "description": "Normalized tags added"
+          },
+          "remove": {
+            "type": "array",
+            "items": {
+              "type": "string"
+            },
+            "description": "Normalized tags removed"
+          },
+          "by": {
+            "type": "string",
+            "description": "The name of the token that made the edit (never the token)"
+          },
+          "atMs": {
+            "type": "number",
+            "description": "When the server recorded it, epoch milliseconds"
+          }
+        },
+        "required": [
+          "id",
+          "target",
+          "add",
+          "remove",
+          "by",
+          "atMs"
+        ],
+        "additionalProperties": {}
+      },
+      "ArtifactTags": {
+        "type": "object",
+        "properties": {
+          "schemaVersion": {
+            "type": "number",
+            "const": 1
+          },
+          "entries": {
+            "type": "array",
+            "items": {
+              "type": "object",
+              "properties": {
+                "id": {
+                  "type": "string",
+                  "description": "Unique and time-ordered"
+                },
+                "target": {
+                  "type": "object",
+                  "properties": {
+                    "layer": {
+                      "type": "string",
+                      "pattern": "^[0-9a-f]{64}$",
+                      "description": "The id of the archived layer that holds the check"
+                    },
+                    "check": {
+                      "type": "string",
+                      "minLength": 1,
+                      "description": "The check's id"
+                    },
+                    "kind": {
+                      "description": "The kind of the part holding the check, when the same id exists in several parts",
+                      "type": "string",
+                      "minLength": 1
+                    },
+                    "artifact": {
+                      "type": "string",
+                      "minLength": 1,
+                      "maxLength": 1024,
+                      "description": "The attachment: `id:<id>` when it has an id, else `key:<bundleKey>`, else `name:<name>` (see `artifactRef`)"
                     }
                   },
                   "required": [
-                    "index",
-                    "status"
+                    "layer",
+                    "check",
+                    "artifact"
                   ],
                   "additionalProperties": {}
+                },
+                "add": {
+                  "type": "array",
+                  "items": {
+                    "type": "string"
+                  },
+                  "description": "Normalized tags added"
+                },
+                "remove": {
+                  "type": "array",
+                  "items": {
+                    "type": "string"
+                  },
+                  "description": "Normalized tags removed"
+                },
+                "by": {
+                  "type": "string",
+                  "description": "The name of the token that made the edit (never the token)"
+                },
+                "atMs": {
+                  "type": "number",
+                  "description": "When the server recorded it, epoch milliseconds"
                 }
-              }
-            },
-            "required": [
-              "id",
-              "title",
-              "status",
-              "detail",
-              "measurements"
-            ],
-            "additionalProperties": {}
-          },
-          "run": {
-            "type": "object",
-            "properties": {},
-            "additionalProperties": {},
-            "description": "What the run as a whole carries: its logs, links, labels, annotations and extensions"
+              },
+              "required": [
+                "id",
+                "target",
+                "add",
+                "remove",
+                "by",
+                "atMs"
+              ],
+              "additionalProperties": {}
+            }
           }
         },
         "required": [
-          "layer",
-          "kind",
-          "check",
-          "run"
+          "schemaVersion",
+          "entries"
         ],
         "additionalProperties": {}
       },
@@ -12274,6 +13199,27 @@
                   "additionalProperties": {}
                 }
               },
+              "artifactTags": {
+                "type": "array",
+                "items": {
+                  "type": "object",
+                  "properties": {
+                    "value": {
+                      "type": "string"
+                    },
+                    "count": {
+                      "type": "integer",
+                      "minimum": 0,
+                      "maximum": 9007199254740991
+                    }
+                  },
+                  "required": [
+                    "value",
+                    "count"
+                  ],
+                  "additionalProperties": {}
+                }
+              },
               "branches": {
                 "type": "array",
                 "items": {
@@ -12540,6 +13486,13 @@
                               "type": "string"
                             }
                           },
+                          "artifactTags": {
+                            "description": "Normalized tags of the attachments themselves, sorted and distinct. Absent when no attachment is tagged; never inherited from a check or run",
+                            "type": "array",
+                            "items": {
+                              "type": "string"
+                            }
+                          },
                           "labels": {
                             "type": "object",
                             "propertyNames": {
@@ -12554,6 +13507,47 @@
                             "items": {
                               "type": "string"
                             }
+                          },
+                          "videos": {
+                            "description": "Its references to videos and who holds each. Absent when it has none, and in reports written before this was recorded",
+                            "type": "array",
+                            "items": {
+                              "type": "object",
+                              "properties": {
+                                "name": {
+                                  "type": "string",
+                                  "description": "The attachment name"
+                                },
+                                "owner": {
+                                  "type": "string",
+                                  "description": "Who holds it: `layer`, `check`, `attempt` or `step`. An open vocabulary: treat an unknown owner as a check"
+                                },
+                                "attempt": {
+                                  "description": "The retry attempt that holds it, or that holds the step that does",
+                                  "type": "integer",
+                                  "minimum": 0,
+                                  "maximum": 9007199254740991
+                                },
+                                "step": {
+                                  "description": "The name of the step that holds it",
+                                  "type": "string"
+                                },
+                                "recording": {
+                                  "description": "What identifies the bytes; references with the same value are one recording. Absent when it cannot be played",
+                                  "type": "string"
+                                },
+                                "available": {
+                                  "type": "boolean",
+                                  "description": "False when the reference names no bytes (no bundle key, address or inline text)"
+                                }
+                              },
+                              "required": [
+                                "name",
+                                "owner",
+                                "available"
+                              ],
+                              "additionalProperties": {}
+                            }
                           }
                         },
                         "required": [
@@ -12734,6 +13728,20 @@
                     "type": "string"
                   }
                 },
+                "artifactTags": {
+                  "description": "Normalized tags of the attachments of its current results, such as `demo` (shown `#demo`). Not inherited from a check or run, unlike `tags`",
+                  "type": "array",
+                  "items": {
+                    "type": "string"
+                  }
+                },
+                "inheritedArtifactTags": {
+                  "description": "Normalized tags its attachments inherit from their check and run, apart from `artifactTags`: what `?artifactTag=…&inherited=1` also matches",
+                  "type": "array",
+                  "items": {
+                    "type": "string"
+                  }
+                },
                 "labels": {
                   "type": "object",
                   "propertyNames": {
@@ -13412,6 +14420,13 @@
                             "type": "string"
                           }
                         },
+                        "artifactTags": {
+                          "description": "Normalized tags of the attachments themselves, sorted and distinct. Absent when no attachment is tagged; never inherited from a check or run",
+                          "type": "array",
+                          "items": {
+                            "type": "string"
+                          }
+                        },
                         "labels": {
                           "type": "object",
                           "propertyNames": {
@@ -13426,6 +14441,47 @@
                           "items": {
                             "type": "string"
                           }
+                        },
+                        "videos": {
+                          "description": "Its references to videos and who holds each. Absent when it has none, and in reports written before this was recorded",
+                          "type": "array",
+                          "items": {
+                            "type": "object",
+                            "properties": {
+                              "name": {
+                                "type": "string",
+                                "description": "The attachment name"
+                              },
+                              "owner": {
+                                "type": "string",
+                                "description": "Who holds it: `layer`, `check`, `attempt` or `step`. An open vocabulary: treat an unknown owner as a check"
+                              },
+                              "attempt": {
+                                "description": "The retry attempt that holds it, or that holds the step that does",
+                                "type": "integer",
+                                "minimum": 0,
+                                "maximum": 9007199254740991
+                              },
+                              "step": {
+                                "description": "The name of the step that holds it",
+                                "type": "string"
+                              },
+                              "recording": {
+                                "description": "What identifies the bytes; references with the same value are one recording. Absent when it cannot be played",
+                                "type": "string"
+                              },
+                              "available": {
+                                "type": "boolean",
+                                "description": "False when the reference names no bytes (no bundle key, address or inline text)"
+                              }
+                            },
+                            "required": [
+                              "name",
+                              "owner",
+                              "available"
+                            ],
+                            "additionalProperties": {}
+                          }
                         }
                       },
                       "required": [
@@ -13606,6 +14662,20 @@
                   "type": "string"
                 }
               },
+              "artifactTags": {
+                "description": "Normalized tags of the attachments of its current results, such as `demo` (shown `#demo`). Not inherited from a check or run, unlike `tags`",
+                "type": "array",
+                "items": {
+                  "type": "string"
+                }
+              },
+              "inheritedArtifactTags": {
+                "description": "Normalized tags its attachments inherit from their check and run, apart from `artifactTags`: what `?artifactTag=…&inherited=1` also matches",
+                "type": "array",
+                "items": {
+                  "type": "string"
+                }
+              },
               "labels": {
                 "type": "object",
                 "propertyNames": {
@@ -13788,6 +14858,13 @@
                         "type": "string"
                       }
                     },
+                    "artifactTags": {
+                      "description": "Normalized tags of the attachments themselves, sorted and distinct. Absent when no attachment is tagged; never inherited from a check or run",
+                      "type": "array",
+                      "items": {
+                        "type": "string"
+                      }
+                    },
                     "labels": {
                       "type": "object",
                       "propertyNames": {
@@ -13802,6 +14879,47 @@
                       "items": {
                         "type": "string"
                       }
+                    },
+                    "videos": {
+                      "description": "Its references to videos and who holds each. Absent when it has none, and in reports written before this was recorded",
+                      "type": "array",
+                      "items": {
+                        "type": "object",
+                        "properties": {
+                          "name": {
+                            "type": "string",
+                            "description": "The attachment name"
+                          },
+                          "owner": {
+                            "type": "string",
+                            "description": "Who holds it: `layer`, `check`, `attempt` or `step`. An open vocabulary: treat an unknown owner as a check"
+                          },
+                          "attempt": {
+                            "description": "The retry attempt that holds it, or that holds the step that does",
+                            "type": "integer",
+                            "minimum": 0,
+                            "maximum": 9007199254740991
+                          },
+                          "step": {
+                            "description": "The name of the step that holds it",
+                            "type": "string"
+                          },
+                          "recording": {
+                            "description": "What identifies the bytes; references with the same value are one recording. Absent when it cannot be played",
+                            "type": "string"
+                          },
+                          "available": {
+                            "type": "boolean",
+                            "description": "False when the reference names no bytes (no bundle key, address or inline text)"
+                          }
+                        },
+                        "required": [
+                          "name",
+                          "owner",
+                          "available"
+                        ],
+                        "additionalProperties": {}
+                      }
                     }
                   },
                   "required": [
@@ -13858,7 +14976,8 @@
           "total": {
             "type": "integer",
             "minimum": 0,
-            "maximum": 9007199254740991
+            "maximum": 9007199254740991,
+            "description": "Runs that matched, before `limit`"
           },
           "runs": {
             "type": "array",
@@ -13992,6 +15111,36 @@
                     ],
                     "additionalProperties": {}
                   }
+                },
+                "videos": {
+                  "description": "Its videos, from its layers and the last result of each test. Absent when it has none or the report carries no video information",
+                  "type": "object",
+                  "properties": {
+                    "references": {
+                      "type": "integer",
+                      "minimum": 0,
+                      "maximum": 9007199254740991,
+                      "description": "Every reference to a video; identical bytes referenced twice count twice"
+                    },
+                    "recordings": {
+                      "type": "integer",
+                      "minimum": 0,
+                      "maximum": 9007199254740991,
+                      "description": "Distinct playable recordings"
+                    },
+                    "unavailable": {
+                      "type": "integer",
+                      "minimum": 0,
+                      "maximum": 9007199254740991,
+                      "description": "References that name no bytes"
+                    }
+                  },
+                  "required": [
+                    "references",
+                    "recordings",
+                    "unavailable"
+                  ],
+                  "additionalProperties": {}
                 }
               },
               "required": [
@@ -14012,6 +15161,12 @@
               ],
               "additionalProperties": {}
             }
+          },
+          "withVideo": {
+            "description": "How many of all runs (before `video` and `limit`) have a playable video recording",
+            "type": "integer",
+            "minimum": 0,
+            "maximum": 9007199254740991
           }
         },
         "required": [
@@ -14162,6 +15317,36 @@
                   ],
                   "additionalProperties": {}
                 }
+              },
+              "videos": {
+                "description": "Its videos, from its layers and the last result of each test. Absent when it has none or the report carries no video information",
+                "type": "object",
+                "properties": {
+                  "references": {
+                    "type": "integer",
+                    "minimum": 0,
+                    "maximum": 9007199254740991,
+                    "description": "Every reference to a video; identical bytes referenced twice count twice"
+                  },
+                  "recordings": {
+                    "type": "integer",
+                    "minimum": 0,
+                    "maximum": 9007199254740991,
+                    "description": "Distinct playable recordings"
+                  },
+                  "unavailable": {
+                    "type": "integer",
+                    "minimum": 0,
+                    "maximum": 9007199254740991,
+                    "description": "References that name no bytes"
+                  }
+                },
+                "required": [
+                  "references",
+                  "recordings",
+                  "unavailable"
+                ],
+                "additionalProperties": {}
               }
             },
             "required": [
@@ -14234,6 +15419,47 @@
                 },
                 "detail": {
                   "type": "string"
+                },
+                "videos": {
+                  "description": "Every video its evidence references, with who holds it",
+                  "type": "array",
+                  "items": {
+                    "type": "object",
+                    "properties": {
+                      "name": {
+                        "type": "string",
+                        "description": "The attachment name"
+                      },
+                      "owner": {
+                        "type": "string",
+                        "description": "Who holds it: `layer`, `check`, `attempt` or `step`. An open vocabulary: treat an unknown owner as a check"
+                      },
+                      "attempt": {
+                        "description": "The retry attempt that holds it, or that holds the step that does",
+                        "type": "integer",
+                        "minimum": 0,
+                        "maximum": 9007199254740991
+                      },
+                      "step": {
+                        "description": "The name of the step that holds it",
+                        "type": "string"
+                      },
+                      "recording": {
+                        "description": "What identifies the bytes; references with the same value are one recording. Absent when it cannot be played",
+                        "type": "string"
+                      },
+                      "available": {
+                        "type": "boolean",
+                        "description": "False when the reference names no bytes (no bundle key, address or inline text)"
+                      }
+                    },
+                    "required": [
+                      "name",
+                      "owner",
+                      "available"
+                    ],
+                    "additionalProperties": {}
+                  }
                 }
               },
               "required": [