doc-detective 4.33.0 → 4.34.0

package/dist/index.cjs

@@ -34565,6 +34565,56 @@ var init_schemas = __esm({
                                                                 }
                                                               ]
                                                             },
+                                                            verify: {
+                                                              title: "Recording verify guards",
+                                                              description: "Structural assertions on the produced video file, evaluated when the recording stops. Unlike checkpoint drift (a WARNING), a violated guard FAILs the stopRecord step \u2014 these are properties you explicitly demand of the artifact.",
+                                                              type: "object",
+                                                              additionalProperties: false,
+                                                              properties: {
+                                                                minDuration: {
+                                                                  type: "number",
+                                                                  description: "Fail if the video is shorter than this many seconds.",
+                                                                  minimum: 0
+                                                                },
+                                                                maxDuration: {
+                                                                  type: "number",
+                                                                  description: "Fail if the video is longer than this many seconds.",
+                                                                  minimum: 0
+                                                                },
+                                                                resolution: {
+                                                                  description: "Verify the video's dimensions (\xB12 pixels \u2014 encoders round to even dimensions). `true` compares against the capture plan's resolved expectation (the crop rectangle when a window/viewport crop applied, else the capture frame size; skipped when no expectation exists for the engine). An object compares literal dimensions.",
+                                                                  anyOf: [
+                                                                    {
+                                                                      type: "boolean",
+                                                                      title: "Verify resolution (boolean)"
+                                                                    },
+                                                                    {
+                                                                      type: "object",
+                                                                      title: "Verify resolution (detailed)",
+                                                                      additionalProperties: false,
+                                                                      required: [
+                                                                        "width",
+                                                                        "height"
+                                                                      ],
+                                                                      properties: {
+                                                                        width: {
+                                                                          type: "integer",
+                                                                          minimum: 1
+                                                                        },
+                                                                        height: {
+                                                                          type: "integer",
+                                                                          minimum: 1
+                                                                        }
+                                                                      }
+                                                                    }
+                                                                  ]
+                                                                },
+                                                                notBlack: {
+                                                                  type: "boolean",
+                                                                  description: "Fail if the video is essentially all black (black frames cover 95% or more of its duration) \u2014 the classic symptom of a broken screen capture."
+                                                                }
+                                                              }
+                                                            },
                                                             checkpoints: {
                                                               title: "Recording checkpoints",
                                                               description: "Capture a checkpoint screenshot after every step while this recording is active and compare each against a persistent baseline stored beside the recording (`<path>.checkpoints/` by default). Baselines seed on the first run; on later runs, per-checkpoint variation is reported in the `stopRecord` step's outputs, and variation beyond `maxVariation` surfaces as a WARNING. If `false` or unset, no checkpoints are captured.",
@@ -34920,6 +34970,56 @@ var init_schemas = __esm({
                                                                   }
                                                                 ]
                                                               },
+                                                              verify: {
+                                                                title: "Recording verify guards",
+                                                                description: "Structural assertions on the produced video file, evaluated when the recording stops. Unlike checkpoint drift (a WARNING), a violated guard FAILs the stopRecord step \u2014 these are properties you explicitly demand of the artifact.",
+                                                                type: "object",
+                                                                additionalProperties: false,
+                                                                properties: {
+                                                                  minDuration: {
+                                                                    type: "number",
+                                                                    description: "Fail if the video is shorter than this many seconds.",
+                                                                    minimum: 0
+                                                                  },
+                                                                  maxDuration: {
+                                                                    type: "number",
+                                                                    description: "Fail if the video is longer than this many seconds.",
+                                                                    minimum: 0
+                                                                  },
+                                                                  resolution: {
+                                                                    description: "Verify the video's dimensions (\xB12 pixels \u2014 encoders round to even dimensions). `true` compares against the capture plan's resolved expectation (the crop rectangle when a window/viewport crop applied, else the capture frame size; skipped when no expectation exists for the engine). An object compares literal dimensions.",
+                                                                    anyOf: [
+                                                                      {
+                                                                        type: "boolean",
+                                                                        title: "Verify resolution (boolean)"
+                                                                      },
+                                                                      {
+                                                                        type: "object",
+                                                                        title: "Verify resolution (detailed)",
+                                                                        additionalProperties: false,
+                                                                        required: [
+                                                                          "width",
+                                                                          "height"
+                                                                        ],
+                                                                        properties: {
+                                                                          width: {
+                                                                            type: "integer",
+                                                                            minimum: 1
+                                                                          },
+                                                                          height: {
+                                                                            type: "integer",
+                                                                            minimum: 1
+                                                                          }
+                                                                        }
+                                                                      }
+                                                                    ]
+                                                                  },
+                                                                  notBlack: {
+                                                                    type: "boolean",
+                                                                    description: "Fail if the video is essentially all black (black frames cover 95% or more of its duration) \u2014 the classic symptom of a broken screen capture."
+                                                                  }
+                                                                }
+                                                              },
                                                               checkpoints: {
                                                                 title: "Recording checkpoints",
                                                                 description: "Capture a checkpoint screenshot after every step while this recording is active and compare each against a persistent baseline stored beside the recording (`<path>.checkpoints/` by default). Baselines seed on the first run; on later runs, per-checkpoint variation is reported in the `stopRecord` step's outputs, and variation beyond `maxVariation` surfaces as a WARNING. If `false` or unset, no checkpoints are captured.",
@@ -80287,6 +80387,56 @@ var init_schemas = __esm({
                                                   }
                                                 ]
                                               },
+                                              verify: {
+                                                title: "Recording verify guards",
+                                                description: "Structural assertions on the produced video file, evaluated when the recording stops. Unlike checkpoint drift (a WARNING), a violated guard FAILs the stopRecord step \u2014 these are properties you explicitly demand of the artifact.",
+                                                type: "object",
+                                                additionalProperties: false,
+                                                properties: {
+                                                  minDuration: {
+                                                    type: "number",
+                                                    description: "Fail if the video is shorter than this many seconds.",
+                                                    minimum: 0
+                                                  },
+                                                  maxDuration: {
+                                                    type: "number",
+                                                    description: "Fail if the video is longer than this many seconds.",
+                                                    minimum: 0
+                                                  },
+                                                  resolution: {
+                                                    description: "Verify the video's dimensions (\xB12 pixels \u2014 encoders round to even dimensions). `true` compares against the capture plan's resolved expectation (the crop rectangle when a window/viewport crop applied, else the capture frame size; skipped when no expectation exists for the engine). An object compares literal dimensions.",
+                                                    anyOf: [
+                                                      {
+                                                        type: "boolean",
+                                                        title: "Verify resolution (boolean)"
+                                                      },
+                                                      {
+                                                        type: "object",
+                                                        title: "Verify resolution (detailed)",
+                                                        additionalProperties: false,
+                                                        required: [
+                                                          "width",
+                                                          "height"
+                                                        ],
+                                                        properties: {
+                                                          width: {
+                                                            type: "integer",
+                                                            minimum: 1
+                                                          },
+                                                          height: {
+                                                            type: "integer",
+                                                            minimum: 1
+                                                          }
+                                                        }
+                                                      }
+                                                    ]
+                                                  },
+                                                  notBlack: {
+                                                    type: "boolean",
+                                                    description: "Fail if the video is essentially all black (black frames cover 95% or more of its duration) \u2014 the classic symptom of a broken screen capture."
+                                                  }
+                                                }
+                                              },
                                               checkpoints: {
                                                 title: "Recording checkpoints",
                                                 description: "Capture a checkpoint screenshot after every step while this recording is active and compare each against a persistent baseline stored beside the recording (`<path>.checkpoints/` by default). Baselines seed on the first run; on later runs, per-checkpoint variation is reported in the `stopRecord` step's outputs, and variation beyond `maxVariation` surfaces as a WARNING. If `false` or unset, no checkpoints are captured.",
@@ -80642,6 +80792,56 @@ var init_schemas = __esm({
                                                     }
                                                   ]
                                                 },
+                                                verify: {
+                                                  title: "Recording verify guards",
+                                                  description: "Structural assertions on the produced video file, evaluated when the recording stops. Unlike checkpoint drift (a WARNING), a violated guard FAILs the stopRecord step \u2014 these are properties you explicitly demand of the artifact.",
+                                                  type: "object",
+                                                  additionalProperties: false,
+                                                  properties: {
+                                                    minDuration: {
+                                                      type: "number",
+                                                      description: "Fail if the video is shorter than this many seconds.",
+                                                      minimum: 0
+                                                    },
+                                                    maxDuration: {
+                                                      type: "number",
+                                                      description: "Fail if the video is longer than this many seconds.",
+                                                      minimum: 0
+                                                    },
+                                                    resolution: {
+                                                      description: "Verify the video's dimensions (\xB12 pixels \u2014 encoders round to even dimensions). `true` compares against the capture plan's resolved expectation (the crop rectangle when a window/viewport crop applied, else the capture frame size; skipped when no expectation exists for the engine). An object compares literal dimensions.",
+                                                      anyOf: [
+                                                        {
+                                                          type: "boolean",
+                                                          title: "Verify resolution (boolean)"
+                                                        },
+                                                        {
+                                                          type: "object",
+                                                          title: "Verify resolution (detailed)",
+                                                          additionalProperties: false,
+                                                          required: [
+                                                            "width",
+                                                            "height"
+                                                          ],
+                                                          properties: {
+                                                            width: {
+                                                              type: "integer",
+                                                              minimum: 1
+                                                            },
+                                                            height: {
+                                                              type: "integer",
+                                                              minimum: 1
+                                                            }
+                                                          }
+                                                        }
+                                                      ]
+                                                    },
+                                                    notBlack: {
+                                                      type: "boolean",
+                                                      description: "Fail if the video is essentially all black (black frames cover 95% or more of its duration) \u2014 the classic symptom of a broken screen capture."
+                                                    }
+                                                  }
+                                                },
                                                 checkpoints: {
                                                   title: "Recording checkpoints",
                                                   description: "Capture a checkpoint screenshot after every step while this recording is active and compare each against a persistent baseline stored beside the recording (`<path>.checkpoints/` by default). Baselines seed on the first run; on later runs, per-checkpoint variation is reported in the `stopRecord` step's outputs, and variation beyond `maxVariation` surfaces as a WARNING. If `false` or unset, no checkpoints are captured.",
@@ -106649,6 +106849,56 @@ var init_schemas = __esm({
                   }
                 ]
               },
+              verify: {
+                title: "Recording verify guards",
+                description: "Structural assertions on the produced video file, evaluated when the recording stops. Unlike checkpoint drift (a WARNING), a violated guard FAILs the stopRecord step \u2014 these are properties you explicitly demand of the artifact.",
+                type: "object",
+                additionalProperties: false,
+                properties: {
+                  minDuration: {
+                    type: "number",
+                    description: "Fail if the video is shorter than this many seconds.",
+                    minimum: 0
+                  },
+                  maxDuration: {
+                    type: "number",
+                    description: "Fail if the video is longer than this many seconds.",
+                    minimum: 0
+                  },
+                  resolution: {
+                    description: "Verify the video's dimensions (\xB12 pixels \u2014 encoders round to even dimensions). `true` compares against the capture plan's resolved expectation (the crop rectangle when a window/viewport crop applied, else the capture frame size; skipped when no expectation exists for the engine). An object compares literal dimensions.",
+                    anyOf: [
+                      {
+                        type: "boolean",
+                        title: "Verify resolution (boolean)"
+                      },
+                      {
+                        type: "object",
+                        title: "Verify resolution (detailed)",
+                        additionalProperties: false,
+                        required: [
+                          "width",
+                          "height"
+                        ],
+                        properties: {
+                          width: {
+                            type: "integer",
+                            minimum: 1
+                          },
+                          height: {
+                            type: "integer",
+                            minimum: 1
+                          }
+                        }
+                      }
+                    ]
+                  },
+                  notBlack: {
+                    type: "boolean",
+                    description: "Fail if the video is essentially all black (black frames cover 95% or more of its duration) \u2014 the classic symptom of a broken screen capture."
+                  }
+                }
+              },
               checkpoints: {
                 title: "Recording checkpoints",
                 description: "Capture a checkpoint screenshot after every step while this recording is active and compare each against a persistent baseline stored beside the recording (`<path>.checkpoints/` by default). Baselines seed on the first run; on later runs, per-checkpoint variation is reported in the `stopRecord` step's outputs, and variation beyond `maxVariation` surfaces as a WARNING. If `false` or unset, no checkpoints are captured.",
@@ -107004,6 +107254,56 @@ var init_schemas = __esm({
                     }
                   ]
                 },
+                verify: {
+                  title: "Recording verify guards",
+                  description: "Structural assertions on the produced video file, evaluated when the recording stops. Unlike checkpoint drift (a WARNING), a violated guard FAILs the stopRecord step \u2014 these are properties you explicitly demand of the artifact.",
+                  type: "object",
+                  additionalProperties: false,
+                  properties: {
+                    minDuration: {
+                      type: "number",
+                      description: "Fail if the video is shorter than this many seconds.",
+                      minimum: 0
+                    },
+                    maxDuration: {
+                      type: "number",
+                      description: "Fail if the video is longer than this many seconds.",
+                      minimum: 0
+                    },
+                    resolution: {
+                      description: "Verify the video's dimensions (\xB12 pixels \u2014 encoders round to even dimensions). `true` compares against the capture plan's resolved expectation (the crop rectangle when a window/viewport crop applied, else the capture frame size; skipped when no expectation exists for the engine). An object compares literal dimensions.",
+                      anyOf: [
+                        {
+                          type: "boolean",
+                          title: "Verify resolution (boolean)"
+                        },
+                        {
+                          type: "object",
+                          title: "Verify resolution (detailed)",
+                          additionalProperties: false,
+                          required: [
+                            "width",
+                            "height"
+                          ],
+                          properties: {
+                            width: {
+                              type: "integer",
+                              minimum: 1
+                            },
+                            height: {
+                              type: "integer",
+                              minimum: 1
+                            }
+                          }
+                        }
+                      ]
+                    },
+                    notBlack: {
+                      type: "boolean",
+                      description: "Fail if the video is essentially all black (black frames cover 95% or more of its duration) \u2014 the classic symptom of a broken screen capture."
+                    }
+                  }
+                },
                 checkpoints: {
                   title: "Recording checkpoints",
                   description: "Capture a checkpoint screenshot after every step while this recording is active and compare each against a persistent baseline stored beside the recording (`<path>.checkpoints/` by default). Baselines seed on the first run; on later runs, per-checkpoint variation is reported in the `stopRecord` step's outputs, and variation beyond `maxVariation` surfaces as a WARNING. If `false` or unset, no checkpoints are captured.",
@@ -139373,6 +139673,56 @@ var init_schemas = __esm({
                                                                     }
                                                                   ]
                                                                 },
+                                                                verify: {
+                                                                  title: "Recording verify guards",
+                                                                  description: "Structural assertions on the produced video file, evaluated when the recording stops. Unlike checkpoint drift (a WARNING), a violated guard FAILs the stopRecord step \u2014 these are properties you explicitly demand of the artifact.",
+                                                                  type: "object",
+                                                                  additionalProperties: false,
+                                                                  properties: {
+                                                                    minDuration: {
+                                                                      type: "number",
+                                                                      description: "Fail if the video is shorter than this many seconds.",
+                                                                      minimum: 0
+                                                                    },
+                                                                    maxDuration: {
+                                                                      type: "number",
+                                                                      description: "Fail if the video is longer than this many seconds.",
+                                                                      minimum: 0
+                                                                    },
+                                                                    resolution: {
+                                                                      description: "Verify the video's dimensions (\xB12 pixels \u2014 encoders round to even dimensions). `true` compares against the capture plan's resolved expectation (the crop rectangle when a window/viewport crop applied, else the capture frame size; skipped when no expectation exists for the engine). An object compares literal dimensions.",
+                                                                      anyOf: [
+                                                                        {
+                                                                          type: "boolean",
+                                                                          title: "Verify resolution (boolean)"
+                                                                        },
+                                                                        {
+                                                                          type: "object",
+                                                                          title: "Verify resolution (detailed)",
+                                                                          additionalProperties: false,
+                                                                          required: [
+                                                                            "width",
+                                                                            "height"
+                                                                          ],
+                                                                          properties: {
+                                                                            width: {
+                                                                              type: "integer",
+                                                                              minimum: 1
+                                                                            },
+                                                                            height: {
+                                                                              type: "integer",
+                                                                              minimum: 1
+                                                                            }
+                                                                          }
+                                                                        }
+                                                                      ]
+                                                                    },
+                                                                    notBlack: {
+                                                                      type: "boolean",
+                                                                      description: "Fail if the video is essentially all black (black frames cover 95% or more of its duration) \u2014 the classic symptom of a broken screen capture."
+                                                                    }
+                                                                  }
+                                                                },
                                                                 checkpoints: {
                                                                   title: "Recording checkpoints",
                                                                   description: "Capture a checkpoint screenshot after every step while this recording is active and compare each against a persistent baseline stored beside the recording (`<path>.checkpoints/` by default). Baselines seed on the first run; on later runs, per-checkpoint variation is reported in the `stopRecord` step's outputs, and variation beyond `maxVariation` surfaces as a WARNING. If `false` or unset, no checkpoints are captured.",
@@ -139728,6 +140078,56 @@ var init_schemas = __esm({
                                                                       }
                                                                     ]
                                                                   },
+                                                                  verify: {
+                                                                    title: "Recording verify guards",
+                                                                    description: "Structural assertions on the produced video file, evaluated when the recording stops. Unlike checkpoint drift (a WARNING), a violated guard FAILs the stopRecord step \u2014 these are properties you explicitly demand of the artifact.",
+                                                                    type: "object",
+                                                                    additionalProperties: false,
+                                                                    properties: {
+                                                                      minDuration: {
+                                                                        type: "number",
+                                                                        description: "Fail if the video is shorter than this many seconds.",
+                                                                        minimum: 0
+                                                                      },
+                                                                      maxDuration: {
+                                                                        type: "number",
+                                                                        description: "Fail if the video is longer than this many seconds.",
+                                                                        minimum: 0
+                                                                      },
+                                                                      resolution: {
+                                                                        description: "Verify the video's dimensions (\xB12 pixels \u2014 encoders round to even dimensions). `true` compares against the capture plan's resolved expectation (the crop rectangle when a window/viewport crop applied, else the capture frame size; skipped when no expectation exists for the engine). An object compares literal dimensions.",
+                                                                        anyOf: [
+                                                                          {
+                                                                            type: "boolean",
+                                                                            title: "Verify resolution (boolean)"
+                                                                          },
+                                                                          {
+                                                                            type: "object",
+                                                                            title: "Verify resolution (detailed)",
+                                                                            additionalProperties: false,
+                                                                            required: [
+                                                                              "width",
+                                                                              "height"
+                                                                            ],
+                                                                            properties: {
+                                                                              width: {
+                                                                                type: "integer",
+                                                                                minimum: 1
+                                                                              },
+                                                                              height: {
+                                                                                type: "integer",
+                                                                                minimum: 1
+                                                                              }
+                                                                            }
+                                                                          }
+                                                                        ]
+                                                                      },
+                                                                      notBlack: {
+                                                                        type: "boolean",
+                                                                        description: "Fail if the video is essentially all black (black frames cover 95% or more of its duration) \u2014 the classic symptom of a broken screen capture."
+                                                                      }
+                                                                    }
+                                                                  },
                                                                   checkpoints: {
                                                                     title: "Recording checkpoints",
                                                                     description: "Capture a checkpoint screenshot after every step while this recording is active and compare each against a persistent baseline stored beside the recording (`<path>.checkpoints/` by default). Baselines seed on the first run; on later runs, per-checkpoint variation is reported in the `stopRecord` step's outputs, and variation beyond `maxVariation` surfaces as a WARNING. If `false` or unset, no checkpoints are captured.",
@@ -185095,6 +185495,56 @@ var init_schemas = __esm({
                                                       }
                                                     ]
                                                   },
+                                                  verify: {
+                                                    title: "Recording verify guards",
+                                                    description: "Structural assertions on the produced video file, evaluated when the recording stops. Unlike checkpoint drift (a WARNING), a violated guard FAILs the stopRecord step \u2014 these are properties you explicitly demand of the artifact.",
+                                                    type: "object",
+                                                    additionalProperties: false,
+                                                    properties: {
+                                                      minDuration: {
+                                                        type: "number",
+                                                        description: "Fail if the video is shorter than this many seconds.",
+                                                        minimum: 0
+                                                      },
+                                                      maxDuration: {
+                                                        type: "number",
+                                                        description: "Fail if the video is longer than this many seconds.",
+                                                        minimum: 0
+                                                      },
+                                                      resolution: {
+                                                        description: "Verify the video's dimensions (\xB12 pixels \u2014 encoders round to even dimensions). `true` compares against the capture plan's resolved expectation (the crop rectangle when a window/viewport crop applied, else the capture frame size; skipped when no expectation exists for the engine). An object compares literal dimensions.",
+                                                        anyOf: [
+                                                          {
+                                                            type: "boolean",
+                                                            title: "Verify resolution (boolean)"
+                                                          },
+                                                          {
+                                                            type: "object",
+                                                            title: "Verify resolution (detailed)",
+                                                            additionalProperties: false,
+                                                            required: [
+                                                              "width",
+                                                              "height"
+                                                            ],
+                                                            properties: {
+                                                              width: {
+                                                                type: "integer",
+                                                                minimum: 1
+                                                              },
+                                                              height: {
+                                                                type: "integer",
+                                                                minimum: 1
+                                                              }
+                                                            }
+                                                          }
+                                                        ]
+                                                      },
+                                                      notBlack: {
+                                                        type: "boolean",
+                                                        description: "Fail if the video is essentially all black (black frames cover 95% or more of its duration) \u2014 the classic symptom of a broken screen capture."
+                                                      }
+                                                    }
+                                                  },
                                                   checkpoints: {
                                                     title: "Recording checkpoints",
                                                     description: "Capture a checkpoint screenshot after every step while this recording is active and compare each against a persistent baseline stored beside the recording (`<path>.checkpoints/` by default). Baselines seed on the first run; on later runs, per-checkpoint variation is reported in the `stopRecord` step's outputs, and variation beyond `maxVariation` surfaces as a WARNING. If `false` or unset, no checkpoints are captured.",
@@ -185450,6 +185900,56 @@ var init_schemas = __esm({
                                                         }
                                                       ]
                                                     },
+                                                    verify: {
+                                                      title: "Recording verify guards",
+                                                      description: "Structural assertions on the produced video file, evaluated when the recording stops. Unlike checkpoint drift (a WARNING), a violated guard FAILs the stopRecord step \u2014 these are properties you explicitly demand of the artifact.",
+                                                      type: "object",
+                                                      additionalProperties: false,
+                                                      properties: {
+                                                        minDuration: {
+                                                          type: "number",
+                                                          description: "Fail if the video is shorter than this many seconds.",
+                                                          minimum: 0
+                                                        },
+                                                        maxDuration: {
+                                                          type: "number",
+                                                          description: "Fail if the video is longer than this many seconds.",
+                                                          minimum: 0
+                                                        },
+                                                        resolution: {
+                                                          description: "Verify the video's dimensions (\xB12 pixels \u2014 encoders round to even dimensions). `true` compares against the capture plan's resolved expectation (the crop rectangle when a window/viewport crop applied, else the capture frame size; skipped when no expectation exists for the engine). An object compares literal dimensions.",
+                                                          anyOf: [
+                                                            {
+                                                              type: "boolean",
+                                                              title: "Verify resolution (boolean)"
+                                                            },
+                                                            {
+                                                              type: "object",
+                                                              title: "Verify resolution (detailed)",
+                                                              additionalProperties: false,
+                                                              required: [
+                                                                "width",
+                                                                "height"
+                                                              ],
+                                                              properties: {
+                                                                width: {
+                                                                  type: "integer",
+                                                                  minimum: 1
+                                                                },
+                                                                height: {
+                                                                  type: "integer",
+                                                                  minimum: 1
+                                                                }
+                                                              }
+                                                            }
+                                                          ]
+                                                        },
+                                                        notBlack: {
+                                                          type: "boolean",
+                                                          description: "Fail if the video is essentially all black (black frames cover 95% or more of its duration) \u2014 the classic symptom of a broken screen capture."
+                                                        }
+                                                      }
+                                                    },
                                                     checkpoints: {
                                                       title: "Recording checkpoints",
                                                       description: "Capture a checkpoint screenshot after every step while this recording is active and compare each against a persistent baseline stored beside the recording (`<path>.checkpoints/` by default). Baselines seed on the first run; on later runs, per-checkpoint variation is reported in the `stopRecord` step's outputs, and variation beyond `maxVariation` surfaces as a WARNING. If `false` or unset, no checkpoints are captured.",
@@ -232556,6 +233056,56 @@ var init_schemas = __esm({
                                                         }
                                                       ]
                                                     },
+                                                    verify: {
+                                                      title: "Recording verify guards",
+                                                      description: "Structural assertions on the produced video file, evaluated when the recording stops. Unlike checkpoint drift (a WARNING), a violated guard FAILs the stopRecord step \u2014 these are properties you explicitly demand of the artifact.",
+                                                      type: "object",
+                                                      additionalProperties: false,
+                                                      properties: {
+                                                        minDuration: {
+                                                          type: "number",
+                                                          description: "Fail if the video is shorter than this many seconds.",
+                                                          minimum: 0
+                                                        },
+                                                        maxDuration: {
+                                                          type: "number",
+                                                          description: "Fail if the video is longer than this many seconds.",
+                                                          minimum: 0
+                                                        },
+                                                        resolution: {
+                                                          description: "Verify the video's dimensions (\xB12 pixels \u2014 encoders round to even dimensions). `true` compares against the capture plan's resolved expectation (the crop rectangle when a window/viewport crop applied, else the capture frame size; skipped when no expectation exists for the engine). An object compares literal dimensions.",
+                                                          anyOf: [
+                                                            {
+                                                              type: "boolean",
+                                                              title: "Verify resolution (boolean)"
+                                                            },
+                                                            {
+                                                              type: "object",
+                                                              title: "Verify resolution (detailed)",
+                                                              additionalProperties: false,
+                                                              required: [
+                                                                "width",
+                                                                "height"
+                                                              ],
+                                                              properties: {
+                                                                width: {
+                                                                  type: "integer",
+                                                                  minimum: 1
+                                                                },
+                                                                height: {
+                                                                  type: "integer",
+                                                                  minimum: 1
+                                                                }
+                                                              }
+                                                            }
+                                                          ]
+                                                        },
+                                                        notBlack: {
+                                                          type: "boolean",
+                                                          description: "Fail if the video is essentially all black (black frames cover 95% or more of its duration) \u2014 the classic symptom of a broken screen capture."
+                                                        }
+                                                      }
+                                                    },
                                                     checkpoints: {
                                                       title: "Recording checkpoints",
                                                       description: "Capture a checkpoint screenshot after every step while this recording is active and compare each against a persistent baseline stored beside the recording (`<path>.checkpoints/` by default). Baselines seed on the first run; on later runs, per-checkpoint variation is reported in the `stopRecord` step's outputs, and variation beyond `maxVariation` surfaces as a WARNING. If `false` or unset, no checkpoints are captured.",
@@ -232911,6 +233461,56 @@ var init_schemas = __esm({
                                                           }
                                                         ]
                                                       },
+                                                      verify: {
+                                                        title: "Recording verify guards",
+                                                        description: "Structural assertions on the produced video file, evaluated when the recording stops. Unlike checkpoint drift (a WARNING), a violated guard FAILs the stopRecord step \u2014 these are properties you explicitly demand of the artifact.",
+                                                        type: "object",
+                                                        additionalProperties: false,
+                                                        properties: {
+                                                          minDuration: {
+                                                            type: "number",
+                                                            description: "Fail if the video is shorter than this many seconds.",
+                                                            minimum: 0
+                                                          },
+                                                          maxDuration: {
+                                                            type: "number",
+                                                            description: "Fail if the video is longer than this many seconds.",
+                                                            minimum: 0
+                                                          },
+                                                          resolution: {
+                                                            description: "Verify the video's dimensions (\xB12 pixels \u2014 encoders round to even dimensions). `true` compares against the capture plan's resolved expectation (the crop rectangle when a window/viewport crop applied, else the capture frame size; skipped when no expectation exists for the engine). An object compares literal dimensions.",
+                                                            anyOf: [
+                                                              {
+                                                                type: "boolean",
+                                                                title: "Verify resolution (boolean)"
+                                                              },
+                                                              {
+                                                                type: "object",
+                                                                title: "Verify resolution (detailed)",
+                                                                additionalProperties: false,
+                                                                required: [
+                                                                  "width",
+                                                                  "height"
+                                                                ],
+                                                                properties: {
+                                                                  width: {
+                                                                    type: "integer",
+                                                                    minimum: 1
+                                                                  },
+                                                                  height: {
+                                                                    type: "integer",
+                                                                    minimum: 1
+                                                                  }
+                                                                }
+                                                              }
+                                                            ]
+                                                          },
+                                                          notBlack: {
+                                                            type: "boolean",
+                                                            description: "Fail if the video is essentially all black (black frames cover 95% or more of its duration) \u2014 the classic symptom of a broken screen capture."
+                                                          }
+                                                        }
+                                                      },
                                                       checkpoints: {
                                                         title: "Recording checkpoints",
                                                         description: "Capture a checkpoint screenshot after every step while this recording is active and compare each against a persistent baseline stored beside the recording (`<path>.checkpoints/` by default). Baselines seed on the first run; on later runs, per-checkpoint variation is reported in the `stopRecord` step's outputs, and variation beyond `maxVariation` surfaces as a WARNING. If `false` or unset, no checkpoints are captured.",
@@ -277540,6 +278140,56 @@ var init_schemas = __esm({
                                                               }
                                                             ]
                                                           },
+                                                          verify: {
+                                                            title: "Recording verify guards",
+                                                            description: "Structural assertions on the produced video file, evaluated when the recording stops. Unlike checkpoint drift (a WARNING), a violated guard FAILs the stopRecord step \u2014 these are properties you explicitly demand of the artifact.",
+                                                            type: "object",
+                                                            additionalProperties: false,
+                                                            properties: {
+                                                              minDuration: {
+                                                                type: "number",
+                                                                description: "Fail if the video is shorter than this many seconds.",
+                                                                minimum: 0
+                                                              },
+                                                              maxDuration: {
+                                                                type: "number",
+                                                                description: "Fail if the video is longer than this many seconds.",
+                                                                minimum: 0
+                                                              },
+                                                              resolution: {
+                                                                description: "Verify the video's dimensions (\xB12 pixels \u2014 encoders round to even dimensions). `true` compares against the capture plan's resolved expectation (the crop rectangle when a window/viewport crop applied, else the capture frame size; skipped when no expectation exists for the engine). An object compares literal dimensions.",
+                                                                anyOf: [
+                                                                  {
+                                                                    type: "boolean",
+                                                                    title: "Verify resolution (boolean)"
+                                                                  },
+                                                                  {
+                                                                    type: "object",
+                                                                    title: "Verify resolution (detailed)",
+                                                                    additionalProperties: false,
+                                                                    required: [
+                                                                      "width",
+                                                                      "height"
+                                                                    ],
+                                                                    properties: {
+                                                                      width: {
+                                                                        type: "integer",
+                                                                        minimum: 1
+                                                                      },
+                                                                      height: {
+                                                                        type: "integer",
+                                                                        minimum: 1
+                                                                      }
+                                                                    }
+                                                                  }
+                                                                ]
+                                                              },
+                                                              notBlack: {
+                                                                type: "boolean",
+                                                                description: "Fail if the video is essentially all black (black frames cover 95% or more of its duration) \u2014 the classic symptom of a broken screen capture."
+                                                              }
+                                                            }
+                                                          },
                                                           checkpoints: {
                                                             title: "Recording checkpoints",
                                                             description: "Capture a checkpoint screenshot after every step while this recording is active and compare each against a persistent baseline stored beside the recording (`<path>.checkpoints/` by default). Baselines seed on the first run; on later runs, per-checkpoint variation is reported in the `stopRecord` step's outputs, and variation beyond `maxVariation` surfaces as a WARNING. If `false` or unset, no checkpoints are captured.",
@@ -277895,6 +278545,56 @@ var init_schemas = __esm({
                                                                 }
                                                               ]
                                                             },
+                                                            verify: {
+                                                              title: "Recording verify guards",
+                                                              description: "Structural assertions on the produced video file, evaluated when the recording stops. Unlike checkpoint drift (a WARNING), a violated guard FAILs the stopRecord step \u2014 these are properties you explicitly demand of the artifact.",
+                                                              type: "object",
+                                                              additionalProperties: false,
+                                                              properties: {
+                                                                minDuration: {
+                                                                  type: "number",
+                                                                  description: "Fail if the video is shorter than this many seconds.",
+                                                                  minimum: 0
+                                                                },
+                                                                maxDuration: {
+                                                                  type: "number",
+                                                                  description: "Fail if the video is longer than this many seconds.",
+                                                                  minimum: 0
+                                                                },
+                                                                resolution: {
+                                                                  description: "Verify the video's dimensions (\xB12 pixels \u2014 encoders round to even dimensions). `true` compares against the capture plan's resolved expectation (the crop rectangle when a window/viewport crop applied, else the capture frame size; skipped when no expectation exists for the engine). An object compares literal dimensions.",
+                                                                  anyOf: [
+                                                                    {
+                                                                      type: "boolean",
+                                                                      title: "Verify resolution (boolean)"
+                                                                    },
+                                                                    {
+                                                                      type: "object",
+                                                                      title: "Verify resolution (detailed)",
+                                                                      additionalProperties: false,
+                                                                      required: [
+                                                                        "width",
+                                                                        "height"
+                                                                      ],
+                                                                      properties: {
+                                                                        width: {
+                                                                          type: "integer",
+                                                                          minimum: 1
+                                                                        },
+                                                                        height: {
+                                                                          type: "integer",
+                                                                          minimum: 1
+                                                                        }
+                                                                      }
+                                                                    }
+                                                                  ]
+                                                                },
+                                                                notBlack: {
+                                                                  type: "boolean",
+                                                                  description: "Fail if the video is essentially all black (black frames cover 95% or more of its duration) \u2014 the classic symptom of a broken screen capture."
+                                                                }
+                                                              }
+                                                            },
                                                             checkpoints: {
                                                               title: "Recording checkpoints",
                                                               description: "Capture a checkpoint screenshot after every step while this recording is active and compare each against a persistent baseline stored beside the recording (`<path>.checkpoints/` by default). Baselines seed on the first run; on later runs, per-checkpoint variation is reported in the `stopRecord` step's outputs, and variation beyond `maxVariation` surfaces as a WARNING. If `false` or unset, no checkpoints are captured.",
@@ -325485,6 +326185,56 @@ var init_schemas = __esm({
                                                         }
                                                       ]
                                                     },
+                                                    verify: {
+                                                      title: "Recording verify guards",
+                                                      description: "Structural assertions on the produced video file, evaluated when the recording stops. Unlike checkpoint drift (a WARNING), a violated guard FAILs the stopRecord step \u2014 these are properties you explicitly demand of the artifact.",
+                                                      type: "object",
+                                                      additionalProperties: false,
+                                                      properties: {
+                                                        minDuration: {
+                                                          type: "number",
+                                                          description: "Fail if the video is shorter than this many seconds.",
+                                                          minimum: 0
+                                                        },
+                                                        maxDuration: {
+                                                          type: "number",
+                                                          description: "Fail if the video is longer than this many seconds.",
+                                                          minimum: 0
+                                                        },
+                                                        resolution: {
+                                                          description: "Verify the video's dimensions (\xB12 pixels \u2014 encoders round to even dimensions). `true` compares against the capture plan's resolved expectation (the crop rectangle when a window/viewport crop applied, else the capture frame size; skipped when no expectation exists for the engine). An object compares literal dimensions.",
+                                                          anyOf: [
+                                                            {
+                                                              type: "boolean",
+                                                              title: "Verify resolution (boolean)"
+                                                            },
+                                                            {
+                                                              type: "object",
+                                                              title: "Verify resolution (detailed)",
+                                                              additionalProperties: false,
+                                                              required: [
+                                                                "width",
+                                                                "height"
+                                                              ],
+                                                              properties: {
+                                                                width: {
+                                                                  type: "integer",
+                                                                  minimum: 1
+                                                                },
+                                                                height: {
+                                                                  type: "integer",
+                                                                  minimum: 1
+                                                                }
+                                                              }
+                                                            }
+                                                          ]
+                                                        },
+                                                        notBlack: {
+                                                          type: "boolean",
+                                                          description: "Fail if the video is essentially all black (black frames cover 95% or more of its duration) \u2014 the classic symptom of a broken screen capture."
+                                                        }
+                                                      }
+                                                    },
                                                     checkpoints: {
                                                       title: "Recording checkpoints",
                                                       description: "Capture a checkpoint screenshot after every step while this recording is active and compare each against a persistent baseline stored beside the recording (`<path>.checkpoints/` by default). Baselines seed on the first run; on later runs, per-checkpoint variation is reported in the `stopRecord` step's outputs, and variation beyond `maxVariation` surfaces as a WARNING. If `false` or unset, no checkpoints are captured.",
@@ -325840,6 +326590,56 @@ var init_schemas = __esm({
                                                           }
                                                         ]
                                                       },
+                                                      verify: {
+                                                        title: "Recording verify guards",
+                                                        description: "Structural assertions on the produced video file, evaluated when the recording stops. Unlike checkpoint drift (a WARNING), a violated guard FAILs the stopRecord step \u2014 these are properties you explicitly demand of the artifact.",
+                                                        type: "object",
+                                                        additionalProperties: false,
+                                                        properties: {
+                                                          minDuration: {
+                                                            type: "number",
+                                                            description: "Fail if the video is shorter than this many seconds.",
+                                                            minimum: 0
+                                                          },
+                                                          maxDuration: {
+                                                            type: "number",
+                                                            description: "Fail if the video is longer than this many seconds.",
+                                                            minimum: 0
+                                                          },
+                                                          resolution: {
+                                                            description: "Verify the video's dimensions (\xB12 pixels \u2014 encoders round to even dimensions). `true` compares against the capture plan's resolved expectation (the crop rectangle when a window/viewport crop applied, else the capture frame size; skipped when no expectation exists for the engine). An object compares literal dimensions.",
+                                                            anyOf: [
+                                                              {
+                                                                type: "boolean",
+                                                                title: "Verify resolution (boolean)"
+                                                              },
+                                                              {
+                                                                type: "object",
+                                                                title: "Verify resolution (detailed)",
+                                                                additionalProperties: false,
+                                                                required: [
+                                                                  "width",
+                                                                  "height"
+                                                                ],
+                                                                properties: {
+                                                                  width: {
+                                                                    type: "integer",
+                                                                    minimum: 1
+                                                                  },
+                                                                  height: {
+                                                                    type: "integer",
+                                                                    minimum: 1
+                                                                  }
+                                                                }
+                                                              }
+                                                            ]
+                                                          },
+                                                          notBlack: {
+                                                            type: "boolean",
+                                                            description: "Fail if the video is essentially all black (black frames cover 95% or more of its duration) \u2014 the classic symptom of a broken screen capture."
+                                                          }
+                                                        }
+                                                      },
                                                       checkpoints: {
                                                         title: "Recording checkpoints",
                                                         description: "Capture a checkpoint screenshot after every step while this recording is active and compare each against a persistent baseline stored beside the recording (`<path>.checkpoints/` by default). Baselines seed on the first run; on later runs, per-checkpoint variation is reported in the `stopRecord` step's outputs, and variation beyond `maxVariation` surfaces as a WARNING. If `false` or unset, no checkpoints are captured.",
@@ -370469,6 +371269,56 @@ var init_schemas = __esm({
                                                               }
                                                             ]
                                                           },
+                                                          verify: {
+                                                            title: "Recording verify guards",
+                                                            description: "Structural assertions on the produced video file, evaluated when the recording stops. Unlike checkpoint drift (a WARNING), a violated guard FAILs the stopRecord step \u2014 these are properties you explicitly demand of the artifact.",
+                                                            type: "object",
+                                                            additionalProperties: false,
+                                                            properties: {
+                                                              minDuration: {
+                                                                type: "number",
+                                                                description: "Fail if the video is shorter than this many seconds.",
+                                                                minimum: 0
+                                                              },
+                                                              maxDuration: {
+                                                                type: "number",
+                                                                description: "Fail if the video is longer than this many seconds.",
+                                                                minimum: 0
+                                                              },
+                                                              resolution: {
+                                                                description: "Verify the video's dimensions (\xB12 pixels \u2014 encoders round to even dimensions). `true` compares against the capture plan's resolved expectation (the crop rectangle when a window/viewport crop applied, else the capture frame size; skipped when no expectation exists for the engine). An object compares literal dimensions.",
+                                                                anyOf: [
+                                                                  {
+                                                                    type: "boolean",
+                                                                    title: "Verify resolution (boolean)"
+                                                                  },
+                                                                  {
+                                                                    type: "object",
+                                                                    title: "Verify resolution (detailed)",
+                                                                    additionalProperties: false,
+                                                                    required: [
+                                                                      "width",
+                                                                      "height"
+                                                                    ],
+                                                                    properties: {
+                                                                      width: {
+                                                                        type: "integer",
+                                                                        minimum: 1
+                                                                      },
+                                                                      height: {
+                                                                        type: "integer",
+                                                                        minimum: 1
+                                                                      }
+                                                                    }
+                                                                  }
+                                                                ]
+                                                              },
+                                                              notBlack: {
+                                                                type: "boolean",
+                                                                description: "Fail if the video is essentially all black (black frames cover 95% or more of its duration) \u2014 the classic symptom of a broken screen capture."
+                                                              }
+                                                            }
+                                                          },
                                                           checkpoints: {
                                                             title: "Recording checkpoints",
                                                             description: "Capture a checkpoint screenshot after every step while this recording is active and compare each against a persistent baseline stored beside the recording (`<path>.checkpoints/` by default). Baselines seed on the first run; on later runs, per-checkpoint variation is reported in the `stopRecord` step's outputs, and variation beyond `maxVariation` surfaces as a WARNING. If `false` or unset, no checkpoints are captured.",
@@ -370824,6 +371674,56 @@ var init_schemas = __esm({
                                                                 }
                                                               ]
                                                             },
+                                                            verify: {
+                                                              title: "Recording verify guards",
+                                                              description: "Structural assertions on the produced video file, evaluated when the recording stops. Unlike checkpoint drift (a WARNING), a violated guard FAILs the stopRecord step \u2014 these are properties you explicitly demand of the artifact.",
+                                                              type: "object",
+                                                              additionalProperties: false,
+                                                              properties: {
+                                                                minDuration: {
+                                                                  type: "number",
+                                                                  description: "Fail if the video is shorter than this many seconds.",
+                                                                  minimum: 0
+                                                                },
+                                                                maxDuration: {
+                                                                  type: "number",
+                                                                  description: "Fail if the video is longer than this many seconds.",
+                                                                  minimum: 0
+                                                                },
+                                                                resolution: {
+                                                                  description: "Verify the video's dimensions (\xB12 pixels \u2014 encoders round to even dimensions). `true` compares against the capture plan's resolved expectation (the crop rectangle when a window/viewport crop applied, else the capture frame size; skipped when no expectation exists for the engine). An object compares literal dimensions.",
+                                                                  anyOf: [
+                                                                    {
+                                                                      type: "boolean",
+                                                                      title: "Verify resolution (boolean)"
+                                                                    },
+                                                                    {
+                                                                      type: "object",
+                                                                      title: "Verify resolution (detailed)",
+                                                                      additionalProperties: false,
+                                                                      required: [
+                                                                        "width",
+                                                                        "height"
+                                                                      ],
+                                                                      properties: {
+                                                                        width: {
+                                                                          type: "integer",
+                                                                          minimum: 1
+                                                                        },
+                                                                        height: {
+                                                                          type: "integer",
+                                                                          minimum: 1
+                                                                        }
+                                                                      }
+                                                                    }
+                                                                  ]
+                                                                },
+                                                                notBlack: {
+                                                                  type: "boolean",
+                                                                  description: "Fail if the video is essentially all black (black frames cover 95% or more of its duration) \u2014 the classic symptom of a broken screen capture."
+                                                                }
+                                                              }
+                                                            },
                                                             checkpoints: {
                                                               title: "Recording checkpoints",
                                                               description: "Capture a checkpoint screenshot after every step while this recording is active and compare each against a persistent baseline stored beside the recording (`<path>.checkpoints/` by default). Baselines seed on the first run; on later runs, per-checkpoint variation is reported in the `stopRecord` step's outputs, and variation beyond `maxVariation` surfaces as a WARNING. If `false` or unset, no checkpoints are captured.",
@@ -421744,6 +422644,56 @@ var init_schemas = __esm({
                                               }
                                             ]
                                           },
+                                          verify: {
+                                            title: "Recording verify guards",
+                                            description: "Structural assertions on the produced video file, evaluated when the recording stops. Unlike checkpoint drift (a WARNING), a violated guard FAILs the stopRecord step \u2014 these are properties you explicitly demand of the artifact.",
+                                            type: "object",
+                                            additionalProperties: false,
+                                            properties: {
+                                              minDuration: {
+                                                type: "number",
+                                                description: "Fail if the video is shorter than this many seconds.",
+                                                minimum: 0
+                                              },
+                                              maxDuration: {
+                                                type: "number",
+                                                description: "Fail if the video is longer than this many seconds.",
+                                                minimum: 0
+                                              },
+                                              resolution: {
+                                                description: "Verify the video's dimensions (\xB12 pixels \u2014 encoders round to even dimensions). `true` compares against the capture plan's resolved expectation (the crop rectangle when a window/viewport crop applied, else the capture frame size; skipped when no expectation exists for the engine). An object compares literal dimensions.",
+                                                anyOf: [
+                                                  {
+                                                    type: "boolean",
+                                                    title: "Verify resolution (boolean)"
+                                                  },
+                                                  {
+                                                    type: "object",
+                                                    title: "Verify resolution (detailed)",
+                                                    additionalProperties: false,
+                                                    required: [
+                                                      "width",
+                                                      "height"
+                                                    ],
+                                                    properties: {
+                                                      width: {
+                                                        type: "integer",
+                                                        minimum: 1
+                                                      },
+                                                      height: {
+                                                        type: "integer",
+                                                        minimum: 1
+                                                      }
+                                                    }
+                                                  }
+                                                ]
+                                              },
+                                              notBlack: {
+                                                type: "boolean",
+                                                description: "Fail if the video is essentially all black (black frames cover 95% or more of its duration) \u2014 the classic symptom of a broken screen capture."
+                                              }
+                                            }
+                                          },
                                           checkpoints: {
                                             title: "Recording checkpoints",
                                             description: "Capture a checkpoint screenshot after every step while this recording is active and compare each against a persistent baseline stored beside the recording (`<path>.checkpoints/` by default). Baselines seed on the first run; on later runs, per-checkpoint variation is reported in the `stopRecord` step's outputs, and variation beyond `maxVariation` surfaces as a WARNING. If `false` or unset, no checkpoints are captured.",
@@ -422099,6 +423049,56 @@ var init_schemas = __esm({
                                                 }
                                               ]
                                             },
+                                            verify: {
+                                              title: "Recording verify guards",
+                                              description: "Structural assertions on the produced video file, evaluated when the recording stops. Unlike checkpoint drift (a WARNING), a violated guard FAILs the stopRecord step \u2014 these are properties you explicitly demand of the artifact.",
+                                              type: "object",
+                                              additionalProperties: false,
+                                              properties: {
+                                                minDuration: {
+                                                  type: "number",
+                                                  description: "Fail if the video is shorter than this many seconds.",
+                                                  minimum: 0
+                                                },
+                                                maxDuration: {
+                                                  type: "number",
+                                                  description: "Fail if the video is longer than this many seconds.",
+                                                  minimum: 0
+                                                },
+                                                resolution: {
+                                                  description: "Verify the video's dimensions (\xB12 pixels \u2014 encoders round to even dimensions). `true` compares against the capture plan's resolved expectation (the crop rectangle when a window/viewport crop applied, else the capture frame size; skipped when no expectation exists for the engine). An object compares literal dimensions.",
+                                                  anyOf: [
+                                                    {
+                                                      type: "boolean",
+                                                      title: "Verify resolution (boolean)"
+                                                    },
+                                                    {
+                                                      type: "object",
+                                                      title: "Verify resolution (detailed)",
+                                                      additionalProperties: false,
+                                                      required: [
+                                                        "width",
+                                                        "height"
+                                                      ],
+                                                      properties: {
+                                                        width: {
+                                                          type: "integer",
+                                                          minimum: 1
+                                                        },
+                                                        height: {
+                                                          type: "integer",
+                                                          minimum: 1
+                                                        }
+                                                      }
+                                                    }
+                                                  ]
+                                                },
+                                                notBlack: {
+                                                  type: "boolean",
+                                                  description: "Fail if the video is essentially all black (black frames cover 95% or more of its duration) \u2014 the classic symptom of a broken screen capture."
+                                                }
+                                              }
+                                            },
                                             checkpoints: {
                                               title: "Recording checkpoints",
                                               description: "Capture a checkpoint screenshot after every step while this recording is active and compare each against a persistent baseline stored beside the recording (`<path>.checkpoints/` by default). Baselines seed on the first run; on later runs, per-checkpoint variation is reported in the `stopRecord` step's outputs, and variation beyond `maxVariation` surfaces as a WARNING. If `false` or unset, no checkpoints are captured.",
@@ -466728,6 +467728,56 @@ var init_schemas = __esm({
                                                     }
                                                   ]
                                                 },
+                                                verify: {
+                                                  title: "Recording verify guards",
+                                                  description: "Structural assertions on the produced video file, evaluated when the recording stops. Unlike checkpoint drift (a WARNING), a violated guard FAILs the stopRecord step \u2014 these are properties you explicitly demand of the artifact.",
+                                                  type: "object",
+                                                  additionalProperties: false,
+                                                  properties: {
+                                                    minDuration: {
+                                                      type: "number",
+                                                      description: "Fail if the video is shorter than this many seconds.",
+                                                      minimum: 0
+                                                    },
+                                                    maxDuration: {
+                                                      type: "number",
+                                                      description: "Fail if the video is longer than this many seconds.",
+                                                      minimum: 0
+                                                    },
+                                                    resolution: {
+                                                      description: "Verify the video's dimensions (\xB12 pixels \u2014 encoders round to even dimensions). `true` compares against the capture plan's resolved expectation (the crop rectangle when a window/viewport crop applied, else the capture frame size; skipped when no expectation exists for the engine). An object compares literal dimensions.",
+                                                      anyOf: [
+                                                        {
+                                                          type: "boolean",
+                                                          title: "Verify resolution (boolean)"
+                                                        },
+                                                        {
+                                                          type: "object",
+                                                          title: "Verify resolution (detailed)",
+                                                          additionalProperties: false,
+                                                          required: [
+                                                            "width",
+                                                            "height"
+                                                          ],
+                                                          properties: {
+                                                            width: {
+                                                              type: "integer",
+                                                              minimum: 1
+                                                            },
+                                                            height: {
+                                                              type: "integer",
+                                                              minimum: 1
+                                                            }
+                                                          }
+                                                        }
+                                                      ]
+                                                    },
+                                                    notBlack: {
+                                                      type: "boolean",
+                                                      description: "Fail if the video is essentially all black (black frames cover 95% or more of its duration) \u2014 the classic symptom of a broken screen capture."
+                                                    }
+                                                  }
+                                                },
                                                 checkpoints: {
                                                   title: "Recording checkpoints",
                                                   description: "Capture a checkpoint screenshot after every step while this recording is active and compare each against a persistent baseline stored beside the recording (`<path>.checkpoints/` by default). Baselines seed on the first run; on later runs, per-checkpoint variation is reported in the `stopRecord` step's outputs, and variation beyond `maxVariation` surfaces as a WARNING. If `false` or unset, no checkpoints are captured.",
@@ -467083,6 +468133,56 @@ var init_schemas = __esm({
                                                       }
                                                     ]
                                                   },
+                                                  verify: {
+                                                    title: "Recording verify guards",
+                                                    description: "Structural assertions on the produced video file, evaluated when the recording stops. Unlike checkpoint drift (a WARNING), a violated guard FAILs the stopRecord step \u2014 these are properties you explicitly demand of the artifact.",
+                                                    type: "object",
+                                                    additionalProperties: false,
+                                                    properties: {
+                                                      minDuration: {
+                                                        type: "number",
+                                                        description: "Fail if the video is shorter than this many seconds.",
+                                                        minimum: 0
+                                                      },
+                                                      maxDuration: {
+                                                        type: "number",
+                                                        description: "Fail if the video is longer than this many seconds.",
+                                                        minimum: 0
+                                                      },
+                                                      resolution: {
+                                                        description: "Verify the video's dimensions (\xB12 pixels \u2014 encoders round to even dimensions). `true` compares against the capture plan's resolved expectation (the crop rectangle when a window/viewport crop applied, else the capture frame size; skipped when no expectation exists for the engine). An object compares literal dimensions.",
+                                                        anyOf: [
+                                                          {
+                                                            type: "boolean",
+                                                            title: "Verify resolution (boolean)"
+                                                          },
+                                                          {
+                                                            type: "object",
+                                                            title: "Verify resolution (detailed)",
+                                                            additionalProperties: false,
+                                                            required: [
+                                                              "width",
+                                                              "height"
+                                                            ],
+                                                            properties: {
+                                                              width: {
+                                                                type: "integer",
+                                                                minimum: 1
+                                                              },
+                                                              height: {
+                                                                type: "integer",
+                                                                minimum: 1
+                                                              }
+                                                            }
+                                                          }
+                                                        ]
+                                                      },
+                                                      notBlack: {
+                                                        type: "boolean",
+                                                        description: "Fail if the video is essentially all black (black frames cover 95% or more of its duration) \u2014 the classic symptom of a broken screen capture."
+                                                      }
+                                                    }
+                                                  },
                                                   checkpoints: {
                                                     title: "Recording checkpoints",
                                                     description: "Capture a checkpoint screenshot after every step while this recording is active and compare each against a persistent baseline stored beside the recording (`<path>.checkpoints/` by default). Baselines seed on the first run; on later runs, per-checkpoint variation is reported in the `stopRecord` step's outputs, and variation beyond `maxVariation` surfaces as a WARNING. If `false` or unset, no checkpoints are captured.",
@@ -513404,6 +514504,56 @@ var init_schemas = __esm({
                               }
                             ]
                           },
+                          verify: {
+                            title: "Recording verify guards",
+                            description: "Structural assertions on the produced video file, evaluated when the recording stops. Unlike checkpoint drift (a WARNING), a violated guard FAILs the stopRecord step \u2014 these are properties you explicitly demand of the artifact.",
+                            type: "object",
+                            additionalProperties: false,
+                            properties: {
+                              minDuration: {
+                                type: "number",
+                                description: "Fail if the video is shorter than this many seconds.",
+                                minimum: 0
+                              },
+                              maxDuration: {
+                                type: "number",
+                                description: "Fail if the video is longer than this many seconds.",
+                                minimum: 0
+                              },
+                              resolution: {
+                                description: "Verify the video's dimensions (\xB12 pixels \u2014 encoders round to even dimensions). `true` compares against the capture plan's resolved expectation (the crop rectangle when a window/viewport crop applied, else the capture frame size; skipped when no expectation exists for the engine). An object compares literal dimensions.",
+                                anyOf: [
+                                  {
+                                    type: "boolean",
+                                    title: "Verify resolution (boolean)"
+                                  },
+                                  {
+                                    type: "object",
+                                    title: "Verify resolution (detailed)",
+                                    additionalProperties: false,
+                                    required: [
+                                      "width",
+                                      "height"
+                                    ],
+                                    properties: {
+                                      width: {
+                                        type: "integer",
+                                        minimum: 1
+                                      },
+                                      height: {
+                                        type: "integer",
+                                        minimum: 1
+                                      }
+                                    }
+                                  }
+                                ]
+                              },
+                              notBlack: {
+                                type: "boolean",
+                                description: "Fail if the video is essentially all black (black frames cover 95% or more of its duration) \u2014 the classic symptom of a broken screen capture."
+                              }
+                            }
+                          },
                           checkpoints: {
                             title: "Recording checkpoints",
                             description: "Capture a checkpoint screenshot after every step while this recording is active and compare each against a persistent baseline stored beside the recording (`<path>.checkpoints/` by default). Baselines seed on the first run; on later runs, per-checkpoint variation is reported in the `stopRecord` step's outputs, and variation beyond `maxVariation` surfaces as a WARNING. If `false` or unset, no checkpoints are captured.",
@@ -513759,6 +514909,56 @@ var init_schemas = __esm({
                                 }
                               ]
                             },
+                            verify: {
+                              title: "Recording verify guards",
+                              description: "Structural assertions on the produced video file, evaluated when the recording stops. Unlike checkpoint drift (a WARNING), a violated guard FAILs the stopRecord step \u2014 these are properties you explicitly demand of the artifact.",
+                              type: "object",
+                              additionalProperties: false,
+                              properties: {
+                                minDuration: {
+                                  type: "number",
+                                  description: "Fail if the video is shorter than this many seconds.",
+                                  minimum: 0
+                                },
+                                maxDuration: {
+                                  type: "number",
+                                  description: "Fail if the video is longer than this many seconds.",
+                                  minimum: 0
+                                },
+                                resolution: {
+                                  description: "Verify the video's dimensions (\xB12 pixels \u2014 encoders round to even dimensions). `true` compares against the capture plan's resolved expectation (the crop rectangle when a window/viewport crop applied, else the capture frame size; skipped when no expectation exists for the engine). An object compares literal dimensions.",
+                                  anyOf: [
+                                    {
+                                      type: "boolean",
+                                      title: "Verify resolution (boolean)"
+                                    },
+                                    {
+                                      type: "object",
+                                      title: "Verify resolution (detailed)",
+                                      additionalProperties: false,
+                                      required: [
+                                        "width",
+                                        "height"
+                                      ],
+                                      properties: {
+                                        width: {
+                                          type: "integer",
+                                          minimum: 1
+                                        },
+                                        height: {
+                                          type: "integer",
+                                          minimum: 1
+                                        }
+                                      }
+                                    }
+                                  ]
+                                },
+                                notBlack: {
+                                  type: "boolean",
+                                  description: "Fail if the video is essentially all black (black frames cover 95% or more of its duration) \u2014 the classic symptom of a broken screen capture."
+                                }
+                              }
+                            },
                             checkpoints: {
                               title: "Recording checkpoints",
                               description: "Capture a checkpoint screenshot after every step while this recording is active and compare each against a persistent baseline stored beside the recording (`<path>.checkpoints/` by default). Baselines seed on the first run; on later runs, per-checkpoint variation is reported in the `stopRecord` step's outputs, and variation beyond `maxVariation` surfaces as a WARNING. If `false` or unset, no checkpoints are captured.",
@@ -561733,6 +562933,56 @@ var init_schemas = __esm({
                                     }
                                   ]
                                 },
+                                verify: {
+                                  title: "Recording verify guards",
+                                  description: "Structural assertions on the produced video file, evaluated when the recording stops. Unlike checkpoint drift (a WARNING), a violated guard FAILs the stopRecord step \u2014 these are properties you explicitly demand of the artifact.",
+                                  type: "object",
+                                  additionalProperties: false,
+                                  properties: {
+                                    minDuration: {
+                                      type: "number",
+                                      description: "Fail if the video is shorter than this many seconds.",
+                                      minimum: 0
+                                    },
+                                    maxDuration: {
+                                      type: "number",
+                                      description: "Fail if the video is longer than this many seconds.",
+                                      minimum: 0
+                                    },
+                                    resolution: {
+                                      description: "Verify the video's dimensions (\xB12 pixels \u2014 encoders round to even dimensions). `true` compares against the capture plan's resolved expectation (the crop rectangle when a window/viewport crop applied, else the capture frame size; skipped when no expectation exists for the engine). An object compares literal dimensions.",
+                                      anyOf: [
+                                        {
+                                          type: "boolean",
+                                          title: "Verify resolution (boolean)"
+                                        },
+                                        {
+                                          type: "object",
+                                          title: "Verify resolution (detailed)",
+                                          additionalProperties: false,
+                                          required: [
+                                            "width",
+                                            "height"
+                                          ],
+                                          properties: {
+                                            width: {
+                                              type: "integer",
+                                              minimum: 1
+                                            },
+                                            height: {
+                                              type: "integer",
+                                              minimum: 1
+                                            }
+                                          }
+                                        }
+                                      ]
+                                    },
+                                    notBlack: {
+                                      type: "boolean",
+                                      description: "Fail if the video is essentially all black (black frames cover 95% or more of its duration) \u2014 the classic symptom of a broken screen capture."
+                                    }
+                                  }
+                                },
                                 checkpoints: {
                                   title: "Recording checkpoints",
                                   description: "Capture a checkpoint screenshot after every step while this recording is active and compare each against a persistent baseline stored beside the recording (`<path>.checkpoints/` by default). Baselines seed on the first run; on later runs, per-checkpoint variation is reported in the `stopRecord` step's outputs, and variation beyond `maxVariation` surfaces as a WARNING. If `false` or unset, no checkpoints are captured.",
@@ -562088,6 +563338,56 @@ var init_schemas = __esm({
                                       }
                                     ]
                                   },
+                                  verify: {
+                                    title: "Recording verify guards",
+                                    description: "Structural assertions on the produced video file, evaluated when the recording stops. Unlike checkpoint drift (a WARNING), a violated guard FAILs the stopRecord step \u2014 these are properties you explicitly demand of the artifact.",
+                                    type: "object",
+                                    additionalProperties: false,
+                                    properties: {
+                                      minDuration: {
+                                        type: "number",
+                                        description: "Fail if the video is shorter than this many seconds.",
+                                        minimum: 0
+                                      },
+                                      maxDuration: {
+                                        type: "number",
+                                        description: "Fail if the video is longer than this many seconds.",
+                                        minimum: 0
+                                      },
+                                      resolution: {
+                                        description: "Verify the video's dimensions (\xB12 pixels \u2014 encoders round to even dimensions). `true` compares against the capture plan's resolved expectation (the crop rectangle when a window/viewport crop applied, else the capture frame size; skipped when no expectation exists for the engine). An object compares literal dimensions.",
+                                        anyOf: [
+                                          {
+                                            type: "boolean",
+                                            title: "Verify resolution (boolean)"
+                                          },
+                                          {
+                                            type: "object",
+                                            title: "Verify resolution (detailed)",
+                                            additionalProperties: false,
+                                            required: [
+                                              "width",
+                                              "height"
+                                            ],
+                                            properties: {
+                                              width: {
+                                                type: "integer",
+                                                minimum: 1
+                                              },
+                                              height: {
+                                                type: "integer",
+                                                minimum: 1
+                                              }
+                                            }
+                                          }
+                                        ]
+                                      },
+                                      notBlack: {
+                                        type: "boolean",
+                                        description: "Fail if the video is essentially all black (black frames cover 95% or more of its duration) \u2014 the classic symptom of a broken screen capture."
+                                      }
+                                    }
+                                  },
                                   checkpoints: {
                                     title: "Recording checkpoints",
                                     description: "Capture a checkpoint screenshot after every step while this recording is active and compare each against a persistent baseline stored beside the recording (`<path>.checkpoints/` by default). Baselines seed on the first run; on later runs, per-checkpoint variation is reported in the `stopRecord` step's outputs, and variation beyond `maxVariation` surfaces as a WARNING. If `false` or unset, no checkpoints are captured.",
@@ -606717,6 +608017,56 @@ var init_schemas = __esm({
                                           }
                                         ]
                                       },
+                                      verify: {
+                                        title: "Recording verify guards",
+                                        description: "Structural assertions on the produced video file, evaluated when the recording stops. Unlike checkpoint drift (a WARNING), a violated guard FAILs the stopRecord step \u2014 these are properties you explicitly demand of the artifact.",
+                                        type: "object",
+                                        additionalProperties: false,
+                                        properties: {
+                                          minDuration: {
+                                            type: "number",
+                                            description: "Fail if the video is shorter than this many seconds.",
+                                            minimum: 0
+                                          },
+                                          maxDuration: {
+                                            type: "number",
+                                            description: "Fail if the video is longer than this many seconds.",
+                                            minimum: 0
+                                          },
+                                          resolution: {
+                                            description: "Verify the video's dimensions (\xB12 pixels \u2014 encoders round to even dimensions). `true` compares against the capture plan's resolved expectation (the crop rectangle when a window/viewport crop applied, else the capture frame size; skipped when no expectation exists for the engine). An object compares literal dimensions.",
+                                            anyOf: [
+                                              {
+                                                type: "boolean",
+                                                title: "Verify resolution (boolean)"
+                                              },
+                                              {
+                                                type: "object",
+                                                title: "Verify resolution (detailed)",
+                                                additionalProperties: false,
+                                                required: [
+                                                  "width",
+                                                  "height"
+                                                ],
+                                                properties: {
+                                                  width: {
+                                                    type: "integer",
+                                                    minimum: 1
+                                                  },
+                                                  height: {
+                                                    type: "integer",
+                                                    minimum: 1
+                                                  }
+                                                }
+                                              }
+                                            ]
+                                          },
+                                          notBlack: {
+                                            type: "boolean",
+                                            description: "Fail if the video is essentially all black (black frames cover 95% or more of its duration) \u2014 the classic symptom of a broken screen capture."
+                                          }
+                                        }
+                                      },
                                       checkpoints: {
                                         title: "Recording checkpoints",
                                         description: "Capture a checkpoint screenshot after every step while this recording is active and compare each against a persistent baseline stored beside the recording (`<path>.checkpoints/` by default). Baselines seed on the first run; on later runs, per-checkpoint variation is reported in the `stopRecord` step's outputs, and variation beyond `maxVariation` surfaces as a WARNING. If `false` or unset, no checkpoints are captured.",
@@ -607072,6 +608422,56 @@ var init_schemas = __esm({
                                             }
                                           ]
                                         },
+                                        verify: {
+                                          title: "Recording verify guards",
+                                          description: "Structural assertions on the produced video file, evaluated when the recording stops. Unlike checkpoint drift (a WARNING), a violated guard FAILs the stopRecord step \u2014 these are properties you explicitly demand of the artifact.",
+                                          type: "object",
+                                          additionalProperties: false,
+                                          properties: {
+                                            minDuration: {
+                                              type: "number",
+                                              description: "Fail if the video is shorter than this many seconds.",
+                                              minimum: 0
+                                            },
+                                            maxDuration: {
+                                              type: "number",
+                                              description: "Fail if the video is longer than this many seconds.",
+                                              minimum: 0
+                                            },
+                                            resolution: {
+                                              description: "Verify the video's dimensions (\xB12 pixels \u2014 encoders round to even dimensions). `true` compares against the capture plan's resolved expectation (the crop rectangle when a window/viewport crop applied, else the capture frame size; skipped when no expectation exists for the engine). An object compares literal dimensions.",
+                                              anyOf: [
+                                                {
+                                                  type: "boolean",
+                                                  title: "Verify resolution (boolean)"
+                                                },
+                                                {
+                                                  type: "object",
+                                                  title: "Verify resolution (detailed)",
+                                                  additionalProperties: false,
+                                                  required: [
+                                                    "width",
+                                                    "height"
+                                                  ],
+                                                  properties: {
+                                                    width: {
+                                                      type: "integer",
+                                                      minimum: 1
+                                                    },
+                                                    height: {
+                                                      type: "integer",
+                                                      minimum: 1
+                                                    }
+                                                  }
+                                                }
+                                              ]
+                                            },
+                                            notBlack: {
+                                              type: "boolean",
+                                              description: "Fail if the video is essentially all black (black frames cover 95% or more of its duration) \u2014 the classic symptom of a broken screen capture."
+                                            }
+                                          }
+                                        },
                                         checkpoints: {
                                           title: "Recording checkpoints",
                                           description: "Capture a checkpoint screenshot after every step while this recording is active and compare each against a persistent baseline stored beside the recording (`<path>.checkpoints/` by default). Baselines seed on the first run; on later runs, per-checkpoint variation is reported in the `stopRecord` step's outputs, and variation beyond `maxVariation` surfaces as a WARNING. If `false` or unset, no checkpoints are captured.",
@@ -644688,6 +646088,93 @@ async function probeVideoMetadata({ cacheDir, filePath }) {
     return null;
   }
 }
+function createMatchingLineCollector(needle, limit = 65536) {
+  let partial = "";
+  let collected = "";
+  const keep = (lines) => {
+    for (const line of lines) {
+      if (line.includes(needle) && collected.length < limit) {
+        collected = (collected + line + "\n").slice(0, limit);
+      }
+    }
+  };
+  return {
+    push(text) {
+      partial += text;
+      const lines = partial.split(/\r?\n/);
+      partial = lines.pop() ?? "";
+      keep(lines);
+    },
+    flush() {
+      if (partial) {
+        keep([partial]);
+        partial = "";
+      }
+      return collected;
+    }
+  };
+}
+function parseBlackdetect(stderr, duration, fps) {
+  if (typeof duration !== "number" || !(duration > 0))
+    return false;
+  let covered = 0;
+  const re = /black_duration:([\d.]+)/g;
+  let m;
+  while ((m = re.exec(stderr ?? "")) !== null) {
+    const d = Number(m[1]);
+    if (Number.isFinite(d))
+      covered += d;
+  }
+  const frameInterval = typeof fps === "number" && fps > 0 ? 1 / fps : 0;
+  return covered >= (duration - frameInterval) * 0.95;
+}
+async function detectAllBlack({ cacheDir, filePath, duration, fps }) {
+  try {
+    const ffmpegPath = await getFfmpegPath({ cacheDir, autoInstall: false });
+    const stderr = await new Promise((resolve) => {
+      let settled = false;
+      let proc = null;
+      let timer;
+      const done = (v) => {
+        if (settled)
+          return;
+        settled = true;
+        if (timer)
+          clearTimeout(timer);
+        try {
+          proc?.kill();
+        } catch {
+        }
+        resolve(v);
+      };
+      try {
+        proc = (0, import_node_child_process11.spawn)(ffmpegPath, [
+          "-hide_banner",
+          "-i",
+          filePath,
+          "-vf",
+          "blackdetect=d=0.1:pix_th=0.10",
+          "-an",
+          "-f",
+          "null",
+          "-"
+        ], { stdio: ["ignore", "ignore", "pipe"] });
+        const lines = createMatchingLineCollector("black_");
+        proc.stderr?.on("data", (chunk) => lines.push(chunk.toString()));
+        proc.on("error", () => done(null));
+        proc.on("close", (code) => done(code === 0 ? lines.flush() : null));
+        timer = setTimeout(() => done(null), 3e4);
+      } catch {
+        done(null);
+      }
+    });
+    if (stderr === null)
+      return null;
+    return parseBlackdetect(stderr, duration, fps);
+  } catch {
+    return null;
+  }
+}
 function deriveCropScale({ platform, frameSize, displayPointSize }) {
   if (platform !== "darwin")
     return 1;
@@ -648716,6 +650203,7 @@ async function stopRecording({ config, step, driver, deps = {} }) {
     result.description = "The device recording never started (no app surface opened a device session), so there is nothing to save.";
     return result;
   }
+  let appliedCrop = null;
   const isAboveVariation = recording.overwrite === "aboveVariation";
   const finalTargetPath = recording.targetPath;
   const writeTargetPath = isAboveVariation ? import_node_path20.default.join(import_node_path20.default.dirname(finalTargetPath), `.${import_node_path20.default.basename(finalTargetPath, import_node_path20.default.extname(finalTargetPath))}.staging${import_node_path20.default.extname(finalTargetPath)}`) : finalTargetPath;
@@ -648826,6 +650314,7 @@ async function stopRecording({ config, step, driver, deps = {} }) {
         deleteSource: true,
         crop
       });
+      appliedCrop = crop;
       dropHandle();
     } else if (recording.type === "appium") {
       const b64 = await recording.driver.stopRecordingScreen();
@@ -648980,28 +650469,92 @@ async function stopRecording({ config, step, driver, deps = {} }) {
   if (!meta || Object.keys(meta).length === 0) {
     log(config, "debug", `Couldn't probe recording metadata for ${finalTargetPath}.`);
   }
+  const specs = [];
+  const verify = recording.verify;
+  if (verify && typeof verify === "object") {
+    if (typeof verify.minDuration === "number") {
+      specs.push({
+        statement: `$$outputs.duration >= ${verify.minDuration}`,
+        severity: "fail"
+      });
+    }
+    if (typeof verify.maxDuration === "number") {
+      specs.push({
+        statement: `$$outputs.duration <= ${verify.maxDuration}`,
+        severity: "fail"
+      });
+    }
+    if (verify.resolution !== void 0 && verify.resolution !== false) {
+      let expected = null;
+      if (verify.resolution === true) {
+        if (appliedCrop) {
+          expected = { width: appliedCrop.w, height: appliedCrop.h };
+        } else if (recording.captureInfo?.frameSize) {
+          expected = {
+            width: recording.captureInfo.frameSize.w,
+            height: recording.captureInfo.frameSize.h
+          };
+        }
+      } else {
+        expected = {
+          width: verify.resolution.width,
+          height: verify.resolution.height
+        };
+      }
+      if (!expected) {
+        log(config, "debug", `verify.resolution: true has no capture expectation for this engine; skipping the check.`);
+      } else {
+        result.outputs.resolutionMatch = typeof result.outputs.width === "number" && typeof result.outputs.height === "number" && Math.abs(result.outputs.width - expected.width) <= 2 && Math.abs(result.outputs.height - expected.height) <= 2;
+        specs.push({
+          statement: `$$outputs.resolutionMatch == true`,
+          severity: "fail"
+        });
+      }
+    }
+    if (verify.notBlack) {
+      const allBlack = typeof result.outputs.duration === "number" ? await detectAllBlack({
+        cacheDir: config?.cacheDir,
+        filePath: finalTargetPath,
+        duration: result.outputs.duration,
+        fps: result.outputs.fps
+      }) : null;
+      if (allBlack === null) {
+        log(config, "debug", `verify.notBlack: couldn't analyze ${finalTargetPath} (unreadable or unknown duration); skipping the check.`);
+      } else {
+        result.outputs.allBlack = allBlack;
+        specs.push({
+          statement: `$$outputs.allBlack == false`,
+          severity: "fail"
+        });
+      }
+    }
+  }
   if (checkpoints?.entries?.length) {
     Object.assign(result.outputs, buildCheckpointOutputs(checkpoints.entries));
     result.outputs.seededBaselines = seededBaselines;
+    specs.push({
+      statement: `$$outputs.maxCheckpointVariation <= ${checkpoints.maxVariation}`,
+      severity: "warning"
+    }, {
+      statement: `$$outputs.checkpointErrors == 0`,
+      severity: "warning"
+    });
+  }
+  if (specs.length > 0) {
     const ctx = buildConditionContext({ outputs: result.outputs });
-    const { assertions, status } = await evaluateImplicitAssertions([
-      {
-        statement: `$$outputs.maxCheckpointVariation <= ${checkpoints.maxVariation}`,
-        severity: "warning"
-      },
-      {
-        statement: `$$outputs.checkpointErrors == 0`,
-        severity: "warning"
-      }
-    ], ctx);
+    const { assertions, status } = await evaluateImplicitAssertions(specs, ctx);
     result.assertions = assertions;
     result.status = status;
-    if (status === "WARNING") {
+    if (status === "FAIL") {
+      result.description += ` One or more structural verify guards failed.`;
+    } else if (status === "WARNING" && checkpoints?.entries?.length) {
       result.description += !isAboveVariation ? ` One or more checkpoints drifted beyond maxVariation (${checkpoints.maxVariation}) or couldn't be compared \u2014 the recorded flow's content may have changed since its baselines were captured.` : result.outputs.changed ? ` One or more checkpoints drifted beyond maxVariation (${checkpoints.maxVariation}) or couldn't be compared \u2014 the recording was refreshed to match the current content.` : ` One or more checkpoints drifted beyond maxVariation (${checkpoints.maxVariation}) or couldn't be compared \u2014 the existing recording was kept.`;
     }
     if (baselineFailures > 0) {
       result.outputs.baselineFailures = baselineFailures;
     }
+  }
+  if (checkpoints) {
     try {
       import_node_fs23.default.rmSync(checkpoints.stagingDir, { recursive: true, force: true });
     } catch {
@@ -649014,7 +650567,8 @@ async function stopRecording({ config, step, driver, deps = {} }) {
       delete result.outputs.recordingPath;
       delete result.outputs.format;
     } else {
-      result.status = "WARNING";
+      if (result.status !== "FAIL")
+        result.status = "WARNING";
       result.description += ` The captured video couldn't replace ${finalTargetPath}, so the existing (now stale) recording was kept.`;
     }
   }
@@ -654332,6 +655886,7 @@ async function runStep({ config = {}, context = {}, step, driver, metaValues = {
       handle.id = handle.id ?? (0, import_node_crypto10.randomUUID)();
       handle.name = handle.name ?? recordStepName(step.record);
       handle.overwrite = step.record?.overwrite;
+      handle.verify = step.record?.verify;
       if (handle.targetPath) {
         handle.checkpoints = resolveCheckpointsConfig({
           record: step.record,