doc-detective 4.15.3 → 4.16.0

package/dist/index.cjs

@@ -1037,6 +1037,11 @@ var init_schemas = __esm({
                               ],
                               $comment: "`safari` is just a shortcut for `webkit`. Included for visibility and to reduce questions."
                             },
+                            explicit: {
+                              type: "boolean",
+                              description: "Set automatically during context resolution: `true` when the author explicitly requested this browser (as opposed to it being auto-selected as the default). The runner's cross-browser fallback uses it to decide whether substituting another engine reports `PASS` (auto-selected) or `WARNING` (explicitly pinned).",
+                              readOnly: true
+                            },
                             headless: {
                               type: "boolean",
                               description: "If `true`, runs the browser in headless mode.",
@@ -1111,6 +1116,11 @@ var init_schemas = __esm({
                                     ],
                                     $comment: "`safari` is just a shortcut for `webkit`. Included for visibility and to reduce questions."
                                   },
+                                  explicit: {
+                                    type: "boolean",
+                                    description: "Set automatically during context resolution: `true` when the author explicitly requested this browser (as opposed to it being auto-selected as the default). The runner's cross-browser fallback uses it to decide whether substituting another engine reports `PASS` (auto-selected) or `WARNING` (explicitly pinned).",
+                                    readOnly: true
+                                  },
                                   headless: {
                                     type: "boolean",
                                     description: "If `true`, runs the browser in headless mode.",
@@ -1155,6 +1165,15 @@ var init_schemas = __esm({
                           }
                         }
                       ]
+                    },
+                    browserFallback: {
+                      description: "Per-context override for the config-level [`browserFallback`](config) policy that governs whether a context whose browser can't start a driver session falls back to another available browser. Accepts the same values \u2014 `auto`, `explicit`, `off` \u2014 and, when set, takes precedence over the config-level value for the contexts this entry expands into. Omit it to inherit the config-level policy (which itself defaults to `auto`).",
+                      type: "string",
+                      enum: [
+                        "auto",
+                        "explicit",
+                        "off"
+                      ]
                     }
                   },
                   components: {
@@ -1197,6 +1216,11 @@ var init_schemas = __esm({
                             ],
                             $comment: "`safari` is just a shortcut for `webkit`. Included for visibility and to reduce questions."
                           },
+                          explicit: {
+                            type: "boolean",
+                            description: "Set automatically during context resolution: `true` when the author explicitly requested this browser (as opposed to it being auto-selected as the default). The runner's cross-browser fallback uses it to decide whether substituting another engine reports `PASS` (auto-selected) or `WARNING` (explicitly pinned).",
+                            readOnly: true
+                          },
                           headless: {
                             type: "boolean",
                             description: "If `true`, runs the browser in headless mode.",
@@ -29464,6 +29488,16 @@ var init_schemas = __esm({
             type: "string",
             minLength: 1,
             pattern: "\\S"
+          },
+          browserFallback: {
+            description: "Controls whether a context whose browser cannot start a driver session falls back to another available browser instead of being skipped. Drivers are validated by execution (not just presence) so a present-but-broken driver \u2014 for example a partially downloaded geckodriver \u2014 no longer silently skips Firefox coverage. `auto` (default): fall back to any other available browser for both auto-selected and explicitly requested browsers; a fallback away from an explicitly requested browser reports the context as `WARNING` rather than `PASS`. `explicit`: fall back only when the browser was auto-selected; an explicitly requested browser whose driver is broken is skipped with a diagnostic reason. `off`: never fall back across browsers (driver validation and diagnostic skip reasons still apply). Equivalent to `--browser-fallback` on the CLI.",
+            type: "string",
+            enum: [
+              "auto",
+              "explicit",
+              "off"
+            ],
+            default: "auto"
           }
         },
         components: {
@@ -56977,6 +57011,11 @@ var init_schemas = __esm({
                     ],
                     $comment: "`safari` is just a shortcut for `webkit`. Included for visibility and to reduce questions."
                   },
+                  explicit: {
+                    type: "boolean",
+                    description: "Set automatically during context resolution: `true` when the author explicitly requested this browser (as opposed to it being auto-selected as the default). The runner's cross-browser fallback uses it to decide whether substituting another engine reports `PASS` (auto-selected) or `WARNING` (explicitly pinned).",
+                    readOnly: true
+                  },
                   headless: {
                     type: "boolean",
                     description: "If `true`, runs the browser in headless mode.",
@@ -57051,6 +57090,11 @@ var init_schemas = __esm({
                           ],
                           $comment: "`safari` is just a shortcut for `webkit`. Included for visibility and to reduce questions."
                         },
+                        explicit: {
+                          type: "boolean",
+                          description: "Set automatically during context resolution: `true` when the author explicitly requested this browser (as opposed to it being auto-selected as the default). The runner's cross-browser fallback uses it to decide whether substituting another engine reports `PASS` (auto-selected) or `WARNING` (explicitly pinned).",
+                          readOnly: true
+                        },
                         headless: {
                           type: "boolean",
                           description: "If `true`, runs the browser in headless mode.",
@@ -57095,6 +57139,15 @@ var init_schemas = __esm({
                 }
               }
             ]
+          },
+          browserFallback: {
+            description: "Per-context override for the config-level [`browserFallback`](config) policy that governs whether a context whose browser can't start a driver session falls back to another available browser. Accepts the same values \u2014 `auto`, `explicit`, `off` \u2014 and, when set, takes precedence over the config-level value for the contexts this entry expands into. Omit it to inherit the config-level policy (which itself defaults to `auto`).",
+            type: "string",
+            enum: [
+              "auto",
+              "explicit",
+              "off"
+            ]
           }
         },
         components: {
@@ -57137,6 +57190,11 @@ var init_schemas = __esm({
                   ],
                   $comment: "`safari` is just a shortcut for `webkit`. Included for visibility and to reduce questions."
                 },
+                explicit: {
+                  type: "boolean",
+                  description: "Set automatically during context resolution: `true` when the author explicitly requested this browser (as opposed to it being auto-selected as the default). The runner's cross-browser fallback uses it to decide whether substituting another engine reports `PASS` (auto-selected) or `WARNING` (explicitly pinned).",
+                  readOnly: true
+                },
                 headless: {
                   type: "boolean",
                   description: "If `true`, runs the browser in headless mode.",
@@ -62241,6 +62299,11 @@ var init_schemas = __esm({
                                   ],
                                   $comment: "`safari` is just a shortcut for `webkit`. Included for visibility and to reduce questions."
                                 },
+                                explicit: {
+                                  type: "boolean",
+                                  description: "Set automatically during context resolution: `true` when the author explicitly requested this browser (as opposed to it being auto-selected as the default). The runner's cross-browser fallback uses it to decide whether substituting another engine reports `PASS` (auto-selected) or `WARNING` (explicitly pinned).",
+                                  readOnly: true
+                                },
                                 headless: {
                                   type: "boolean",
                                   description: "If `true`, runs the browser in headless mode.",
@@ -62315,6 +62378,11 @@ var init_schemas = __esm({
                                         ],
                                         $comment: "`safari` is just a shortcut for `webkit`. Included for visibility and to reduce questions."
                                       },
+                                      explicit: {
+                                        type: "boolean",
+                                        description: "Set automatically during context resolution: `true` when the author explicitly requested this browser (as opposed to it being auto-selected as the default). The runner's cross-browser fallback uses it to decide whether substituting another engine reports `PASS` (auto-selected) or `WARNING` (explicitly pinned).",
+                                        readOnly: true
+                                      },
                                       headless: {
                                         type: "boolean",
                                         description: "If `true`, runs the browser in headless mode.",
@@ -62359,6 +62427,15 @@ var init_schemas = __esm({
                               }
                             }
                           ]
+                        },
+                        browserFallback: {
+                          description: "Per-context override for the config-level [`browserFallback`](config) policy that governs whether a context whose browser can't start a driver session falls back to another available browser. Accepts the same values \u2014 `auto`, `explicit`, `off` \u2014 and, when set, takes precedence over the config-level value for the contexts this entry expands into. Omit it to inherit the config-level policy (which itself defaults to `auto`).",
+                          type: "string",
+                          enum: [
+                            "auto",
+                            "explicit",
+                            "off"
+                          ]
                         }
                       },
                       components: {
@@ -62401,6 +62478,11 @@ var init_schemas = __esm({
                                 ],
                                 $comment: "`safari` is just a shortcut for `webkit`. Included for visibility and to reduce questions."
                               },
+                              explicit: {
+                                type: "boolean",
+                                description: "Set automatically during context resolution: `true` when the author explicitly requested this browser (as opposed to it being auto-selected as the default). The runner's cross-browser fallback uses it to decide whether substituting another engine reports `PASS` (auto-selected) or `WARNING` (explicitly pinned).",
+                                readOnly: true
+                              },
                               headless: {
                                 type: "boolean",
                                 description: "If `true`, runs the browser in headless mode.",
@@ -90668,6 +90750,16 @@ var init_schemas = __esm({
                 type: "string",
                 minLength: 1,
                 pattern: "\\S"
+              },
+              browserFallback: {
+                description: "Controls whether a context whose browser cannot start a driver session falls back to another available browser instead of being skipped. Drivers are validated by execution (not just presence) so a present-but-broken driver \u2014 for example a partially downloaded geckodriver \u2014 no longer silently skips Firefox coverage. `auto` (default): fall back to any other available browser for both auto-selected and explicitly requested browsers; a fallback away from an explicitly requested browser reports the context as `WARNING` rather than `PASS`. `explicit`: fall back only when the browser was auto-selected; an explicitly requested browser whose driver is broken is skipped with a diagnostic reason. `off`: never fall back across browsers (driver validation and diagnostic skip reasons still apply). Equivalent to `--browser-fallback` on the CLI.",
+                type: "string",
+                enum: [
+                  "auto",
+                  "explicit",
+                  "off"
+                ],
+                default: "auto"
               }
             },
             components: {
@@ -118243,6 +118335,11 @@ var init_schemas = __esm({
                                         ],
                                         $comment: "`safari` is just a shortcut for `webkit`. Included for visibility and to reduce questions."
                                       },
+                                      explicit: {
+                                        type: "boolean",
+                                        description: "Set automatically during context resolution: `true` when the author explicitly requested this browser (as opposed to it being auto-selected as the default). The runner's cross-browser fallback uses it to decide whether substituting another engine reports `PASS` (auto-selected) or `WARNING` (explicitly pinned).",
+                                        readOnly: true
+                                      },
                                       headless: {
                                         type: "boolean",
                                         description: "If `true`, runs the browser in headless mode.",
@@ -118317,6 +118414,11 @@ var init_schemas = __esm({
                                               ],
                                               $comment: "`safari` is just a shortcut for `webkit`. Included for visibility and to reduce questions."
                                             },
+                                            explicit: {
+                                              type: "boolean",
+                                              description: "Set automatically during context resolution: `true` when the author explicitly requested this browser (as opposed to it being auto-selected as the default). The runner's cross-browser fallback uses it to decide whether substituting another engine reports `PASS` (auto-selected) or `WARNING` (explicitly pinned).",
+                                              readOnly: true
+                                            },
                                             headless: {
                                               type: "boolean",
                                               description: "If `true`, runs the browser in headless mode.",
@@ -118361,6 +118463,15 @@ var init_schemas = __esm({
                                     }
                                   }
                                 ]
+                              },
+                              browserFallback: {
+                                description: "Per-context override for the config-level [`browserFallback`](config) policy that governs whether a context whose browser can't start a driver session falls back to another available browser. Accepts the same values \u2014 `auto`, `explicit`, `off` \u2014 and, when set, takes precedence over the config-level value for the contexts this entry expands into. Omit it to inherit the config-level policy (which itself defaults to `auto`).",
+                                type: "string",
+                                enum: [
+                                  "auto",
+                                  "explicit",
+                                  "off"
+                                ]
                               }
                             },
                             components: {
@@ -118403,6 +118514,11 @@ var init_schemas = __esm({
                                       ],
                                       $comment: "`safari` is just a shortcut for `webkit`. Included for visibility and to reduce questions."
                                     },
+                                    explicit: {
+                                      type: "boolean",
+                                      description: "Set automatically during context resolution: `true` when the author explicitly requested this browser (as opposed to it being auto-selected as the default). The runner's cross-browser fallback uses it to decide whether substituting another engine reports `PASS` (auto-selected) or `WARNING` (explicitly pinned).",
+                                      readOnly: true
+                                    },
                                     headless: {
                                       type: "boolean",
                                       description: "If `true`, runs the browser in headless mode.",
@@ -118852,6 +118968,11 @@ var init_schemas = __esm({
                                                   ],
                                                   $comment: "`safari` is just a shortcut for `webkit`. Included for visibility and to reduce questions."
                                                 },
+                                                explicit: {
+                                                  type: "boolean",
+                                                  description: "Set automatically during context resolution: `true` when the author explicitly requested this browser (as opposed to it being auto-selected as the default). The runner's cross-browser fallback uses it to decide whether substituting another engine reports `PASS` (auto-selected) or `WARNING` (explicitly pinned).",
+                                                  readOnly: true
+                                                },
                                                 headless: {
                                                   type: "boolean",
                                                   description: "If `true`, runs the browser in headless mode.",
@@ -118926,6 +119047,11 @@ var init_schemas = __esm({
                                                         ],
                                                         $comment: "`safari` is just a shortcut for `webkit`. Included for visibility and to reduce questions."
                                                       },
+                                                      explicit: {
+                                                        type: "boolean",
+                                                        description: "Set automatically during context resolution: `true` when the author explicitly requested this browser (as opposed to it being auto-selected as the default). The runner's cross-browser fallback uses it to decide whether substituting another engine reports `PASS` (auto-selected) or `WARNING` (explicitly pinned).",
+                                                        readOnly: true
+                                                      },
                                                       headless: {
                                                         type: "boolean",
                                                         description: "If `true`, runs the browser in headless mode.",
@@ -118970,6 +119096,15 @@ var init_schemas = __esm({
                                               }
                                             }
                                           ]
+                                        },
+                                        browserFallback: {
+                                          description: "Per-context override for the config-level [`browserFallback`](config) policy that governs whether a context whose browser can't start a driver session falls back to another available browser. Accepts the same values \u2014 `auto`, `explicit`, `off` \u2014 and, when set, takes precedence over the config-level value for the contexts this entry expands into. Omit it to inherit the config-level policy (which itself defaults to `auto`).",
+                                          type: "string",
+                                          enum: [
+                                            "auto",
+                                            "explicit",
+                                            "off"
+                                          ]
                                         }
                                       },
                                       components: {
@@ -119012,6 +119147,11 @@ var init_schemas = __esm({
                                                 ],
                                                 $comment: "`safari` is just a shortcut for `webkit`. Included for visibility and to reduce questions."
                                               },
+                                              explicit: {
+                                                type: "boolean",
+                                                description: "Set automatically during context resolution: `true` when the author explicitly requested this browser (as opposed to it being auto-selected as the default). The runner's cross-browser fallback uses it to decide whether substituting another engine reports `PASS` (auto-selected) or `WARNING` (explicitly pinned).",
+                                                readOnly: true
+                                              },
                                               headless: {
                                                 type: "boolean",
                                                 description: "If `true`, runs the browser in headless mode.",
@@ -147114,6 +147254,11 @@ var init_schemas = __esm({
                                           ],
                                           $comment: "`safari` is just a shortcut for `webkit`. Included for visibility and to reduce questions."
                                         },
+                                        explicit: {
+                                          type: "boolean",
+                                          description: "Set automatically during context resolution: `true` when the author explicitly requested this browser (as opposed to it being auto-selected as the default). The runner's cross-browser fallback uses it to decide whether substituting another engine reports `PASS` (auto-selected) or `WARNING` (explicitly pinned).",
+                                          readOnly: true
+                                        },
                                         headless: {
                                           type: "boolean",
                                           description: "If `true`, runs the browser in headless mode.",
@@ -175285,6 +175430,11 @@ var init_schemas = __esm({
                                         ],
                                         $comment: "`safari` is just a shortcut for `webkit`. Included for visibility and to reduce questions."
                                       },
+                                      explicit: {
+                                        type: "boolean",
+                                        description: "Set automatically during context resolution: `true` when the author explicitly requested this browser (as opposed to it being auto-selected as the default). The runner's cross-browser fallback uses it to decide whether substituting another engine reports `PASS` (auto-selected) or `WARNING` (explicitly pinned).",
+                                        readOnly: true
+                                      },
                                       headless: {
                                         type: "boolean",
                                         description: "If `true`, runs the browser in headless mode.",
@@ -175359,6 +175509,11 @@ var init_schemas = __esm({
                                               ],
                                               $comment: "`safari` is just a shortcut for `webkit`. Included for visibility and to reduce questions."
                                             },
+                                            explicit: {
+                                              type: "boolean",
+                                              description: "Set automatically during context resolution: `true` when the author explicitly requested this browser (as opposed to it being auto-selected as the default). The runner's cross-browser fallback uses it to decide whether substituting another engine reports `PASS` (auto-selected) or `WARNING` (explicitly pinned).",
+                                              readOnly: true
+                                            },
                                             headless: {
                                               type: "boolean",
                                               description: "If `true`, runs the browser in headless mode.",
@@ -175403,6 +175558,15 @@ var init_schemas = __esm({
                                     }
                                   }
                                 ]
+                              },
+                              browserFallback: {
+                                description: "Per-context override for the config-level [`browserFallback`](config) policy that governs whether a context whose browser can't start a driver session falls back to another available browser. Accepts the same values \u2014 `auto`, `explicit`, `off` \u2014 and, when set, takes precedence over the config-level value for the contexts this entry expands into. Omit it to inherit the config-level policy (which itself defaults to `auto`).",
+                                type: "string",
+                                enum: [
+                                  "auto",
+                                  "explicit",
+                                  "off"
+                                ]
                               }
                             },
                             components: {
@@ -175445,6 +175609,11 @@ var init_schemas = __esm({
                                       ],
                                       $comment: "`safari` is just a shortcut for `webkit`. Included for visibility and to reduce questions."
                                     },
+                                    explicit: {
+                                      type: "boolean",
+                                      description: "Set automatically during context resolution: `true` when the author explicitly requested this browser (as opposed to it being auto-selected as the default). The runner's cross-browser fallback uses it to decide whether substituting another engine reports `PASS` (auto-selected) or `WARNING` (explicitly pinned).",
+                                      readOnly: true
+                                    },
                                     headless: {
                                       type: "boolean",
                                       description: "If `true`, runs the browser in headless mode.",
@@ -175894,6 +176063,11 @@ var init_schemas = __esm({
                                                   ],
                                                   $comment: "`safari` is just a shortcut for `webkit`. Included for visibility and to reduce questions."
                                                 },
+                                                explicit: {
+                                                  type: "boolean",
+                                                  description: "Set automatically during context resolution: `true` when the author explicitly requested this browser (as opposed to it being auto-selected as the default). The runner's cross-browser fallback uses it to decide whether substituting another engine reports `PASS` (auto-selected) or `WARNING` (explicitly pinned).",
+                                                  readOnly: true
+                                                },
                                                 headless: {
                                                   type: "boolean",
                                                   description: "If `true`, runs the browser in headless mode.",
@@ -175968,6 +176142,11 @@ var init_schemas = __esm({
                                                         ],
                                                         $comment: "`safari` is just a shortcut for `webkit`. Included for visibility and to reduce questions."
                                                       },
+                                                      explicit: {
+                                                        type: "boolean",
+                                                        description: "Set automatically during context resolution: `true` when the author explicitly requested this browser (as opposed to it being auto-selected as the default). The runner's cross-browser fallback uses it to decide whether substituting another engine reports `PASS` (auto-selected) or `WARNING` (explicitly pinned).",
+                                                        readOnly: true
+                                                      },
                                                       headless: {
                                                         type: "boolean",
                                                         description: "If `true`, runs the browser in headless mode.",
@@ -176012,6 +176191,15 @@ var init_schemas = __esm({
                                               }
                                             }
                                           ]
+                                        },
+                                        browserFallback: {
+                                          description: "Per-context override for the config-level [`browserFallback`](config) policy that governs whether a context whose browser can't start a driver session falls back to another available browser. Accepts the same values \u2014 `auto`, `explicit`, `off` \u2014 and, when set, takes precedence over the config-level value for the contexts this entry expands into. Omit it to inherit the config-level policy (which itself defaults to `auto`).",
+                                          type: "string",
+                                          enum: [
+                                            "auto",
+                                            "explicit",
+                                            "off"
+                                          ]
                                         }
                                       },
                                       components: {
@@ -176054,6 +176242,11 @@ var init_schemas = __esm({
                                                 ],
                                                 $comment: "`safari` is just a shortcut for `webkit`. Included for visibility and to reduce questions."
                                               },
+                                              explicit: {
+                                                type: "boolean",
+                                                description: "Set automatically during context resolution: `true` when the author explicitly requested this browser (as opposed to it being auto-selected as the default). The runner's cross-browser fallback uses it to decide whether substituting another engine reports `PASS` (auto-selected) or `WARNING` (explicitly pinned).",
+                                                readOnly: true
+                                              },
                                               headless: {
                                                 type: "boolean",
                                                 description: "If `true`, runs the browser in headless mode.",
@@ -204156,6 +204349,11 @@ var init_schemas = __esm({
                                           ],
                                           $comment: "`safari` is just a shortcut for `webkit`. Included for visibility and to reduce questions."
                                         },
+                                        explicit: {
+                                          type: "boolean",
+                                          description: "Set automatically during context resolution: `true` when the author explicitly requested this browser (as opposed to it being auto-selected as the default). The runner's cross-browser fallback uses it to decide whether substituting another engine reports `PASS` (auto-selected) or `WARNING` (explicitly pinned).",
+                                          readOnly: true
+                                        },
                                         headless: {
                                           type: "boolean",
                                           description: "If `true`, runs the browser in headless mode.",
@@ -234283,6 +234481,11 @@ var init_schemas = __esm({
                               ],
                               $comment: "`safari` is just a shortcut for `webkit`. Included for visibility and to reduce questions."
                             },
+                            explicit: {
+                              type: "boolean",
+                              description: "Set automatically during context resolution: `true` when the author explicitly requested this browser (as opposed to it being auto-selected as the default). The runner's cross-browser fallback uses it to decide whether substituting another engine reports `PASS` (auto-selected) or `WARNING` (explicitly pinned).",
+                              readOnly: true
+                            },
                             headless: {
                               type: "boolean",
                               description: "If `true`, runs the browser in headless mode.",
@@ -234357,6 +234560,11 @@ var init_schemas = __esm({
                                     ],
                                     $comment: "`safari` is just a shortcut for `webkit`. Included for visibility and to reduce questions."
                                   },
+                                  explicit: {
+                                    type: "boolean",
+                                    description: "Set automatically during context resolution: `true` when the author explicitly requested this browser (as opposed to it being auto-selected as the default). The runner's cross-browser fallback uses it to decide whether substituting another engine reports `PASS` (auto-selected) or `WARNING` (explicitly pinned).",
+                                    readOnly: true
+                                  },
                                   headless: {
                                     type: "boolean",
                                     description: "If `true`, runs the browser in headless mode.",
@@ -234401,6 +234609,15 @@ var init_schemas = __esm({
                           }
                         }
                       ]
+                    },
+                    browserFallback: {
+                      description: "Per-context override for the config-level [`browserFallback`](config) policy that governs whether a context whose browser can't start a driver session falls back to another available browser. Accepts the same values \u2014 `auto`, `explicit`, `off` \u2014 and, when set, takes precedence over the config-level value for the contexts this entry expands into. Omit it to inherit the config-level policy (which itself defaults to `auto`).",
+                      type: "string",
+                      enum: [
+                        "auto",
+                        "explicit",
+                        "off"
+                      ]
                     }
                   },
                   components: {
@@ -234443,6 +234660,11 @@ var init_schemas = __esm({
                             ],
                             $comment: "`safari` is just a shortcut for `webkit`. Included for visibility and to reduce questions."
                           },
+                          explicit: {
+                            type: "boolean",
+                            description: "Set automatically during context resolution: `true` when the author explicitly requested this browser (as opposed to it being auto-selected as the default). The runner's cross-browser fallback uses it to decide whether substituting another engine reports `PASS` (auto-selected) or `WARNING` (explicitly pinned).",
+                            readOnly: true
+                          },
                           headless: {
                             type: "boolean",
                             description: "If `true`, runs the browser in headless mode.",
@@ -234892,6 +235114,11 @@ var init_schemas = __esm({
                                         ],
                                         $comment: "`safari` is just a shortcut for `webkit`. Included for visibility and to reduce questions."
                                       },
+                                      explicit: {
+                                        type: "boolean",
+                                        description: "Set automatically during context resolution: `true` when the author explicitly requested this browser (as opposed to it being auto-selected as the default). The runner's cross-browser fallback uses it to decide whether substituting another engine reports `PASS` (auto-selected) or `WARNING` (explicitly pinned).",
+                                        readOnly: true
+                                      },
                                       headless: {
                                         type: "boolean",
                                         description: "If `true`, runs the browser in headless mode.",
@@ -234966,6 +235193,11 @@ var init_schemas = __esm({
                                               ],
                                               $comment: "`safari` is just a shortcut for `webkit`. Included for visibility and to reduce questions."
                                             },
+                                            explicit: {
+                                              type: "boolean",
+                                              description: "Set automatically during context resolution: `true` when the author explicitly requested this browser (as opposed to it being auto-selected as the default). The runner's cross-browser fallback uses it to decide whether substituting another engine reports `PASS` (auto-selected) or `WARNING` (explicitly pinned).",
+                                              readOnly: true
+                                            },
                                             headless: {
                                               type: "boolean",
                                               description: "If `true`, runs the browser in headless mode.",
@@ -235010,6 +235242,15 @@ var init_schemas = __esm({
                                     }
                                   }
                                 ]
+                              },
+                              browserFallback: {
+                                description: "Per-context override for the config-level [`browserFallback`](config) policy that governs whether a context whose browser can't start a driver session falls back to another available browser. Accepts the same values \u2014 `auto`, `explicit`, `off` \u2014 and, when set, takes precedence over the config-level value for the contexts this entry expands into. Omit it to inherit the config-level policy (which itself defaults to `auto`).",
+                                type: "string",
+                                enum: [
+                                  "auto",
+                                  "explicit",
+                                  "off"
+                                ]
                               }
                             },
                             components: {
@@ -235052,6 +235293,11 @@ var init_schemas = __esm({
                                       ],
                                       $comment: "`safari` is just a shortcut for `webkit`. Included for visibility and to reduce questions."
                                     },
+                                    explicit: {
+                                      type: "boolean",
+                                      description: "Set automatically during context resolution: `true` when the author explicitly requested this browser (as opposed to it being auto-selected as the default). The runner's cross-browser fallback uses it to decide whether substituting another engine reports `PASS` (auto-selected) or `WARNING` (explicitly pinned).",
+                                      readOnly: true
+                                    },
                                     headless: {
                                       type: "boolean",
                                       description: "If `true`, runs the browser in headless mode.",
@@ -263154,6 +263400,11 @@ var init_schemas = __esm({
                                 ],
                                 $comment: "`safari` is just a shortcut for `webkit`. Included for visibility and to reduce questions."
                               },
+                              explicit: {
+                                type: "boolean",
+                                description: "Set automatically during context resolution: `true` when the author explicitly requested this browser (as opposed to it being auto-selected as the default). The runner's cross-browser fallback uses it to decide whether substituting another engine reports `PASS` (auto-selected) or `WARNING` (explicitly pinned).",
+                                readOnly: true
+                              },
                               headless: {
                                 type: "boolean",
                                 description: "If `true`, runs the browser in headless mode.",
@@ -318224,6 +318475,11 @@ var init_schemas = __esm({
                               ],
                               $comment: "`safari` is just a shortcut for `webkit`. Included for visibility and to reduce questions."
                             },
+                            explicit: {
+                              type: "boolean",
+                              description: "Set automatically during context resolution: `true` when the author explicitly requested this browser (as opposed to it being auto-selected as the default). The runner's cross-browser fallback uses it to decide whether substituting another engine reports `PASS` (auto-selected) or `WARNING` (explicitly pinned).",
+                              readOnly: true
+                            },
                             headless: {
                               type: "boolean",
                               description: "If `true`, runs the browser in headless mode.",
@@ -318298,6 +318554,11 @@ var init_schemas = __esm({
                                     ],
                                     $comment: "`safari` is just a shortcut for `webkit`. Included for visibility and to reduce questions."
                                   },
+                                  explicit: {
+                                    type: "boolean",
+                                    description: "Set automatically during context resolution: `true` when the author explicitly requested this browser (as opposed to it being auto-selected as the default). The runner's cross-browser fallback uses it to decide whether substituting another engine reports `PASS` (auto-selected) or `WARNING` (explicitly pinned).",
+                                    readOnly: true
+                                  },
                                   headless: {
                                     type: "boolean",
                                     description: "If `true`, runs the browser in headless mode.",
@@ -318342,6 +318603,15 @@ var init_schemas = __esm({
                           }
                         }
                       ]
+                    },
+                    browserFallback: {
+                      description: "Per-context override for the config-level [`browserFallback`](config) policy that governs whether a context whose browser can't start a driver session falls back to another available browser. Accepts the same values \u2014 `auto`, `explicit`, `off` \u2014 and, when set, takes precedence over the config-level value for the contexts this entry expands into. Omit it to inherit the config-level policy (which itself defaults to `auto`).",
+                      type: "string",
+                      enum: [
+                        "auto",
+                        "explicit",
+                        "off"
+                      ]
                     }
                   },
                   components: {
@@ -318384,6 +318654,11 @@ var init_schemas = __esm({
                             ],
                             $comment: "`safari` is just a shortcut for `webkit`. Included for visibility and to reduce questions."
                           },
+                          explicit: {
+                            type: "boolean",
+                            description: "Set automatically during context resolution: `true` when the author explicitly requested this browser (as opposed to it being auto-selected as the default). The runner's cross-browser fallback uses it to decide whether substituting another engine reports `PASS` (auto-selected) or `WARNING` (explicitly pinned).",
+                            readOnly: true
+                          },
                           headless: {
                             type: "boolean",
                             description: "If `true`, runs the browser in headless mode.",
@@ -346486,6 +346761,11 @@ var init_schemas = __esm({
                       ],
                       $comment: "`safari` is just a shortcut for `webkit`. Included for visibility and to reduce questions."
                     },
+                    explicit: {
+                      type: "boolean",
+                      description: "Set automatically during context resolution: `true` when the author explicitly requested this browser (as opposed to it being auto-selected as the default). The runner's cross-browser fallback uses it to decide whether substituting another engine reports `PASS` (auto-selected) or `WARNING` (explicitly pinned).",
+                      readOnly: true
+                    },
                     headless: {
                       type: "boolean",
                       description: "If `true`, runs the browser in headless mode.",
@@ -385247,16 +385527,410 @@ var init_utils = __esm({
   }
 });
 
+// dist/runtime/browsers.js
+var browsers_exports = {};
+__export(browsers_exports, {
+  BROWSER_CHANNELS: () => BROWSER_CHANNELS,
+  ensureBrowserInstalled: () => ensureBrowserInstalled,
+  geckodriverBinaryInCache: () => geckodriverBinaryInCache,
+  getInstalledBrowsers: () => getInstalledBrowsers,
+  requiredBrowserAssets: () => requiredBrowserAssets,
+  verifyDriverBinary: () => verifyDriverBinary
+});
+function isAllowedDriverPath(binaryPath) {
+  return typeof binaryPath === "string" && import_node_path5.default.isAbsolute(binaryPath) && ALLOWED_DRIVER_PATH.test(binaryPath);
+}
+function parseDriverVersion(output) {
+  const m = output.match(/(\d+\.\d+(?:\.\d+)*)/);
+  return m ? m[1] : void 0;
+}
+async function verifyDriverBinary(driverName, binaryPath, options = {}) {
+  if (!binaryPath || typeof binaryPath !== "string") {
+    return { ok: false, error: "No driver binary path to verify." };
+  }
+  if (!isAllowedDriverPath(binaryPath)) {
+    return {
+      ok: false,
+      error: `Refusing to execute '${binaryPath}': not a recognized driver binary path.`
+    };
+  }
+  const key = String(driverName ?? "").toLowerCase();
+  const args = DRIVER_VERSION_ARGS[key] ?? ["--version"];
+  const exec = options.exec ?? defaultDriverExec;
+  const timeoutMs = options.timeoutMs ?? DRIVER_VERIFY_TIMEOUT_MS;
+  let res;
+  try {
+    res = await exec(binaryPath, args, timeoutMs);
+  } catch (err) {
+    return { ok: false, error: `Failed to execute ${driverName}: ${String(err)}` };
+  }
+  if (res.code === null) {
+    const detail = (res.stderr || res.stdout || "").trim();
+    return {
+      ok: false,
+      error: `${driverName} could not be executed (spawn failed)${detail ? `: ${detail}` : ""}`
+    };
+  }
+  if (res.code !== 0) {
+    const detail = (res.stderr || res.stdout || "").trim();
+    return {
+      ok: false,
+      error: `${driverName} exited with code ${res.code}${detail ? `: ${detail}` : ""}`
+    };
+  }
+  const version = parseDriverVersion(`${res.stdout}
+${res.stderr}`);
+  if (!version) {
+    return {
+      ok: false,
+      error: `${driverName} ran but did not report a parseable version (likely a partial or corrupt download).`
+    };
+  }
+  return { ok: true, version };
+}
+function requiredBrowserAssets(name) {
+  switch ((name ?? "").toLowerCase()) {
+    case "chrome":
+      return ["chrome", "chromedriver"];
+    case "firefox":
+      return ["firefox", "geckodriver"];
+    default:
+      return [];
+  }
+}
+async function loadPuppeteerBrowsers(deps, ctx) {
+  if (deps.browsersModule)
+    return deps.browsersModule;
+  return await loadHeavyDep("@puppeteer/browsers", { ctx, deps: { logger: deps.logger } });
+}
+async function loadGeckodriver(deps, ctx) {
+  if (deps.geckodriverModule)
+    return deps.geckodriverModule;
+  return await loadHeavyDep("geckodriver", { ctx, deps: { logger: deps.logger } });
+}
+function isStillFresh(latestCheckedAt, now) {
+  if (!latestCheckedAt)
+    return false;
+  const t = Date.parse(latestCheckedAt);
+  if (Number.isNaN(t))
+    return false;
+  return now.getTime() - t < FRESHNESS_TTL_MS;
+}
+async function resolveChannelBuildId(browsersModule, assetName, platform) {
+  const channel = BROWSER_CHANNELS[assetName];
+  return await withTimeout(Promise.resolve(browsersModule.resolveBuildId(assetName, platform, channel)), RESOLVE_TIMEOUT_MS, `resolveBuildId(${assetName}, ${channel})`);
+}
+function withTimeout(p, ms, label) {
+  return new Promise((resolve, reject) => {
+    const t = setTimeout(() => reject(new Error(`${label} timed out after ${ms}ms`)), ms);
+    if (typeof t.unref === "function")
+      t.unref();
+    p.then((v) => {
+      clearTimeout(t);
+      resolve(v);
+    }, (err) => {
+      clearTimeout(t);
+      reject(err);
+    });
+  });
+}
+async function ensureBrowserInstalled(name, options = {}) {
+  const { ctx = {} } = options;
+  const dedupeKey = `${name}:${getBrowsersDir(ctx)}`;
+  const inFlight = inFlightInstalls.get(dedupeKey);
+  if (inFlight)
+    return inFlight;
+  const p = ensureBrowserInstalledImpl(name, options).finally(() => {
+    inFlightInstalls.delete(dedupeKey);
+  });
+  inFlightInstalls.set(dedupeKey, p);
+  return p;
+}
+async function ensureBrowserInstalledImpl(name, options = {}) {
+  const { ctx = {}, deps = {}, force = false } = options;
+  const logger = deps.logger ?? defaultLogger2;
+  const now = (deps.now ?? (() => /* @__PURE__ */ new Date()))();
+  const cacheDir = getBrowsersDir(ctx);
+  const record = readInstalledRecord(ctx);
+  const existing = record.browsers[name];
+  if (name === "geckodriver") {
+    return await ensureGeckodriver({ ctx, deps: { ...deps, logger }, force, now }, record, existing, logger);
+  }
+  const browsersModule = await loadPuppeteerBrowsers(deps, ctx);
+  const platform = browsersModule.detectBrowserPlatform ? browsersModule.detectBrowserPlatform() : void 0;
+  if (!platform) {
+    throw new Error(`Unable to determine browser platform on ${process.platform}/${process.arch}. @puppeteer/browsers does not recognize this OS; ${name} cannot be installed automatically. Set DOC_DETECTIVE_CACHE_DIR to a pre-warmed cache or skip browser-driven steps.`);
+  }
+  if (!force && existing && isStillFresh(existing.latestCheckedAt, now)) {
+    if (existing.latestKnownVersion === existing.installedVersion) {
+      const path24 = await locateExecutable(browsersModule, name, existing.installedVersion, cacheDir, platform);
+      return { path: path24, version: existing.installedVersion, outdated: false };
+    }
+    const path23 = await locateExecutable(browsersModule, name, existing.installedVersion, cacheDir, platform);
+    logger(`${name} ${existing.installedVersion} installed in ${cacheDir}; "${BROWSER_CHANNELS[name]}" channel is now ${existing.latestKnownVersion}. Run \`doc-detective install browsers ${name} --force\` to update.`, "warn");
+    return { path: path23, version: existing.installedVersion, outdated: true };
+  }
+  let latest;
+  try {
+    latest = await resolveChannelBuildId(browsersModule, name, platform);
+  } catch (err) {
+    logger(`Channel resolution for ${name} skipped: ${String(err)}`, "debug");
+    if (existing) {
+      const path23 = await locateExecutable(browsersModule, name, existing.installedVersion, cacheDir, platform);
+      return { path: path23, version: existing.installedVersion, outdated: false };
+    }
+    throw err;
+  }
+  if (!force && existing && existing.installedVersion === latest) {
+    record.browsers[name] = {
+      ...existing,
+      latestKnownVersion: latest,
+      latestCheckedAt: now.toISOString()
+    };
+    writeInstalledRecord(record, ctx);
+    const path23 = await locateExecutable(browsersModule, name, latest, cacheDir, platform);
+    return { path: path23, version: latest, outdated: false };
+  }
+  if (!force && existing) {
+    record.browsers[name] = {
+      ...existing,
+      latestKnownVersion: latest,
+      latestCheckedAt: now.toISOString()
+    };
+    writeInstalledRecord(record, ctx);
+    logger(`${name} ${existing.installedVersion} installed in ${cacheDir}; "${BROWSER_CHANNELS[name]}" channel is now ${latest}. Run \`doc-detective install browsers ${name} --force\` to update.`, "warn");
+    const path23 = await locateExecutable(browsersModule, name, existing.installedVersion, cacheDir, platform);
+    return { path: path23, version: existing.installedVersion, outdated: true };
+  }
+  logger(`Installing ${name} ${latest} into ${cacheDir}`, "info");
+  await browsersModule.install({
+    browser: name,
+    buildId: latest,
+    cacheDir
+  });
+  let path22 = await locateExecutable(browsersModule, name, latest, cacheDir, platform);
+  if (name === "chromedriver" && isAllowedDriverPath(path22)) {
+    let verify = await verifyDriverBinary(name, path22, { exec: deps.verifyExec });
+    if (!verify.ok) {
+      logger(`Installed ${name} ${latest} failed validation (${verify.error}); reinstalling once.`, "warn");
+      try {
+        await browsersModule.uninstall({ browser: name, buildId: latest, cacheDir });
+      } catch (err) {
+        logger(`Failed to prune broken ${name} ${latest}: ${String(err)}`, "debug");
+      }
+      await browsersModule.install({ browser: name, buildId: latest, cacheDir });
+      path22 = await locateExecutable(browsersModule, name, latest, cacheDir, platform);
+      verify = await verifyDriverBinary(name, path22, { exec: deps.verifyExec });
+    }
+    if (!verify.ok) {
+      throw new Error(`${name} ${latest} is present but non-functional after a reinstall (${verify.error}). It may be a partial or corrupt download; delete ${path22} or reinstall.`);
+    }
+  }
+  if (existing && existing.installedVersion !== latest) {
+    try {
+      await browsersModule.uninstall({
+        browser: name,
+        buildId: existing.installedVersion,
+        cacheDir
+      });
+    } catch (err) {
+      logger(`Failed to prune old ${name} buildId ${existing.installedVersion}: ${String(err)}`, "debug");
+    }
+  }
+  record.browsers[name] = {
+    installedVersion: latest,
+    installedAt: now.toISOString(),
+    latestKnownVersion: latest,
+    latestCheckedAt: now.toISOString()
+  };
+  writeInstalledRecord(record, ctx);
+  return { path: path22, version: latest, outdated: false };
+}
+async function locateExecutable(browsersModule, name, buildId, cacheDir, platform) {
+  if (typeof browsersModule.computeExecutablePath === "function") {
+    return browsersModule.computeExecutablePath({
+      browser: name,
+      buildId,
+      cacheDir,
+      platform
+    });
+  }
+  return cacheDir;
+}
+async function withGeckodriverCacheDir(cacheDir, fn) {
+  const previous = geckodriverEnvQueue;
+  let release;
+  geckodriverEnvQueue = new Promise((resolve) => {
+    release = resolve;
+  });
+  await previous;
+  const prevEnv = process.env.GECKODRIVER_CACHE_DIR;
+  process.env.GECKODRIVER_CACHE_DIR = cacheDir;
+  try {
+    return await fn();
+  } finally {
+    if (prevEnv === void 0)
+      delete process.env.GECKODRIVER_CACHE_DIR;
+    else
+      process.env.GECKODRIVER_CACHE_DIR = prevEnv;
+    release();
+  }
+}
+function isPathInside(child, dir) {
+  const resolvedDir = import_node_path5.default.resolve(dir);
+  const resolvedChild = import_node_path5.default.resolve(child);
+  return resolvedChild === resolvedDir || resolvedChild.startsWith(resolvedDir + import_node_path5.default.sep);
+}
+function geckodriverBinaryInCache(cacheDir) {
+  const binName = process.platform === "win32" ? "geckodriver.exe" : "geckodriver";
+  const rootCandidate = import_node_path5.default.join(cacheDir, binName);
+  try {
+    if (import_node_fs5.default.existsSync(rootCandidate))
+      return rootCandidate;
+  } catch {
+  }
+  try {
+    for (const entry of import_node_fs5.default.readdirSync(cacheDir, { withFileTypes: true })) {
+      if (!entry.isDirectory())
+        continue;
+      const nested = import_node_path5.default.join(cacheDir, entry.name, binName);
+      if (import_node_fs5.default.existsSync(nested))
+        return nested;
+    }
+  } catch {
+  }
+  return void 0;
+}
+async function ensureGeckodriver(ctxBag, record, existing, logger) {
+  const cacheDir = getBrowsersDir(ctxBag.ctx);
+  const resolveBinaryPath = (gecko) => {
+    const fromModule = gecko && typeof gecko.path === "string" && gecko.path.length > 0 && isPathInside(gecko.path, cacheDir) ? gecko.path : null;
+    return fromModule ?? geckodriverBinaryInCache(cacheDir) ?? cacheDir;
+  };
+  if (!ctxBag.force && existing && isStillFresh(existing.latestCheckedAt, ctxBag.now)) {
+    const gecko = ctxBag.deps.geckodriverModule ?? await withGeckodriverCacheDir(cacheDir, () => loadGeckodriver(ctxBag.deps, ctxBag.ctx));
+    return {
+      path: resolveBinaryPath(gecko),
+      version: existing.installedVersion,
+      // Only mark outdated when we actually KNOW a different latest
+      // version exists. If `latestKnownVersion` is undefined (e.g., the
+      // installer couldn't determine a version and we recorded
+      // `installedVersion: "unknown"` with `latestKnownVersion: undefined`),
+      // a naive `!==` comparison would flag the entry as outdated on
+      // every run.
+      outdated: typeof existing.latestKnownVersion === "string" && existing.latestKnownVersion.length > 0 && existing.latestKnownVersion !== existing.installedVersion
+    };
+  }
+  return await withGeckodriverCacheDir(cacheDir, async () => {
+    const gecko = await loadGeckodriver(ctxBag.deps, ctxBag.ctx);
+    logger(`Installing geckodriver into ${cacheDir}`, "info");
+    await gecko.download();
+    let binaryPath = resolveBinaryPath(gecko);
+    let verify = await verifyDriverBinary("geckodriver", binaryPath, {
+      exec: ctxBag.deps.verifyExec
+    });
+    if (!verify.ok) {
+      logger(`Downloaded geckodriver failed validation (${verify.error}); re-downloading once.`, "warn");
+      try {
+        if (binaryPath && binaryPath !== cacheDir && import_node_fs5.default.existsSync(binaryPath)) {
+          import_node_fs5.default.rmSync(binaryPath, { force: true });
+        }
+      } catch {
+      }
+      await gecko.download();
+      binaryPath = resolveBinaryPath(gecko);
+      verify = await verifyDriverBinary("geckodriver", binaryPath, {
+        exec: ctxBag.deps.verifyExec
+      });
+    }
+    if (!verify.ok) {
+      throw new Error(`geckodriver is present but non-functional after a re-download (${verify.error}). It may be a partial or corrupt download; delete ${binaryPath} or reinstall.`);
+    }
+    const installedVersion = verify.version;
+    record.browsers.geckodriver = {
+      installedVersion,
+      installedAt: ctxBag.now.toISOString(),
+      latestKnownVersion: installedVersion,
+      latestCheckedAt: ctxBag.now.toISOString()
+    };
+    writeInstalledRecord(record, ctxBag.ctx);
+    return {
+      path: binaryPath,
+      version: installedVersion,
+      outdated: false
+    };
+  });
+}
+function getInstalledBrowsers(ctx = {}) {
+  const record = readInstalledRecord(ctx);
+  return Object.entries(record.browsers).map(([name, entry]) => ({
+    name,
+    installedVersion: entry.installedVersion,
+    installedAt: entry.installedAt,
+    latestKnownVersion: entry.latestKnownVersion
+  }));
+}
+var import_node_child_process3, import_node_fs5, import_node_path5, DRIVER_VERSION_ARGS, DRIVER_VERIFY_TIMEOUT_MS, ALLOWED_DRIVER_PATH, defaultDriverExec, BROWSER_CHANNELS, FRESHNESS_TTL_MS, RESOLVE_TIMEOUT_MS, RUNTIME_DEBUG2, defaultLogger2, inFlightInstalls, geckodriverEnvQueue;
+var init_browsers = __esm({
+  "dist/runtime/browsers.js"() {
+    "use strict";
+    import_node_child_process3 = require("node:child_process");
+    import_node_fs5 = __toESM(require("node:fs"), 1);
+    import_node_path5 = __toESM(require("node:path"), 1);
+    init_cacheDir();
+    init_loader();
+    DRIVER_VERSION_ARGS = {
+      geckodriver: ["--version"],
+      chromedriver: ["--version"],
+      safaridriver: ["--version"]
+    };
+    DRIVER_VERIFY_TIMEOUT_MS = 1e4;
+    ALLOWED_DRIVER_PATH = /[\\/](?:geckodriver|chromedriver|safaridriver)(?:\.exe)?$/i;
+    defaultDriverExec = (binaryPath, args, timeoutMs) => new Promise((resolve) => {
+      (0, import_node_child_process3.execFile)(binaryPath, args, { timeout: timeoutMs, windowsHide: true }, (err, stdout, stderr) => {
+        const out = typeof stdout === "string" ? stdout : String(stdout ?? "");
+        const errOut = typeof stderr === "string" ? stderr : String(stderr ?? "");
+        if (err && typeof err.code === "number") {
+          resolve({ code: err.code, stdout: out, stderr: errOut });
+        } else if (err) {
+          resolve({ code: null, stdout: out, stderr: `${errOut}${String(err)}` });
+        } else {
+          resolve({ code: 0, stdout: out, stderr: errOut });
+        }
+      });
+    });
+    BROWSER_CHANNELS = {
+      chrome: "stable",
+      firefox: "latest",
+      chromedriver: "stable",
+      geckodriver: "latest"
+    };
+    FRESHNESS_TTL_MS = 24 * 60 * 60 * 1e3;
+    RESOLVE_TIMEOUT_MS = 5e3;
+    RUNTIME_DEBUG2 = process.env.DOC_DETECTIVE_RUNTIME_DEBUG === "1";
+    defaultLogger2 = (msg, level = "info") => {
+      if (level === "debug" && !RUNTIME_DEBUG2)
+        return;
+      if (level === "error")
+        console.error(msg);
+      else
+        console.log(msg);
+    };
+    inFlightInstalls = /* @__PURE__ */ new Map();
+    geckodriverEnvQueue = Promise.resolve();
+  }
+});
+
 // dist/core/appium.js
 function appiumHomeForDriverPath(driverEntry) {
-  const marker = `${import_node_path5.default.sep}node_modules${import_node_path5.default.sep}`;
+  const marker = `${import_node_path6.default.sep}node_modules${import_node_path6.default.sep}`;
   const idx = driverEntry.lastIndexOf(marker);
   return idx === -1 ? null : driverEntry.slice(0, idx);
 }
 function setAppiumHome(ctx = {}) {
-  const runtimeAppium = import_node_path5.default.join(getRuntimeDir({ cacheDir: ctx.cacheDir }), "node_modules", "appium");
-  if ((0, import_node_fs5.existsSync)(runtimeAppium)) {
-    process.env.APPIUM_HOME = import_node_path5.default.join(getRuntimeDir({ cacheDir: ctx.cacheDir }));
+  const runtimeAppium = import_node_path6.default.join(getRuntimeDir({ cacheDir: ctx.cacheDir }), "node_modules", "appium");
+  if ((0, import_node_fs6.existsSync)(runtimeAppium)) {
+    process.env.APPIUM_HOME = import_node_path6.default.join(getRuntimeDir({ cacheDir: ctx.cacheDir }));
     return;
   }
   for (const driverName of ["appium-chromium-driver", "appium-geckodriver"]) {
@@ -385269,27 +385943,27 @@ function setAppiumHome(ctx = {}) {
       return;
     }
   }
-  const corePath = import_node_path5.default.join(__dirname3, "../../node_modules");
+  const corePath = import_node_path6.default.join(__dirname3, "../../node_modules");
   const pathArray = corePath.split("node_modules");
   let appiumParentPath = pathArray[0];
   for (let i = 1; i < pathArray.length; i++) {
-    if ((0, import_node_fs5.existsSync)(import_node_path5.default.join(appiumParentPath, "node_modules", "appium"))) {
+    if ((0, import_node_fs6.existsSync)(import_node_path6.default.join(appiumParentPath, "node_modules", "appium"))) {
       break;
     }
-    appiumParentPath = import_node_path5.default.join(appiumParentPath, "node_modules", pathArray[i]);
+    appiumParentPath = import_node_path6.default.join(appiumParentPath, "node_modules", pathArray[i]);
   }
   process.env.APPIUM_HOME = appiumParentPath;
 }
-var import_node_path5, import_node_fs5, import_node_url4, __dirname3;
+var import_node_path6, import_node_fs6, import_node_url4, __dirname3;
 var init_appium = __esm({
   "dist/core/appium.js"() {
     "use strict";
-    import_node_path5 = __toESM(require("node:path"), 1);
-    import_node_fs5 = require("node:fs");
+    import_node_path6 = __toESM(require("node:path"), 1);
+    import_node_fs6 = require("node:fs");
     import_node_url4 = require("node:url");
     init_cacheDir();
     init_loader();
-    __dirname3 = import_node_path5.default.dirname((0, import_node_url4.fileURLToPath)(importMetaUrl));
+    __dirname3 = import_node_path6.default.dirname((0, import_node_url4.fileURLToPath)(importMetaUrl));
   }
 });
 
@@ -385321,7 +385995,7 @@ async function readFile({ fileURLOrPath }) {
     }
   } else {
     try {
-      content = await import_node_fs6.default.promises.readFile(fileURLOrPath, "utf8");
+      content = await import_node_fs7.default.promises.readFile(fileURLOrPath, "utf8");
     } catch (error) {
       if (error.code === "ENOENT") {
         console.warn(`File not found: ${fileURLOrPath}`);
@@ -385392,13 +386066,13 @@ async function resolvePaths({ config, object, filePath, nested = false, objectTy
     if (relativePath.startsWith("https://") || relativePath.startsWith("http://") || relativePath.startsWith("heretto:")) {
       return relativePath;
     }
-    if (import_node_path6.default.isAbsolute(relativePath)) {
+    if (import_node_path7.default.isAbsolute(relativePath)) {
       return relativePath;
     }
-    const fileExists = import_node_fs6.default.existsSync(filePath2);
-    const isFile = fileExists ? import_node_fs6.default.lstatSync(filePath2).isFile() : import_node_path6.default.parse(filePath2).ext !== "";
-    const basePath = isFile ? import_node_path6.default.dirname(filePath2) : filePath2;
-    return baseType === "file" ? import_node_path6.default.resolve(basePath, relativePath) : import_node_path6.default.resolve(relativePath);
+    const fileExists = import_node_fs7.default.existsSync(filePath2);
+    const isFile = fileExists ? import_node_fs7.default.lstatSync(filePath2).isFile() : import_node_path7.default.parse(filePath2).ext !== "";
+    const basePath = isFile ? import_node_path7.default.dirname(filePath2) : filePath2;
+    return baseType === "file" ? import_node_path7.default.resolve(basePath, relativePath) : import_node_path7.default.resolve(relativePath);
   }
   const relativePathBase = config.relativePathBase;
   let pathProperties;
@@ -385447,7 +386121,7 @@ async function resolvePaths({ config, object, filePath, nested = false, objectTy
             objectType
           });
         } else if (typeof item === "string" && pathProperties.includes(property)) {
-          const resolved = property === "path" && object.directory && import_node_path6.default.isAbsolute(object.directory) ? resolve(relativePathBase, item, object.directory) : resolve(relativePathBase, item, filePath);
+          const resolved = property === "path" && object.directory && import_node_path7.default.isAbsolute(object.directory) ? resolve(relativePathBase, item, object.directory) : resolve(relativePathBase, item, filePath);
           object[property][i] = resolved;
         }
       }
@@ -385465,7 +386139,7 @@ async function resolvePaths({ config, object, filePath, nested = false, objectTy
       }
       if (pathProperties.includes(property)) {
         if (property === "path" && object.directory) {
-          const directory = import_node_path6.default.isAbsolute(object.directory) ? object.directory : resolve(relativePathBase, object.directory, filePath);
+          const directory = import_node_path7.default.isAbsolute(object.directory) ? object.directory : resolve(relativePathBase, object.directory, filePath);
           object[property] = resolve(relativePathBase, object[property], directory);
         } else {
           object[property] = resolve(relativePathBase, object[property], filePath);
@@ -385475,12 +386149,12 @@ async function resolvePaths({ config, object, filePath, nested = false, objectTy
   }
   return object;
 }
-var import_node_fs6, import_node_path6, import_yaml, import_axios2;
+var import_node_fs7, import_node_path7, import_yaml, import_axios2;
 var init_files = __esm({
   "dist/core/files.js"() {
     "use strict";
-    import_node_fs6 = __toESM(require("node:fs"), 1);
-    import_node_path6 = __toESM(require("node:path"), 1);
+    import_node_fs7 = __toESM(require("node:fs"), 1);
+    import_node_path7 = __toESM(require("node:path"), 1);
     import_yaml = __toESM(require("yaml"), 1);
     import_axios2 = __toESM(require("axios"), 1);
     init_validate();
@@ -385503,10 +386177,10 @@ async function getOperation(definition = {}, operationId = "", responseCode = ""
   if (!operationId) {
     throw new Error("OperationId is required.");
   }
-  for (const path21 in definition.paths) {
-    for (const method in definition.paths[path21]) {
-      if (definition.paths[path21][method].operationId === operationId) {
-        const operation = definition.paths[path21][method];
+  for (const path22 in definition.paths) {
+    for (const method in definition.paths[path22]) {
+      if (definition.paths[path22][method].operationId === operationId) {
+        const operation = definition.paths[path22][method];
         if (!server) {
           if (definition.servers && definition.servers.length > 0) {
             server = definition.servers[0].url;
@@ -385514,9 +386188,9 @@ async function getOperation(definition = {}, operationId = "", responseCode = ""
             throw new Error("No server URL provided and no servers defined in the OpenAPI definition.");
           }
         }
-        const example = await compileExample(operation, server + path21, responseCode, exampleKey);
+        const example = await compileExample(operation, server + path22, responseCode, exampleKey);
         const schemas2 = getSchemas(operation, responseCode);
-        return { path: path21, method, definition: operation, schemas: schemas2, example };
+        return { path: path22, method, definition: operation, schemas: schemas2, example };
       }
     }
   }
@@ -385537,15 +386211,15 @@ function getSchemas(definition = {}, responseCode = "") {
   schemas2.response = definition.responses[responseCode].content[Object.keys(definition.responses[responseCode].content)[0]].schema;
   return schemas2;
 }
-async function compileExample(operation = {}, path21 = "", responseCode = "", exampleKey = "") {
+async function compileExample(operation = {}, path22 = "", responseCode = "", exampleKey = "") {
   if (!operation) {
     throw new Error("Operation is required.");
   }
-  if (!path21) {
+  if (!path22) {
     throw new Error("Path is required.");
   }
   let example = {
-    url: path21,
+    url: path22,
     request: { parameters: {}, headers: {}, body: {} },
     response: { headers: {}, body: {} }
   };
@@ -385712,8 +386386,25 @@ __export(config_exports, {
   getBrowserDiagnostics: () => getBrowserDiagnostics,
   getEnvironment: () => getEnvironment,
   resolveConcurrentRunners: () => resolveConcurrentRunners,
-  setConfig: () => setConfig
+  setConfig: () => setConfig,
+  verifyAppDrivers: () => verifyAppDrivers
 });
+async function verifyAppDrivers(descriptors, { verify, logger }) {
+  const out = [];
+  for (const d of descriptors) {
+    if (!d.driverName || !d.driverPath) {
+      out.push(d.app);
+      continue;
+    }
+    const res = await verify(d.driverName, d.driverPath);
+    if (res.ok) {
+      out.push(d.app);
+    } else if (logger) {
+      logger(`Excluding ${d.app?.name ?? d.driverName} from available browsers: its ${d.driverName} driver is present but did not validate (${res.error ?? "no error reported"}). Possible causes include a partial or corrupt download, a permissions issue, or a missing dependency.`, "warning");
+    }
+  }
+  return out;
+}
 function deepMerge(target, override) {
   const result = { ...target };
   for (const key in override) {
@@ -385907,7 +386598,7 @@ function clearAppCache(config) {
 async function probeBrowserEnvironment({ config, browsersDir }) {
   setAppiumHome({ cacheDir: config?.cacheDir });
   const cwd = process.cwd();
-  process.chdir(import_node_path7.default.join(__dirname4, "../.."));
+  process.chdir(import_node_path8.default.join(__dirname4, "../.."));
   let installedBrowsers = [];
   let browserDetectionFailed = false;
   let appiumDriverOutput = "";
@@ -385942,7 +386633,7 @@ async function probeBrowserEnvironment({ config, browsersDir }) {
         });
         return;
       }
-      const child = (0, import_node_child_process3.spawn)(process.execPath, [appiumEntry, "driver", "list"], { env: process.env });
+      const child = (0, import_node_child_process4.spawn)(process.execPath, [appiumEntry, "driver", "list"], { env: process.env });
       let stdout = "";
       let stderr = "";
       child.stdout?.on("data", (c) => {
@@ -385979,44 +386670,69 @@ async function getAvailableApps({ config }) {
   if (hit)
     return hit;
   const { installedBrowsers, appiumDriverOutput, browserDetectionFailed } = await probeBrowserEnvironment({ config, browsersDir });
-  const apps = [];
+  const descriptors = [];
   const chrome = installedBrowsers.find((browser) => browser.browser === "chrome");
   const chromeVersion = chrome?.buildId;
   const chromedriver = installedBrowsers.find((browser) => browser.browser === "chromedriver");
   const appiumChromium = appiumDriverOutput.match(/\n.*chromium.*installed \(npm\).*\n/);
   if (chrome && chromedriver && appiumChromium) {
-    apps.push({
-      name: "chrome",
-      version: chromeVersion,
-      path: chrome.executablePath,
-      driver: chromedriver.executablePath
+    descriptors.push({
+      app: {
+        name: "chrome",
+        version: chromeVersion,
+        path: chrome.executablePath,
+        driver: chromedriver.executablePath
+      },
+      driverName: "chromedriver",
+      driverPath: chromedriver.executablePath
     });
   }
   const firefox = installedBrowsers.find((browser) => browser.browser === "firefox");
   const appiumFirefox = appiumDriverOutput.match(/\n.*gecko.*installed \(npm\).*\n/);
   if (firefox && appiumFirefox) {
-    apps.push({
-      name: "firefox",
-      version: firefox.buildId,
-      path: firefox.executablePath
+    const geckodriverPath = resolveGeckodriverBinaryPath(config, browsersDir);
+    descriptors.push({
+      app: {
+        name: "firefox",
+        version: firefox.buildId,
+        path: firefox.executablePath
+      },
+      driverName: geckodriverPath ? "geckodriver" : void 0,
+      driverPath: geckodriverPath
     });
   }
   if (config.environment.platform === "mac") {
     const safariVersion = await spawnCommand("defaults read /Applications/Safari.app/Contents/Info.plist CFBundleShortVersionString");
     const appiumSafari = appiumDriverOutput.match(/\n.*safari.*installed \(npm\).*\n/);
     if (safariVersion.exitCode === 0 && appiumSafari) {
-      apps.push({ name: "safari", version: safariVersion.stdout.trim(), path: "" });
+      descriptors.push({
+        app: { name: "safari", version: safariVersion.stdout.trim(), path: "" },
+        driverName: "safaridriver",
+        driverPath: "/usr/bin/safaridriver"
+      });
     }
   }
+  const apps = await verifyAppDrivers(descriptors, {
+    verify: (driverName, driverPath) => verifyDriverBinary(driverName, driverPath),
+    logger: (msg, level) => log(config, level ?? "warning", msg)
+  });
   if (!browserDetectionFailed)
     cachedAppsByDir.set(key, apps);
   return apps;
 }
+function resolveGeckodriverBinaryPath(config, browsersDir) {
+  const installed = resolveHeavyDepPath("geckodriver", {
+    cacheDir: config?.cacheDir
+  });
+  if (!installed)
+    return void 0;
+  return geckodriverBinaryInCache(browsersDir);
+}
 function probeSafariVersion(timeoutMs) {
   return new Promise((resolve) => {
     let child;
     try {
-      child = (0, import_node_child_process3.spawn)("defaults", [
+      child = (0, import_node_child_process4.spawn)("defaults", [
         "read",
         "/Applications/Safari.app/Contents/Info.plist",
         "CFBundleShortVersionString"
@@ -386097,7 +386813,7 @@ async function getBrowserDiagnostics({ config }) {
       const version = await probeSafariVersion(4e3);
       safariApp = version !== null;
       safariVersion = version ?? void 0;
-      safaridriver = import_node_fs7.default.existsSync("/usr/bin/safaridriver");
+      safaridriver = import_node_fs8.default.existsSync("/usr/bin/safaridriver");
     } catch {
       detectionFailed = true;
     }
@@ -386119,22 +386835,23 @@ async function getBrowserDiagnostics({ config }) {
   });
   return { browsers, detectionFailed };
 }
-var import_node_os3, import_node_fs7, import_node_path7, import_node_child_process3, import_node_url5, __dirname4, platformMap, defaultFileTypes, cachedAppsByDir;
+var import_node_os3, import_node_fs8, import_node_path8, import_node_child_process4, import_node_url5, __dirname4, platformMap, defaultFileTypes, cachedAppsByDir;
 var init_config = __esm({
   "dist/core/config.js"() {
     "use strict";
     import_node_os3 = __toESM(require("node:os"), 1);
-    import_node_fs7 = __toESM(require("node:fs"), 1);
+    import_node_fs8 = __toESM(require("node:fs"), 1);
     init_validate();
     init_utils();
-    import_node_path7 = __toESM(require("node:path"), 1);
-    import_node_child_process3 = require("node:child_process");
+    import_node_path8 = __toESM(require("node:path"), 1);
+    import_node_child_process4 = require("node:child_process");
     init_loader();
     init_cacheDir();
+    init_browsers();
     init_appium();
     init_openapi();
     import_node_url5 = require("node:url");
-    __dirname4 = import_node_path7.default.dirname((0, import_node_url5.fileURLToPath)(importMetaUrl));
+    __dirname4 = import_node_path8.default.dirname((0, import_node_url5.fileURLToPath)(importMetaUrl));
     platformMap = {
       darwin: "mac",
       linux: "linux",
@@ -386436,252 +387153,6 @@ var init_browserStepKeys = __esm({
   }
 });
 
-// dist/runtime/browsers.js
-var browsers_exports = {};
-__export(browsers_exports, {
-  BROWSER_CHANNELS: () => BROWSER_CHANNELS,
-  ensureBrowserInstalled: () => ensureBrowserInstalled,
-  getInstalledBrowsers: () => getInstalledBrowsers,
-  requiredBrowserAssets: () => requiredBrowserAssets
-});
-function requiredBrowserAssets(name) {
-  switch ((name ?? "").toLowerCase()) {
-    case "chrome":
-      return ["chrome", "chromedriver"];
-    case "firefox":
-      return ["firefox", "geckodriver"];
-    default:
-      return [];
-  }
-}
-async function loadPuppeteerBrowsers(deps, ctx) {
-  if (deps.browsersModule)
-    return deps.browsersModule;
-  return await loadHeavyDep("@puppeteer/browsers", { ctx, deps: { logger: deps.logger } });
-}
-async function loadGeckodriver(deps, ctx) {
-  if (deps.geckodriverModule)
-    return deps.geckodriverModule;
-  return await loadHeavyDep("geckodriver", { ctx, deps: { logger: deps.logger } });
-}
-function isStillFresh(latestCheckedAt, now) {
-  if (!latestCheckedAt)
-    return false;
-  const t = Date.parse(latestCheckedAt);
-  if (Number.isNaN(t))
-    return false;
-  return now.getTime() - t < FRESHNESS_TTL_MS;
-}
-async function resolveChannelBuildId(browsersModule, assetName, platform) {
-  const channel = BROWSER_CHANNELS[assetName];
-  return await withTimeout(Promise.resolve(browsersModule.resolveBuildId(assetName, platform, channel)), RESOLVE_TIMEOUT_MS, `resolveBuildId(${assetName}, ${channel})`);
-}
-function withTimeout(p, ms, label) {
-  return new Promise((resolve, reject) => {
-    const t = setTimeout(() => reject(new Error(`${label} timed out after ${ms}ms`)), ms);
-    if (typeof t.unref === "function")
-      t.unref();
-    p.then((v) => {
-      clearTimeout(t);
-      resolve(v);
-    }, (err) => {
-      clearTimeout(t);
-      reject(err);
-    });
-  });
-}
-async function ensureBrowserInstalled(name, options = {}) {
-  const { ctx = {} } = options;
-  const dedupeKey = `${name}:${getBrowsersDir(ctx)}`;
-  const inFlight = inFlightInstalls.get(dedupeKey);
-  if (inFlight)
-    return inFlight;
-  const p = ensureBrowserInstalledImpl(name, options).finally(() => {
-    inFlightInstalls.delete(dedupeKey);
-  });
-  inFlightInstalls.set(dedupeKey, p);
-  return p;
-}
-async function ensureBrowserInstalledImpl(name, options = {}) {
-  const { ctx = {}, deps = {}, force = false } = options;
-  const logger = deps.logger ?? defaultLogger2;
-  const now = (deps.now ?? (() => /* @__PURE__ */ new Date()))();
-  const cacheDir = getBrowsersDir(ctx);
-  const record = readInstalledRecord(ctx);
-  const existing = record.browsers[name];
-  if (name === "geckodriver") {
-    return await ensureGeckodriver({ ctx, deps: { ...deps, logger }, force, now }, record, existing, logger);
-  }
-  const browsersModule = await loadPuppeteerBrowsers(deps, ctx);
-  const platform = browsersModule.detectBrowserPlatform ? browsersModule.detectBrowserPlatform() : void 0;
-  if (!platform) {
-    throw new Error(`Unable to determine browser platform on ${process.platform}/${process.arch}. @puppeteer/browsers does not recognize this OS; ${name} cannot be installed automatically. Set DOC_DETECTIVE_CACHE_DIR to a pre-warmed cache or skip browser-driven steps.`);
-  }
-  if (!force && existing && isStillFresh(existing.latestCheckedAt, now)) {
-    if (existing.latestKnownVersion === existing.installedVersion) {
-      const path23 = await locateExecutable(browsersModule, name, existing.installedVersion, cacheDir, platform);
-      return { path: path23, version: existing.installedVersion, outdated: false };
-    }
-    const path22 = await locateExecutable(browsersModule, name, existing.installedVersion, cacheDir, platform);
-    logger(`${name} ${existing.installedVersion} installed in ${cacheDir}; "${BROWSER_CHANNELS[name]}" channel is now ${existing.latestKnownVersion}. Run \`doc-detective install browsers ${name} --force\` to update.`, "warn");
-    return { path: path22, version: existing.installedVersion, outdated: true };
-  }
-  let latest;
-  try {
-    latest = await resolveChannelBuildId(browsersModule, name, platform);
-  } catch (err) {
-    logger(`Channel resolution for ${name} skipped: ${String(err)}`, "debug");
-    if (existing) {
-      const path22 = await locateExecutable(browsersModule, name, existing.installedVersion, cacheDir, platform);
-      return { path: path22, version: existing.installedVersion, outdated: false };
-    }
-    throw err;
-  }
-  if (!force && existing && existing.installedVersion === latest) {
-    record.browsers[name] = {
-      ...existing,
-      latestKnownVersion: latest,
-      latestCheckedAt: now.toISOString()
-    };
-    writeInstalledRecord(record, ctx);
-    const path22 = await locateExecutable(browsersModule, name, latest, cacheDir, platform);
-    return { path: path22, version: latest, outdated: false };
-  }
-  if (!force && existing) {
-    record.browsers[name] = {
-      ...existing,
-      latestKnownVersion: latest,
-      latestCheckedAt: now.toISOString()
-    };
-    writeInstalledRecord(record, ctx);
-    logger(`${name} ${existing.installedVersion} installed in ${cacheDir}; "${BROWSER_CHANNELS[name]}" channel is now ${latest}. Run \`doc-detective install browsers ${name} --force\` to update.`, "warn");
-    const path22 = await locateExecutable(browsersModule, name, existing.installedVersion, cacheDir, platform);
-    return { path: path22, version: existing.installedVersion, outdated: true };
-  }
-  logger(`Installing ${name} ${latest} into ${cacheDir}`, "info");
-  await browsersModule.install({
-    browser: name,
-    buildId: latest,
-    cacheDir
-  });
-  if (existing && existing.installedVersion !== latest) {
-    try {
-      await browsersModule.uninstall({
-        browser: name,
-        buildId: existing.installedVersion,
-        cacheDir
-      });
-    } catch (err) {
-      logger(`Failed to prune old ${name} buildId ${existing.installedVersion}: ${String(err)}`, "debug");
-    }
-  }
-  record.browsers[name] = {
-    installedVersion: latest,
-    installedAt: now.toISOString(),
-    latestKnownVersion: latest,
-    latestCheckedAt: now.toISOString()
-  };
-  writeInstalledRecord(record, ctx);
-  const path21 = await locateExecutable(browsersModule, name, latest, cacheDir, platform);
-  return { path: path21, version: latest, outdated: false };
-}
-async function locateExecutable(browsersModule, name, buildId, cacheDir, platform) {
-  if (typeof browsersModule.computeExecutablePath === "function") {
-    return browsersModule.computeExecutablePath({
-      browser: name,
-      buildId,
-      cacheDir,
-      platform
-    });
-  }
-  return cacheDir;
-}
-async function ensureGeckodriver(ctxBag, record, existing, logger) {
-  const cacheDir = getBrowsersDir(ctxBag.ctx);
-  const resolveBinaryPath = (gecko2) => {
-    const fromModule = gecko2 && typeof gecko2.path === "string" && gecko2.path.length > 0 ? gecko2.path : null;
-    return fromModule ?? cacheDir;
-  };
-  if (!ctxBag.force && existing && isStillFresh(existing.latestCheckedAt, ctxBag.now)) {
-    const gecko2 = ctxBag.deps.geckodriverModule ?? await loadGeckodriver(ctxBag.deps, ctxBag.ctx);
-    return {
-      path: resolveBinaryPath(gecko2),
-      version: existing.installedVersion,
-      // Only mark outdated when we actually KNOW a different latest
-      // version exists. If `latestKnownVersion` is undefined (e.g., the
-      // installer couldn't determine a version and we recorded
-      // `installedVersion: "unknown"` with `latestKnownVersion: undefined`),
-      // a naive `!==` comparison would flag the entry as outdated on
-      // every run.
-      outdated: typeof existing.latestKnownVersion === "string" && existing.latestKnownVersion.length > 0 && existing.latestKnownVersion !== existing.installedVersion
-    };
-  }
-  const gecko = await loadGeckodriver(ctxBag.deps, ctxBag.ctx);
-  const prevEnv = process.env.GECKODRIVER_CACHE_DIR;
-  process.env.GECKODRIVER_CACHE_DIR = cacheDir;
-  try {
-    logger(`Installing geckodriver into ${cacheDir}`, "info");
-    const downloadResult = await gecko.download();
-    const resolvedVersion = (typeof gecko.GECKODRIVER_VERSION === "string" ? gecko.GECKODRIVER_VERSION : void 0) || (downloadResult && typeof downloadResult.version === "string" ? downloadResult.version : void 0);
-    if (!resolvedVersion) {
-      logger("Could not determine geckodriver version after install. Freshness checks for geckodriver will be unreliable until the next forced reinstall.", "warn");
-    }
-    const installedVersion = resolvedVersion ?? "unknown";
-    record.browsers.geckodriver = {
-      installedVersion,
-      installedAt: ctxBag.now.toISOString(),
-      latestKnownVersion: resolvedVersion,
-      latestCheckedAt: ctxBag.now.toISOString()
-    };
-    writeInstalledRecord(record, ctxBag.ctx);
-    return {
-      path: resolveBinaryPath(gecko),
-      version: installedVersion,
-      outdated: false
-    };
-  } finally {
-    if (prevEnv === void 0)
-      delete process.env.GECKODRIVER_CACHE_DIR;
-    else
-      process.env.GECKODRIVER_CACHE_DIR = prevEnv;
-  }
-}
-function getInstalledBrowsers(ctx = {}) {
-  const record = readInstalledRecord(ctx);
-  return Object.entries(record.browsers).map(([name, entry]) => ({
-    name,
-    installedVersion: entry.installedVersion,
-    installedAt: entry.installedAt,
-    latestKnownVersion: entry.latestKnownVersion
-  }));
-}
-var BROWSER_CHANNELS, FRESHNESS_TTL_MS, RESOLVE_TIMEOUT_MS, RUNTIME_DEBUG2, defaultLogger2, inFlightInstalls;
-var init_browsers = __esm({
-  "dist/runtime/browsers.js"() {
-    "use strict";
-    init_cacheDir();
-    init_loader();
-    BROWSER_CHANNELS = {
-      chrome: "stable",
-      firefox: "latest",
-      chromedriver: "stable",
-      geckodriver: "latest"
-    };
-    FRESHNESS_TTL_MS = 24 * 60 * 60 * 1e3;
-    RESOLVE_TIMEOUT_MS = 5e3;
-    RUNTIME_DEBUG2 = process.env.DOC_DETECTIVE_RUNTIME_DEBUG === "1";
-    defaultLogger2 = (msg, level = "info") => {
-      if (level === "debug" && !RUNTIME_DEBUG2)
-        return;
-      if (level === "error")
-        console.error(msg);
-      else
-        console.log(msg);
-    };
-    inFlightInstalls = /* @__PURE__ */ new Map();
-  }
-});
-
 // dist/runtime/inferRuntimeNeeds.js
 var inferRuntimeNeeds_exports = {};
 __export(inferRuntimeNeeds_exports, {
@@ -386819,8 +387290,8 @@ module.exports = __toCommonJS(index_exports);
 init_config();
 
 // dist/core/detectTests.js
-var import_node_fs9 = __toESM(require("node:fs"), 1);
-var import_node_path9 = __toESM(require("node:path"), 1);
+var import_node_fs10 = __toESM(require("node:fs"), 1);
+var import_node_path10 = __toESM(require("node:path"), 1);
 var import_node_os5 = __toESM(require("node:os"), 1);
 var import_node_crypto3 = __toESM(require("node:crypto"), 1);
 var import_yaml3 = __toESM(require("yaml"), 1);
@@ -387693,8 +388164,8 @@ init_files();
 init_utils();
 
 // dist/core/integrations/heretto.js
-var import_node_fs8 = __toESM(require("node:fs"), 1);
-var import_node_path8 = __toESM(require("node:path"), 1);
+var import_node_fs9 = __toESM(require("node:fs"), 1);
+var import_node_path9 = __toESM(require("node:path"), 1);
 var import_node_https = __toESM(require("node:https"), 1);
 var import_node_http = __toESM(require("node:http"), 1);
 var import_axios3 = __toESM(require("axios"), 1);
@@ -387736,7 +388207,7 @@ var HerettoUploader = class {
     const apiBaseUrl = `https://${integrationConfig.organizationId}.heretto.com`;
     let fileId = sourceIntegration.fileId;
     let parentFolderId = sourceIntegration.parentFolderId;
-    const filename = import_node_path8.default.basename(sourceIntegration.filePath);
+    const filename = import_node_path9.default.basename(sourceIntegration.filePath);
     const relativeFilePath = sourceIntegration.filePath;
     if (!fileId && integrationConfig.resourceDependencies) {
       const resolvedFile = this.resolveFromDependencies({
@@ -387776,9 +388247,9 @@ var HerettoUploader = class {
           }
         }
         if (!parentFolderId && relativeFilePath) {
-          const parentDirPath = import_node_path8.default.dirname(relativeFilePath);
+          const parentDirPath = import_node_path9.default.dirname(relativeFilePath);
           if (parentDirPath && parentDirPath !== ".") {
-            const folderName = import_node_path8.default.basename(parentDirPath);
+            const folderName = import_node_path9.default.basename(parentDirPath);
             log3(config, "debug", `Searching for parent folder by name: ${folderName}`);
             parentFolderId = await this.searchFolderByName({
               apiBaseUrl,
@@ -387854,11 +388325,11 @@ var HerettoUploader = class {
         return result;
       }
     }
-    if (!import_node_fs8.default.existsSync(localFilePath)) {
+    if (!import_node_fs9.default.existsSync(localFilePath)) {
       result.description = `Local file not found: ${localFilePath}`;
       return result;
     }
-    const fileContent = import_node_fs8.default.readFileSync(localFilePath);
+    const fileContent = import_node_fs9.default.readFileSync(localFilePath);
     const contentType = this.getContentType(localFilePath);
     try {
       await this.uploadFile({
@@ -387889,7 +388360,7 @@ var HerettoUploader = class {
   resolveFromDependencies({ resourceDependencies, filePath, filename, log: log3 }) {
     if (!resourceDependencies)
       return null;
-    const normalizedPath = import_node_path8.default.posix.normalize(filePath.replace(/\\/g, "/")).replace(/^\.\.\/+/g, "").replace(/^\.\//, "");
+    const normalizedPath = import_node_path9.default.posix.normalize(filePath.replace(/\\/g, "/")).replace(/^\.\.\/+/g, "").replace(/^\.\//, "");
     for (const [depPath, info] of Object.entries(resourceDependencies)) {
       if (depPath.startsWith("_"))
         continue;
@@ -387899,14 +388370,14 @@ var HerettoUploader = class {
         return info;
       }
     }
-    const parentDir = import_node_path8.default.dirname(normalizedPath);
-    const parentFolderName = import_node_path8.default.basename(parentDir);
+    const parentDir = import_node_path9.default.dirname(normalizedPath);
+    const parentFolderName = import_node_path9.default.basename(parentDir);
     for (const [depPath, info] of Object.entries(resourceDependencies)) {
       if (depPath.startsWith("_"))
         continue;
-      const depFilename = import_node_path8.default.basename(depPath);
-      const depParentDir = import_node_path8.default.dirname(depPath);
-      const depParentFolderName = import_node_path8.default.basename(depParentDir);
+      const depFilename = import_node_path9.default.basename(depPath);
+      const depParentDir = import_node_path9.default.dirname(depPath);
+      const depParentFolderName = import_node_path9.default.basename(depParentDir);
       if (depFilename === filename && depParentFolderName === parentFolderName) {
         log3("debug", `Found filename+folder match in dependencies: ${depPath}`);
         return info;
@@ -387915,7 +388386,7 @@ var HerettoUploader = class {
     for (const [depPath, info] of Object.entries(resourceDependencies)) {
       if (depPath.startsWith("_"))
         continue;
-      const depFilename = import_node_path8.default.basename(depPath);
+      const depFilename = import_node_path9.default.basename(depPath);
       if (depFilename === filename) {
         log3("debug", `Found filename match in dependencies: ${depPath}`);
         return info;
@@ -387946,17 +388417,17 @@ var HerettoUploader = class {
     };
     if (!resourceDependencies)
       return result;
-    const normalizedPath = import_node_path8.default.posix.normalize(filePath.replace(/\\/g, "/")).replace(/^(\.\.\/)+/g, "").replace(/^\.\//, "");
-    const parentDir = import_node_path8.default.dirname(normalizedPath);
-    const targetFolderName = import_node_path8.default.basename(parentDir);
+    const normalizedPath = import_node_path9.default.posix.normalize(filePath.replace(/\\/g, "/")).replace(/^(\.\.\/)+/g, "").replace(/^\.\//, "");
+    const parentDir = import_node_path9.default.dirname(normalizedPath);
+    const targetFolderName = import_node_path9.default.basename(parentDir);
     result.targetFolderName = targetFolderName;
     result.ditamapParentFolderId = resourceDependencies._ditamapParentFolderId || null;
     log3("debug", `Looking for parent folder '${targetFolderName}' in dependencies`);
     for (const [depPath, info] of Object.entries(resourceDependencies)) {
       if (depPath.startsWith("_"))
         continue;
-      const depParentDir = import_node_path8.default.dirname(depPath);
-      const depFolderName = import_node_path8.default.basename(depParentDir);
+      const depParentDir = import_node_path9.default.dirname(depPath);
+      const depFolderName = import_node_path9.default.basename(depParentDir);
       if (depFolderName === targetFolderName && info.parentFolderId) {
         log3("debug", `Found sibling file ${depPath} with parent folder ID: ${info.parentFolderId}`);
         result.folderId = info.parentFolderId;
@@ -388460,7 +388931,7 @@ var HerettoUploader = class {
    * @returns {string} MIME content type
    */
   getContentType(filePath) {
-    const ext = import_node_path8.default.extname(filePath).toLowerCase();
+    const ext = import_node_path9.default.extname(filePath).toLowerCase();
     const contentTypes = {
       ".png": "image/png",
       ".jpg": "image/jpeg",
@@ -388632,39 +389103,39 @@ async function pollJobStatus(client, fileId, jobId, log3, config) {
   return null;
 }
 async function downloadAndExtractOutput(client, fileId, jobId, herettoName, log3, config, deps) {
-  const fsModule = deps?.fsModule || import_node_fs8.default;
+  const fsModule = deps?.fsModule || import_node_fs9.default;
   const ZipClass = deps?.ZipClass || import_adm_zip.default;
-  const tempDir = import_node_path8.default.join(import_node_os4.default.tmpdir(), "doc-detective");
+  const tempDir = import_node_path9.default.join(import_node_os4.default.tmpdir(), "doc-detective");
   const hash = import_node_crypto2.default.createHash("md5").update(`${herettoName}_${jobId}`).digest("hex");
   try {
     fsModule.mkdirSync(tempDir, { recursive: true });
-    const outputDir = import_node_path8.default.join(tempDir, `heretto_${hash}`);
+    const outputDir = import_node_path9.default.join(tempDir, `heretto_${hash}`);
     log3(config, "debug", `Downloading publishing job output for ${herettoName}...`);
     const response = await client.get(`/files/${fileId}/publishes/${jobId}/assets-all`, {
       responseType: "arraybuffer",
       timeout: DOWNLOAD_TIMEOUT_MS,
       headers: { Accept: "application/octet-stream" }
     });
-    const zipPath = import_node_path8.default.join(tempDir, `heretto_${hash}.zip`);
+    const zipPath = import_node_path9.default.join(tempDir, `heretto_${hash}.zip`);
     fsModule.writeFileSync(zipPath, response.data);
     log3(config, "debug", `Extracting output to ${outputDir}...`);
     const zip = new ZipClass(zipPath);
-    const resolvedOutputDir = import_node_path8.default.resolve(outputDir);
+    const resolvedOutputDir = import_node_path9.default.resolve(outputDir);
     for (const entry of zip.getEntries()) {
-      const normalizedName = import_node_path8.default.posix.normalize(entry.entryName.replace(/\\/g, "/"));
+      const normalizedName = import_node_path9.default.posix.normalize(entry.entryName.replace(/\\/g, "/"));
       if (normalizedName.startsWith("..") || normalizedName.includes("/..")) {
         log3(config, "warning", `Skipping ZIP entry with path traversal: ${entry.entryName}`);
         continue;
       }
-      const resolvedPath = import_node_path8.default.resolve(outputDir, normalizedName);
-      if (!resolvedPath.startsWith(resolvedOutputDir + import_node_path8.default.sep) && resolvedPath !== resolvedOutputDir) {
+      const resolvedPath = import_node_path9.default.resolve(outputDir, normalizedName);
+      if (!resolvedPath.startsWith(resolvedOutputDir + import_node_path9.default.sep) && resolvedPath !== resolvedOutputDir) {
         log3(config, "warning", `Skipping ZIP entry outside output directory: ${entry.entryName}`);
         continue;
       }
       if (entry.isDirectory) {
         fsModule.mkdirSync(resolvedPath, { recursive: true });
       } else {
-        fsModule.mkdirSync(import_node_path8.default.dirname(resolvedPath), { recursive: true });
+        fsModule.mkdirSync(import_node_path9.default.dirname(resolvedPath), { recursive: true });
         fsModule.writeFileSync(resolvedPath, entry.getData());
       }
     }
@@ -388673,14 +389144,14 @@ async function downloadAndExtractOutput(client, fileId, jobId, herettoName, log3
     return outputDir;
   } catch (error) {
     try {
-      const zipCleanupPath = import_node_path8.default.join(tempDir, `heretto_${hash}.zip`);
+      const zipCleanupPath = import_node_path9.default.join(tempDir, `heretto_${hash}.zip`);
       if (fsModule.existsSync(zipCleanupPath)) {
         fsModule.unlinkSync(zipCleanupPath);
       }
     } catch {
     }
     try {
-      const cleanupOutputDir = import_node_path8.default.join(tempDir, `heretto_${hash}`);
+      const cleanupOutputDir = import_node_path9.default.join(tempDir, `heretto_${hash}`);
       if (fsModule.existsSync(cleanupOutputDir)) {
         fsModule.rmSync(cleanupOutputDir, { recursive: true, force: true });
       }
@@ -388759,7 +389230,7 @@ async function getResourceDependencies(restClient, ditamapId, log3, config) {
           pathToUuidMap[relativePath] = {
             uuid,
             fullPath: uri,
-            name: name || import_node_path8.default.basename(relativePath || ""),
+            name: name || import_node_path9.default.basename(relativePath || ""),
             parentFolderId
           };
         }
@@ -388827,12 +389298,12 @@ async function detectTests2({ config }) {
   return specs;
 }
 function generateSpecId(filePath) {
-  const absolutePath = import_node_path9.default.resolve(filePath);
+  const absolutePath = import_node_path10.default.resolve(filePath);
   const cwd = process.cwd();
-  const candidate = import_node_path9.default.relative(cwd, absolutePath);
-  const isInsideCwd = candidate.length > 0 && !candidate.startsWith("..") && !import_node_path9.default.isAbsolute(candidate);
+  const candidate = import_node_path10.default.relative(cwd, absolutePath);
+  const isInsideCwd = candidate.length > 0 && !candidate.startsWith("..") && !import_node_path10.default.isAbsolute(candidate);
   const relativePath = isInsideCwd ? candidate : absolutePath;
-  const normalizedPath = relativePath.split(import_node_path9.default.sep).join("/").replace(/^\.\//, "").replace(/[^a-zA-Z0-9._\-\/]/g, "_");
+  const normalizedPath = relativePath.split(import_node_path10.default.sep).join("/").replace(/^\.\//, "").replace(/[^a-zA-Z0-9._\-\/]/g, "_");
   return normalizedPath;
 }
 async function isValidSourceFile({ config, files, source }) {
@@ -388843,7 +389314,7 @@ async function isValidSourceFile({ config, files, source }) {
   });
   if (files.indexOf(source) >= 0)
     return false;
-  if (import_node_path9.default.extname(source) === ".json" || import_node_path9.default.extname(source) === ".yaml" || import_node_path9.default.extname(source) === ".yml") {
+  if (import_node_path10.default.extname(source) === ".json" || import_node_path10.default.extname(source) === ".yaml" || import_node_path10.default.extname(source) === ".yml") {
     const content = await readFile({ fileURLOrPath: source });
     if (typeof content !== "object") {
       log(config, "debug", `${source} isn't a valid test specification. Skipping.`);
@@ -388863,11 +389334,11 @@ async function isValidSourceFile({ config, files, source }) {
       if (test.before) {
         let beforePath = "";
         if (config.relativePathBase === "file") {
-          beforePath = import_node_path9.default.resolve(import_node_path9.default.dirname(source), test.before);
+          beforePath = import_node_path10.default.resolve(import_node_path10.default.dirname(source), test.before);
         } else {
-          beforePath = import_node_path9.default.resolve(test.before);
+          beforePath = import_node_path10.default.resolve(test.before);
         }
-        if (!import_node_fs9.default.existsSync(beforePath)) {
+        if (!import_node_fs10.default.existsSync(beforePath)) {
           log(config, "debug", `${beforePath} is specified to run before a test but isn't a valid file. Skipping ${source}.`);
           return false;
         }
@@ -388875,18 +389346,18 @@ async function isValidSourceFile({ config, files, source }) {
       if (test.after) {
         let afterPath = "";
         if (config.relativePathBase === "file") {
-          afterPath = import_node_path9.default.resolve(import_node_path9.default.dirname(source), test.after);
+          afterPath = import_node_path10.default.resolve(import_node_path10.default.dirname(source), test.after);
         } else {
-          afterPath = import_node_path9.default.resolve(test.after);
+          afterPath = import_node_path10.default.resolve(test.after);
         }
-        if (!import_node_fs9.default.existsSync(afterPath)) {
+        if (!import_node_fs10.default.existsSync(afterPath)) {
           log(config, "debug", `${afterPath} is specified to run after a test but isn't a valid file. Skipping ${source}.`);
           return false;
         }
       }
     }
   }
-  const extension = import_node_path9.default.extname(source).substring(1);
+  const extension = import_node_path10.default.extname(source).substring(1);
   if (!allowedExtensions.includes(extension)) {
     log(config, "debug", `${source} extension isn't specified in a \`config.fileTypes\` object. Skipping.`);
     return false;
@@ -388895,11 +389366,11 @@ async function isValidSourceFile({ config, files, source }) {
 }
 async function processDitaMap({ config, source }) {
   const hash = import_node_crypto3.default.createHash("md5").update(source).digest("hex");
-  const tmpBase = import_node_path9.default.join(import_node_os5.default.tmpdir(), "doc-detective");
-  const outputDir = import_node_path9.default.join(tmpBase, `ditamap_${hash}`);
-  if (!import_node_fs9.default.existsSync(tmpBase)) {
+  const tmpBase = import_node_path10.default.join(import_node_os5.default.tmpdir(), "doc-detective");
+  const outputDir = import_node_path10.default.join(tmpBase, `ditamap_${hash}`);
+  if (!import_node_fs10.default.existsSync(tmpBase)) {
     log(config, "debug", `Creating temp directory: ${tmpBase}`);
-    import_node_fs9.default.mkdirSync(tmpBase, { recursive: true });
+    import_node_fs10.default.mkdirSync(tmpBase, { recursive: true });
   }
   const ditaVersion = await spawnCommand("dita", ["--version"]);
   if (ditaVersion.exitCode !== 0) {
@@ -389006,13 +389477,13 @@ async function qualifyFiles({ config }) {
     let isFile = false;
     let isDir = false;
     try {
-      isFile = import_node_fs9.default.statSync(source).isFile();
-      isDir = import_node_fs9.default.statSync(source).isDirectory();
+      isFile = import_node_fs10.default.statSync(source).isFile();
+      isDir = import_node_fs10.default.statSync(source).isDirectory();
     } catch {
       log(config, "warning", `Cannot access path: ${source}. Skipping.`);
       continue;
     }
-    if (isFile && import_node_path9.default.extname(source) === ".ditamap" && !ignoredDitaMaps.some((ignored) => source.includes(ignored)) && config.processDitaMaps) {
+    if (isFile && import_node_path10.default.extname(source) === ".ditamap" && !ignoredDitaMaps.some((ignored) => source.includes(ignored)) && config.processDitaMaps) {
       const ditaOutput = await processDitaMap({ config, source });
       if (ditaOutput) {
         const currentIndex = sequence.findIndex((e) => e.source === source);
@@ -389021,7 +389492,7 @@ async function qualifyFiles({ config }) {
       }
       continue;
     }
-    const resolved = import_node_path9.default.resolve(source);
+    const resolved = import_node_path10.default.resolve(source);
     if (isFile && await isValidSourceFile({ config, files, source: resolved })) {
       files.push(resolved);
       if (!phaseByFile.has(resolved))
@@ -389030,15 +389501,15 @@ async function qualifyFiles({ config }) {
       dirs = [];
       dirs[0] = source;
       for (const dir of dirs) {
-        const objects = import_node_fs9.default.readdirSync(dir);
+        const objects = import_node_fs10.default.readdirSync(dir);
         for (const object of objects) {
-          const content = import_node_path9.default.resolve(dir + "/" + object);
+          const content = import_node_path10.default.resolve(dir + "/" + object);
           if (content.includes("node_modules"))
             continue;
-          const isFile2 = import_node_fs9.default.statSync(content).isFile();
-          const isDir2 = import_node_fs9.default.statSync(content).isDirectory();
+          const isFile2 = import_node_fs10.default.statSync(content).isFile();
+          const isDir2 = import_node_fs10.default.statSync(content).isDirectory();
           if (isFile2 && await isValidSourceFile({ config, files, source: content })) {
-            const resolved2 = import_node_path9.default.resolve(content);
+            const resolved2 = import_node_path10.default.resolve(content);
             files.push(resolved2);
             if (!phaseByFile.has(resolved2))
               phaseByFile.set(resolved2, phase);
@@ -389055,12 +389526,12 @@ async function parseTests({ config, files }) {
   let specs = [];
   for (const file of files) {
     log(config, "debug", `file: ${file}`);
-    const extension = import_node_path9.default.extname(file).slice(1);
+    const extension = import_node_path10.default.extname(file).slice(1);
     let content = "";
     let rawContent;
     if (extension === "json" || extension === "yaml" || extension === "yml") {
       try {
-        rawContent = await import_node_fs9.default.promises.readFile(file, "utf8");
+        rawContent = await import_node_fs10.default.promises.readFile(file, "utf8");
         if (extension === "json") {
           content = JSON.parse(rawContent);
         } else {
@@ -389078,7 +389549,7 @@ async function parseTests({ config, files }) {
         content.specId = generateSpecId(file);
       if (!content.contentPath)
         content.contentPath = file;
-      const specPhase = config._phaseByFile?.get(import_node_path9.default.resolve(file)) ?? "main";
+      const specPhase = config._phaseByFile?.get(import_node_path10.default.resolve(file)) ?? "main";
       content._phase = specPhase;
       if (Array.isArray(content.tests)) {
         const usedTestIds = new Set(content.tests.map((test) => test?.testId).filter((id) => id));
@@ -389246,7 +389717,7 @@ async function parseTests({ config, files }) {
       let spec = {
         specId: id,
         contentPath: file,
-        _phase: config._phaseByFile?.get(import_node_path9.default.resolve(file)) ?? "main",
+        _phase: config._phaseByFile?.get(import_node_path10.default.resolve(file)) ?? "main",
         tests: []
       };
       const fileType = config.fileTypes.find((fileType2) => fileType2.extensions.includes(extension));
@@ -389295,7 +389766,7 @@ async function parseTests({ config, files }) {
           object: spec,
           filePath: file
         });
-        spec._phase = config._phaseByFile?.get(import_node_path9.default.resolve(file)) ?? "main";
+        spec._phase = config._phaseByFile?.get(import_node_path10.default.resolve(file)) ?? "main";
         specs.push(spec);
       }
     }
@@ -389329,6 +389800,7 @@ function resolveContexts({ contexts, test, config }) {
         }
         if (browser.name === "safari")
           browser.name = "webkit";
+        browser.explicit = true;
         return browser;
       });
     }
@@ -389508,7 +389980,7 @@ init_utils();
 
 // dist/core/tests.js
 var import_tree_kill3 = __toESM(require("tree-kill"), 1);
-var import_node_fs21 = __toESM(require("node:fs"), 1);
+var import_node_fs22 = __toESM(require("node:fs"), 1);
 init_loader();
 init_browsers();
 init_browserStepKeys();
@@ -390065,10 +390537,10 @@ init_validate();
 init_loader();
 
 // dist/core/tests/ffmpegRecorder.js
-var import_node_child_process4 = require("node:child_process");
+var import_node_child_process5 = require("node:child_process");
 var import_node_os6 = __toESM(require("node:os"), 1);
-var import_node_path10 = __toESM(require("node:path"), 1);
-var import_node_fs10 = __toESM(require("node:fs"), 1);
+var import_node_path11 = __toESM(require("node:path"), 1);
+var import_node_fs11 = __toESM(require("node:fs"), 1);
 var import_node_crypto5 = __toESM(require("node:crypto"), 1);
 init_loader();
 init_utils();
@@ -390147,7 +390619,7 @@ function browserCaptureTitle(contextId) {
   return `RECORD_ME_${safeContextId(contextId)}`;
 }
 function browserDownloadDir(contextId) {
-  return import_node_path10.default.join(import_node_os6.default.tmpdir(), "doc-detective", "recordings", safeContextId(contextId));
+  return import_node_path11.default.join(import_node_os6.default.tmpdir(), "doc-detective", "recordings", safeContextId(contextId));
 }
 function engineFields(record) {
   const engine = record && typeof record === "object" ? record.engine : void 0;
@@ -390384,7 +390856,7 @@ async function detectMacScreenIndex(ffmpegPath) {
       resolve(v);
     };
     try {
-      proc = (0, import_node_child_process4.spawn)(ffmpegPath, ["-f", "avfoundation", "-list_devices", "true", "-i", ""], { stdio: ["ignore", "ignore", "pipe"] });
+      proc = (0, import_node_child_process5.spawn)(ffmpegPath, ["-f", "avfoundation", "-list_devices", "true", "-i", ""], { stdio: ["ignore", "ignore", "pipe"] });
       proc.stderr?.on("data", (d) => {
         out += d.toString();
       });
@@ -390413,7 +390885,7 @@ async function detectX11ScreenSize(display) {
     };
     try {
       const env = display ? { ...process.env, DISPLAY: display } : process.env;
-      proc = (0, import_node_child_process4.spawn)("xdpyinfo", [], { env, stdio: ["ignore", "pipe", "ignore"] });
+      proc = (0, import_node_child_process5.spawn)("xdpyinfo", [], { env, stdio: ["ignore", "pipe", "ignore"] });
       proc.stdout?.on("data", (d) => {
         out += d.toString();
       });
@@ -390431,7 +390903,7 @@ async function detectX11ScreenSize(display) {
 async function checkSystemBinary(name) {
   return new Promise((resolve) => {
     try {
-      const proc = (0, import_node_child_process4.spawn)(name, ["-help"], { stdio: "ignore" });
+      const proc = (0, import_node_child_process5.spawn)(name, ["-help"], { stdio: "ignore" });
       proc.on("error", () => resolve(false));
       proc.on("close", () => resolve(true));
     } catch {
@@ -390448,7 +390920,7 @@ async function startXvfb(display, opts = {}) {
   const w = opts.width ?? defW;
   const h = opts.height ?? defH;
   const startMs = Date.now();
-  const proc = (0, import_node_child_process4.spawn)("Xvfb", [display, "-screen", "0", `${w}x${h}x24`, "-nolisten", "tcp"], { stdio: "ignore" });
+  const proc = (0, import_node_child_process5.spawn)("Xvfb", [display, "-screen", "0", `${w}x${h}x24`, "-nolisten", "tcp"], { stdio: "ignore" });
   let spawnErr = null;
   proc.on("error", (e) => {
     spawnErr = e;
@@ -390460,7 +390932,7 @@ async function startXvfb(display, opts = {}) {
     if (proc.exitCode !== null)
       throw new Error(`Xvfb exited early on ${display} (code ${proc.exitCode})`);
     try {
-      if (import_node_fs10.default.statSync(lock).mtimeMs >= startMs)
+      if (import_node_fs11.default.statSync(lock).mtimeMs >= startMs)
         return proc;
     } catch {
     }
@@ -390545,11 +391017,11 @@ function hasUnresolvedMetaReference(expression, context) {
   }
   return false;
 }
-function getMetaValue(path21, context) {
+function getMetaValue(path22, context) {
   if (!context) {
     return void 0;
   }
-  const [basePath, jsonPointer] = path21.split("#");
+  const [basePath, jsonPointer] = path22.split("#");
   const resolvedPath = resolvePathTemplateVariables(basePath, context);
   let value = getNestedProperty(context, resolvedPath);
   if (jsonPointer && value) {
@@ -390566,9 +391038,9 @@ function getMetaValue(path21, context) {
   }
   return value;
 }
-function resolvePathTemplateVariables(path21, context) {
+function resolvePathTemplateVariables(path22, context) {
   const templateRegex = /\{\{(\w+)\}\}/g;
-  return path21.replace(templateRegex, (match, varName) => {
+  return path22.replace(templateRegex, (match, varName) => {
     if (context && context.id && varName === "id") {
       return context.id;
     }
@@ -390605,10 +391077,10 @@ async function resolveEmbeddedExpressions(str, context) {
   parts.push(str.slice(lastIdx));
   return parts.join("");
 }
-function getNestedProperty(obj, path21) {
-  if (!obj || !path21)
+function getNestedProperty(obj, path22) {
+  if (!obj || !path22)
     return void 0;
-  const parts = path21.split(".");
+  const parts = path22.split(".");
   let current = obj;
   for (const part of parts) {
     if (current === null || current === void 0)
@@ -391866,8 +392338,8 @@ async function waitForDOMStable(driver, idleTime, timeout) {
 init_validate();
 init_utils();
 var import_tree_kill = __toESM(require("tree-kill"), 1);
-var import_node_fs11 = __toESM(require("node:fs"), 1);
-var import_node_path11 = __toESM(require("node:path"), 1);
+var import_node_fs12 = __toESM(require("node:fs"), 1);
+var import_node_path12 = __toESM(require("node:path"), 1);
 async function runShell({ config, step, processRegistry }) {
   const result = {
     status: "PASS",
@@ -392009,19 +392481,19 @@ async function runShell({ config, step, processRegistry }) {
     descriptions.push(stdioMatched ? `Found expected output (${step.runShell.stdio}) in stdio.` : isRegex ? `Couldn't find expected output (${step.runShell.stdio}) in actual output (stdout or stderr).` : `Couldn't find expected output (${step.runShell.stdio}) in stdio (stdout or stderr).`);
   }
   if (step.runShell.path) {
-    const dir = import_node_path11.default.dirname(step.runShell.path);
-    if (!import_node_fs11.default.existsSync(dir)) {
-      import_node_fs11.default.mkdirSync(dir, { recursive: true });
+    const dir = import_node_path12.default.dirname(step.runShell.path);
+    if (!import_node_fs12.default.existsSync(dir)) {
+      import_node_fs12.default.mkdirSync(dir, { recursive: true });
     }
     let filePath = step.runShell.path;
     log(config, "debug", `Saving stdio to file: ${filePath}`);
-    if (!import_node_fs11.default.existsSync(filePath)) {
-      import_node_fs11.default.writeFileSync(filePath, result.outputs.stdio.stdout);
+    if (!import_node_fs12.default.existsSync(filePath)) {
+      import_node_fs12.default.writeFileSync(filePath, result.outputs.stdio.stdout);
     } else {
       if (step.runShell.overwrite == "false") {
         descriptions.push(`Didn't save output. File already exists.`);
       }
-      const existingFile = import_node_fs11.default.readFileSync(filePath, "utf8");
+      const existingFile = import_node_fs12.default.readFileSync(filePath, "utf8");
       const fractionalDiff = calculateFractionalDifference(existingFile, result.outputs.stdio.stdout);
       log(config, "debug", `Fractional difference: ${fractionalDiff}`);
       result.outputs.variation = fractionalDiff;
@@ -392031,13 +392503,13 @@ async function runShell({ config, step, processRegistry }) {
       });
       if (fractionalDiff > step.runShell.maxVariation) {
         if (step.runShell.overwrite == "aboveVariation") {
-          import_node_fs11.default.writeFileSync(filePath, result.outputs.stdio.stdout);
+          import_node_fs12.default.writeFileSync(filePath, result.outputs.stdio.stdout);
           descriptions.push(`Saved output to file.`);
         }
         descriptions.push(`The difference between the existing output and the new output (${fractionalDiff.toFixed(2)}) is greater than the max accepted variation (${step.runShell.maxVariation}).`);
       } else {
         if (step.runShell.overwrite == "true") {
-          import_node_fs11.default.writeFileSync(filePath, result.outputs.stdio.stdout);
+          import_node_fs12.default.writeFileSync(filePath, result.outputs.stdio.stdout);
           descriptions.push(`Saved output to file.`);
         }
         descriptions.push(`Saved-file variation (${fractionalDiff.toFixed(2)}) is within the max accepted variation (${step.runShell.maxVariation}).`);
@@ -392235,8 +392707,8 @@ async function checkLink({ config, step }) {
 // dist/core/tests/saveScreenshot.js
 init_validate();
 init_utils();
-var import_node_path12 = __toESM(require("node:path"), 1);
-var import_node_fs12 = __toESM(require("node:fs"), 1);
+var import_node_path13 = __toESM(require("node:path"), 1);
+var import_node_fs13 = __toESM(require("node:fs"), 1);
 init_loader();
 var _pngjs = null;
 var _sharp = null;
@@ -392332,7 +392804,7 @@ async function saveScreenshot({ config, step, driver }) {
   if (typeof step.screenshot.path === "undefined") {
     step.screenshot.path = `${step.stepId}.png`;
     if (step.screenshot.directory) {
-      step.screenshot.path = import_node_path12.default.resolve(step.screenshot.directory, step.screenshot.path);
+      step.screenshot.path = import_node_path13.default.resolve(step.screenshot.directory, step.screenshot.path);
     }
   }
   step.screenshot = {
@@ -392368,17 +392840,17 @@ async function saveScreenshot({ config, step, driver }) {
     } catch {
       urlPathname = originalUrlPath;
     }
-    const rawBase = import_node_path12.default.basename(urlPathname.split("?")[0].split("#")[0].replace(/\\/g, "/"));
+    const rawBase = import_node_path13.default.basename(urlPathname.split("?")[0].split("#")[0].replace(/\\/g, "/"));
     const safeBase = sanitizeFilesystemName(rawBase, `${step.stepId}.png`);
-    dir = import_node_path12.default.join(process.cwd(), "doc-detective-runs", getOrInitRunTimestamp(config));
-    if (!import_node_fs12.default.existsSync(dir)) {
-      import_node_fs12.default.mkdirSync(dir, { recursive: true });
+    dir = import_node_path13.default.join(process.cwd(), "doc-detective-runs", getOrInitRunTimestamp(config));
+    if (!import_node_fs13.default.existsSync(dir)) {
+      import_node_fs13.default.mkdirSync(dir, { recursive: true });
     }
     const captureId = `${step.stepId || "screenshot"}_${Date.now()}`;
-    filePath = import_node_path12.default.join(dir, `${captureId}_${safeBase}`);
-    const resolvedDir = import_node_path12.default.resolve(dir);
-    const resolvedFile = import_node_path12.default.resolve(filePath);
-    if (!resolvedFile.startsWith(resolvedDir + import_node_path12.default.sep)) {
+    filePath = import_node_path13.default.join(dir, `${captureId}_${safeBase}`);
+    const resolvedDir = import_node_path13.default.resolve(dir);
+    const resolvedFile = import_node_path13.default.resolve(filePath);
+    if (!resolvedFile.startsWith(resolvedDir + import_node_path13.default.sep)) {
       result.status = "FAIL";
       result.description = `Refusing to write screenshot outside run folder: ${resolvedFile}`;
       return result;
@@ -392387,11 +392859,11 @@ async function saveScreenshot({ config, step, driver }) {
       log(config, "debug", `Screenshot path is a URL (${redactedUrl}); overwrite is ignored, running comparison only.`);
     }
   } else {
-    dir = import_node_path12.default.dirname(step.screenshot.path);
-    if (!import_node_fs12.default.existsSync(dir)) {
-      import_node_fs12.default.mkdirSync(dir, { recursive: true });
+    dir = import_node_path13.default.dirname(step.screenshot.path);
+    if (!import_node_fs13.default.existsSync(dir)) {
+      import_node_fs13.default.mkdirSync(dir, { recursive: true });
     }
-    if (import_node_fs12.default.existsSync(filePath)) {
+    if (import_node_fs13.default.existsSync(filePath)) {
       if (step.screenshot.overwrite == "false") {
         result.status = "SKIPPED";
         result.description = `File already exists: ${filePath}`;
@@ -392399,7 +392871,7 @@ async function saveScreenshot({ config, step, driver }) {
         return result;
       } else {
         existFilePath = filePath;
-        filePath = import_node_path12.default.join(dir, `${step.stepId}_${Date.now()}.png`);
+        filePath = import_node_path13.default.join(dir, `${step.stepId}_${Date.now()}.png`);
       }
     }
   }
@@ -392497,8 +392969,8 @@ async function saveScreenshot({ config, step, driver }) {
   } catch (error) {
     result.status = "FAIL";
     result.description = `Couldn't save screenshot. ${error}`;
-    if (existFilePath && filePath !== existFilePath && import_node_fs12.default.existsSync(filePath)) {
-      import_node_fs12.default.unlinkSync(filePath);
+    if (existFilePath && filePath !== existFilePath && import_node_fs13.default.existsSync(filePath)) {
+      import_node_fs13.default.unlinkSync(filePath);
     }
     return result;
   } finally {
@@ -392553,7 +393025,7 @@ async function saveScreenshot({ config, step, driver }) {
     rect.width = clamped.width;
     rect.height = clamped.height;
     log(config, "debug", { padded_rect: rect });
-    const croppedPath = import_node_path12.default.join(dir, `cropped_${step.stepId || Date.now()}.png`);
+    const croppedPath = import_node_path13.default.join(dir, `cropped_${step.stepId || Date.now()}.png`);
     try {
       await sharp(filePath).extract({
         left: rect.x,
@@ -392561,12 +393033,12 @@ async function saveScreenshot({ config, step, driver }) {
         width: rect.width,
         height: rect.height
       }).toFile(croppedPath);
-      import_node_fs12.default.renameSync(croppedPath, filePath);
+      import_node_fs13.default.renameSync(croppedPath, filePath);
     } catch (error) {
       result.status = "FAIL";
       result.description = `Couldn't crop image. ${error}`;
-      if (existFilePath && filePath !== existFilePath && import_node_fs12.default.existsSync(filePath)) {
-        import_node_fs12.default.unlinkSync(filePath);
+      if (existFilePath && filePath !== existFilePath && import_node_fs13.default.existsSync(filePath)) {
+        import_node_fs13.default.unlinkSync(filePath);
       }
       return result;
     }
@@ -392574,7 +393046,7 @@ async function saveScreenshot({ config, step, driver }) {
   if (existFilePath) {
     if (step.screenshot.overwrite == "true" && !isUrlPath) {
       result.description += ` Overwrote existing file.`;
-      import_node_fs12.default.renameSync(filePath, existFilePath);
+      import_node_fs13.default.renameSync(filePath, existFilePath);
       result.outputs.screenshotPath = existFilePath;
       result.outputs.changed = true;
       if (step.screenshot.sourceIntegration) {
@@ -392587,13 +393059,13 @@ async function saveScreenshot({ config, step, driver }) {
       let img1;
       let img2;
       try {
-        img1 = PNG.sync.read(import_node_fs12.default.readFileSync(existFilePath));
-        img2 = PNG.sync.read(import_node_fs12.default.readFileSync(filePath));
+        img1 = PNG.sync.read(import_node_fs13.default.readFileSync(existFilePath));
+        img2 = PNG.sync.read(import_node_fs13.default.readFileSync(filePath));
       } catch (error) {
         result.status = "FAIL";
         result.description = isUrlPath ? `Couldn't decode PNG for comparison. The URL reference (${redactedUrl}) may not be a valid PNG. ${error}` : `Couldn't decode PNG for comparison. ${error}`;
-        if (!isUrlPath && filePath !== existFilePath && import_node_fs12.default.existsSync(filePath)) {
-          import_node_fs12.default.unlinkSync(filePath);
+        if (!isUrlPath && filePath !== existFilePath && import_node_fs13.default.existsSync(filePath)) {
+          import_node_fs13.default.unlinkSync(filePath);
         }
         return result;
       }
@@ -392605,8 +393077,8 @@ async function saveScreenshot({ config, step, driver }) {
       });
       if (!aspectRatioMatch) {
         result.description = `Couldn't compare images. Images have different aspect ratios.`;
-        if (!isUrlPath && filePath !== existFilePath && import_node_fs12.default.existsSync(filePath)) {
-          import_node_fs12.default.unlinkSync(filePath);
+        if (!isUrlPath && filePath !== existFilePath && import_node_fs13.default.existsSync(filePath)) {
+          import_node_fs13.default.unlinkSync(filePath);
         }
         return await evaluateApplicable();
       }
@@ -392633,8 +393105,8 @@ async function saveScreenshot({ config, step, driver }) {
       } catch (error) {
         result.status = "FAIL";
         result.description = `Couldn't load screenshot comparison dependency (pixelmatch). ${error?.message ?? error}`;
-        if (!isUrlPath && filePath !== existFilePath && import_node_fs12.default.existsSync(filePath)) {
-          import_node_fs12.default.unlinkSync(filePath);
+        if (!isUrlPath && filePath !== existFilePath && import_node_fs13.default.existsSync(filePath)) {
+          import_node_fs13.default.unlinkSync(filePath);
         }
         return result;
       }
@@ -392652,7 +393124,7 @@ async function saveScreenshot({ config, step, driver }) {
       });
       if (fractionalDiff > step.screenshot.maxVariation) {
         if (step.screenshot.overwrite == "aboveVariation" && !isUrlPath) {
-          import_node_fs12.default.renameSync(filePath, existFilePath);
+          import_node_fs13.default.renameSync(filePath, existFilePath);
         }
         result.description += ` The difference between the existing screenshot and new screenshot (${fractionalDiff.toFixed(2)}) is greater than the max accepted variation (${step.screenshot.maxVariation}).`;
         if (isUrlPath) {
@@ -392677,7 +393149,7 @@ async function saveScreenshot({ config, step, driver }) {
             result.outputs.sourceIntegration = step.screenshot.sourceIntegration;
           }
           if (step.screenshot.overwrite != "true") {
-            import_node_fs12.default.unlinkSync(filePath);
+            import_node_fs13.default.unlinkSync(filePath);
           }
         }
       }
@@ -392696,10 +393168,10 @@ async function saveScreenshot({ config, step, driver }) {
 // dist/core/tests/startRecording.js
 init_validate();
 init_utils();
-var import_node_child_process5 = require("node:child_process");
+var import_node_child_process6 = require("node:child_process");
 var import_node_crypto6 = require("node:crypto");
-var import_node_path13 = __toESM(require("node:path"), 1);
-var import_node_fs13 = __toESM(require("node:fs"), 1);
+var import_node_path14 = __toESM(require("node:path"), 1);
+var import_node_fs14 = __toESM(require("node:fs"), 1);
 var import_node_os7 = __toESM(require("node:os"), 1);
 async function startRecording({ config, context, step, driver }) {
   let result = {
@@ -392727,7 +393199,7 @@ async function startRecording({ config, context, step, driver }) {
   if (typeof step.record.path === "undefined") {
     step.record.path = `${step.stepId}.mp4`;
     if (step.record.directory) {
-      step.record.path = import_node_path13.default.resolve(step.record.directory, step.record.path);
+      step.record.path = import_node_path14.default.resolve(step.record.directory, step.record.path);
     }
   }
   step.record = {
@@ -392735,18 +393207,18 @@ async function startRecording({ config, context, step, driver }) {
     overwrite: step.record.overwrite || "false"
   };
   let filePath = step.record.path;
-  const baseName = import_node_path13.default.basename(filePath, import_node_path13.default.extname(filePath));
-  const dir = import_node_path13.default.dirname(step.record.path);
-  if (!import_node_fs13.default.existsSync(dir)) {
-    import_node_fs13.default.mkdirSync(dir, { recursive: true });
+  const baseName = import_node_path14.default.basename(filePath, import_node_path14.default.extname(filePath));
+  const dir = import_node_path14.default.dirname(step.record.path);
+  if (!import_node_fs14.default.existsSync(dir)) {
+    import_node_fs14.default.mkdirSync(dir, { recursive: true });
   }
-  if (import_node_fs13.default.existsSync(filePath) && step.record.overwrite == "false") {
+  if (import_node_fs14.default.existsSync(filePath) && step.record.overwrite == "false") {
     result.status = "SKIPPED";
     result.description = `File already exists: ${filePath}`;
     return result;
   }
   const normalizeActiveTarget = (p) => {
-    const resolved = import_node_path13.default.resolve(p);
+    const resolved = import_node_path14.default.resolve(p);
     return process.platform === "win32" || process.platform === "darwin" ? resolved.toLowerCase() : resolved;
   };
   const normalizedTarget = normalizeActiveTarget(filePath);
@@ -392774,13 +393246,13 @@ async function startRecording({ config, context, step, driver }) {
     }
     const captureTitle = browserCaptureTitle(context.contextId);
     const downloadDir = browserDownloadDir(context.contextId);
-    if (!import_node_fs13.default.existsSync(downloadDir)) {
-      import_node_fs13.default.mkdirSync(downloadDir, { recursive: true });
+    if (!import_node_fs14.default.existsSync(downloadDir)) {
+      import_node_fs14.default.mkdirSync(downloadDir, { recursive: true });
     }
-    const downloadPath = import_node_path13.default.join(downloadDir, `${baseName}.webm`);
-    if (import_node_fs13.default.existsSync(downloadPath)) {
+    const downloadPath = import_node_path14.default.join(downloadDir, `${baseName}.webm`);
+    if (import_node_fs14.default.existsSync(downloadPath)) {
       try {
-        import_node_fs13.default.unlinkSync(downloadPath);
+        import_node_fs14.default.unlinkSync(downloadPath);
       } catch {
       }
     }
@@ -392907,10 +393379,10 @@ async function startRecording({ config, context, step, driver }) {
     } catch {
     }
   }
-  const tempDir = import_node_path13.default.join(import_node_os7.default.tmpdir(), "doc-detective", "recordings");
-  if (!import_node_fs13.default.existsSync(tempDir))
-    import_node_fs13.default.mkdirSync(tempDir, { recursive: true });
-  const tempPath = import_node_path13.default.join(tempDir, `${safeContextId(context.contextId)}-${baseName}-${(0, import_node_crypto6.randomUUID)().slice(0, 8)}.mkv`);
+  const tempDir = import_node_path14.default.join(import_node_os7.default.tmpdir(), "doc-detective", "recordings");
+  if (!import_node_fs14.default.existsSync(tempDir))
+    import_node_fs14.default.mkdirSync(tempDir, { recursive: true });
+  const tempPath = import_node_path14.default.join(tempDir, `${safeContextId(context.contextId)}-${baseName}-${(0, import_node_crypto6.randomUUID)().slice(0, 8)}.mkv`);
   let ffmpegPath;
   try {
     ffmpegPath = await getFfmpegPath({ cacheDir: config?.cacheDir });
@@ -392939,7 +393411,7 @@ async function startRecording({ config, context, step, driver }) {
     screenSize
   });
   log(config, "debug", `ffmpeg recording: platform=${process.platform} target=${plan.target}${screenIndex !== void 0 ? ` screen=${screenIndex}` : ""}${context.__display ? ` display=${context.__display}` : ""} -> ${tempPath}`);
-  const proc = (0, import_node_child_process5.spawn)(ffmpegPath, args, { stdio: ["pipe", "ignore", "pipe"] });
+  const proc = (0, import_node_child_process6.spawn)(ffmpegPath, args, { stdio: ["pipe", "ignore", "pipe"] });
   let spawnError = null;
   let stderrTail = "";
   proc.stderr?.on("data", (d) => {
@@ -392968,9 +393440,9 @@ async function startRecording({ config, context, step, driver }) {
 // dist/core/tests/stopRecording.js
 init_validate();
 init_utils();
-var import_node_child_process6 = require("node:child_process");
-var import_node_path14 = __toESM(require("node:path"), 1);
-var import_node_fs14 = __toESM(require("node:fs"), 1);
+var import_node_child_process7 = require("node:child_process");
+var import_node_path15 = __toESM(require("node:path"), 1);
+var import_node_fs15 = __toESM(require("node:fs"), 1);
 async function stopRecording({ config, step, driver }) {
   let result = {
     status: "PASS",
@@ -393107,7 +393579,7 @@ async function transcode({ config, sourcePath, targetPath, deleteSource, crop })
     const cy = `max(0\\,min(${crop.y}\\,ih-${ch}))`;
     filters.push(`crop=w=${cw}:h=${ch}:x=${cx}:y=${cy}`);
   }
-  if (import_node_path14.default.extname(targetPath) === ".gif") {
+  if (import_node_path15.default.extname(targetPath) === ".gif") {
     filters.push("scale=iw:-1:flags=lanczos");
   }
   if (filters.length > 0) {
@@ -393116,7 +393588,7 @@ async function transcode({ config, sourcePath, targetPath, deleteSource, crop })
   ffmpegArgs.push(`${targetPath}`);
   const ffmpegPath = await getFfmpegPath({ cacheDir: config?.cacheDir });
   await new Promise((resolve, reject) => {
-    const child = (0, import_node_child_process6.spawn)(ffmpegPath, ffmpegArgs);
+    const child = (0, import_node_child_process7.spawn)(ffmpegPath, ffmpegArgs);
     let stderr = "";
     child.stderr?.on("data", (d) => {
       stderr = (stderr + d.toString()).slice(-2e3);
@@ -393125,7 +393597,7 @@ async function transcode({ config, sourcePath, targetPath, deleteSource, crop })
       if (code === 0) {
         if (deleteSource && sourcePath !== targetPath) {
           try {
-            import_node_fs14.default.unlinkSync(sourcePath);
+            import_node_fs15.default.unlinkSync(sourcePath);
           } catch {
           }
         }
@@ -393144,7 +393616,7 @@ async function waitForStableFile(filePath, maxSeconds) {
   for (let i = 0; i < deadline; i++) {
     let size = -1;
     try {
-      size = import_node_fs14.default.statSync(filePath).size;
+      size = import_node_fs15.default.statSync(filePath).size;
     } catch {
       size = -1;
     }
@@ -393184,8 +393656,8 @@ async function loadVariables({ step }) {
 // dist/core/tests/saveCookie.js
 init_validate();
 init_utils();
-var import_node_path15 = __toESM(require("node:path"), 1);
-var import_node_fs15 = __toESM(require("node:fs"), 1);
+var import_node_path16 = __toESM(require("node:path"), 1);
+var import_node_fs16 = __toESM(require("node:fs"), 1);
 async function saveCookie({ config, step, driver }) {
   let result = {
     status: "PASS",
@@ -393202,7 +393674,7 @@ async function saveCookie({ config, step, driver }) {
   let cookieName, filePath, directory, overwrite, domain, variable;
   if (typeof step.saveCookie === "string") {
     if (step.saveCookie.endsWith(".txt")) {
-      cookieName = import_node_path15.default.basename(step.saveCookie, ".txt");
+      cookieName = import_node_path16.default.basename(step.saveCookie, ".txt");
       filePath = step.saveCookie;
     } else {
       cookieName = step.saveCookie;
@@ -393251,15 +393723,15 @@ async function saveCookie({ config, step, driver }) {
     }
     if (filePath) {
       const outputDirectory = directory || config.output || process.cwd();
-      const fullPath = import_node_path15.default.resolve(outputDirectory, filePath);
-      if (import_node_fs15.default.existsSync(fullPath) && !(overwrite === true || overwrite === "true")) {
+      const fullPath = import_node_path16.default.resolve(outputDirectory, filePath);
+      if (import_node_fs16.default.existsSync(fullPath) && !(overwrite === true || overwrite === "true")) {
         result.status = "FAIL";
         result.description = `File '${fullPath}' already exists and overwrite is not enabled.`;
         return result;
       }
-      const dir = import_node_path15.default.dirname(fullPath);
-      if (!import_node_fs15.default.existsSync(dir)) {
-        import_node_fs15.default.mkdirSync(dir, { recursive: true });
+      const dir = import_node_path16.default.dirname(fullPath);
+      if (!import_node_fs16.default.existsSync(dir)) {
+        import_node_fs16.default.mkdirSync(dir, { recursive: true });
       }
       if (targetCookie) {
         const netscapeCookie = formatCookieForNetscape(targetCookie);
@@ -393267,11 +393739,11 @@ async function saveCookie({ config, step, driver }) {
 # This is a cookie file saved by Doc Detective
 ${netscapeCookie}
 `;
-        import_node_fs15.default.writeFileSync(fullPath, content, "utf8");
+        import_node_fs16.default.writeFileSync(fullPath, content, "utf8");
         result.description = `Saved cookie '${cookieName}' to '${fullPath}'.`;
         log(config, "debug", `Saved cookie '${cookieName}' to file: ${fullPath}`);
       } else {
-        import_node_fs15.default.writeFileSync(fullPath, "# No cookie data\n", "utf8");
+        import_node_fs16.default.writeFileSync(fullPath, "# No cookie data\n", "utf8");
         result.description = `Created empty cookie file at '${fullPath}'.`;
         log(config, "debug", `Created empty cookie file: ${fullPath}`);
       }
@@ -393298,8 +393770,8 @@ function formatCookieForNetscape(cookie) {
 // dist/core/tests/loadCookie.js
 init_validate();
 init_utils();
-var import_node_path16 = __toESM(require("node:path"), 1);
-var import_node_fs16 = __toESM(require("node:fs"), 1);
+var import_node_path17 = __toESM(require("node:path"), 1);
+var import_node_fs17 = __toESM(require("node:fs"), 1);
 async function loadCookie({ config, step, driver }) {
   let result = {
     status: "PASS",
@@ -393316,7 +393788,7 @@ async function loadCookie({ config, step, driver }) {
   let cookieName, filePath, directory, domain, variable;
   if (typeof step.loadCookie === "string") {
     if (step.loadCookie.endsWith(".txt")) {
-      cookieName = import_node_path16.default.basename(step.loadCookie, ".txt");
+      cookieName = import_node_path17.default.basename(step.loadCookie, ".txt");
       filePath = step.loadCookie;
     } else {
       cookieName = step.loadCookie;
@@ -393329,9 +393801,9 @@ async function loadCookie({ config, step, driver }) {
     domain = step.loadCookie.domain;
     variable = step.loadCookie.variable;
     if (filePath && !cookieName) {
-      const ext = import_node_path16.default.extname(filePath).toLowerCase();
+      const ext = import_node_path17.default.extname(filePath).toLowerCase();
       if (ext === ".txt") {
-        cookieName = import_node_path16.default.basename(filePath, ext);
+        cookieName = import_node_path17.default.basename(filePath, ext);
       }
     }
   }
@@ -393354,14 +393826,14 @@ async function loadCookie({ config, step, driver }) {
       }
     } else if (filePath) {
       const inputDirectory = directory || config.output || process.cwd();
-      const fullPath = import_node_path16.default.resolve(inputDirectory, filePath);
-      if (!import_node_fs16.default.existsSync(fullPath)) {
+      const fullPath = import_node_path17.default.resolve(inputDirectory, filePath);
+      if (!import_node_fs17.default.existsSync(fullPath)) {
         result.status = "FAIL";
         result.description = `Cookie file '${fullPath}' not found`;
         return result;
       }
       try {
-        const fileContent = import_node_fs16.default.readFileSync(fullPath, "utf8");
+        const fileContent = import_node_fs17.default.readFileSync(fullPath, "utf8");
         const cookies = parseNetscapeCookieFile(fileContent);
         if (cookies.length === 0) {
           result.status = "FAIL";
@@ -393527,8 +393999,8 @@ function isDomainCompatible(currentDomain, cookieDomain) {
 // dist/core/tests/httpRequest.js
 init_validate();
 var import_axios5 = __toESM(require("axios"), 1);
-var import_node_fs17 = __toESM(require("node:fs"), 1);
-var import_node_path17 = __toESM(require("node:path"), 1);
+var import_node_fs18 = __toESM(require("node:fs"), 1);
+var import_node_path18 = __toESM(require("node:path"), 1);
 var import_ajv2 = __toESM(require("ajv"), 1);
 init_openapi();
 init_utils();
@@ -393555,9 +394027,9 @@ async function httpRequest({ config, step, openApiDefinitions = [] }) {
       delete step.httpRequest.openApi.definition;
     } else if (openApiDefinitions.length > 0) {
       for (const openApiConfig of openApiDefinitions) {
-        for (const path21 in openApiConfig.definition.paths) {
-          for (const method in openApiConfig.definition.paths[path21]) {
-            if (openApiConfig.definition.paths[path21][method].operationId === step.httpRequest.openApi.operationId) {
+        for (const path22 in openApiConfig.definition.paths) {
+          for (const method in openApiConfig.definition.paths[path22]) {
+            if (openApiConfig.definition.paths[path22][method].operationId === step.httpRequest.openApi.operationId) {
               openApiDefinition = openApiConfig.definition;
               step.httpRequest.openApi = {
                 ...openApiConfig,
@@ -393859,20 +394331,20 @@ async function httpRequest({ config, step, openApiDefinitions = [] }) {
     }
   }
   if (step.httpRequest.path) {
-    const dir = import_node_path17.default.dirname(step.httpRequest.path);
-    if (!import_node_fs17.default.existsSync(dir)) {
-      import_node_fs17.default.mkdirSync(dir, { recursive: true });
+    const dir = import_node_path18.default.dirname(step.httpRequest.path);
+    if (!import_node_fs18.default.existsSync(dir)) {
+      import_node_fs18.default.mkdirSync(dir, { recursive: true });
     }
     let filePath = step.httpRequest.path;
     log(config, "debug", `Saving output to file: ${filePath}`);
-    if (!import_node_fs17.default.existsSync(filePath)) {
-      await import_node_fs17.default.promises.writeFile(filePath, JSON.stringify(response.data, null, 2));
+    if (!import_node_fs18.default.existsSync(filePath)) {
+      await import_node_fs18.default.promises.writeFile(filePath, JSON.stringify(response.data, null, 2));
       descriptions.push(`Saved output to file.`);
     } else {
       if (step.httpRequest.overwrite == "false") {
         descriptions.push(`Didn't save output. File already exists.`);
       }
-      const existingFile = import_node_fs17.default.readFileSync(filePath, "utf8");
+      const existingFile = import_node_fs18.default.readFileSync(filePath, "utf8");
       const fractionalDiff = calculateFractionalDifference(existingFile, JSON.stringify(response.data, null, 2));
       log(config, "debug", `Fractional difference: ${fractionalDiff}`);
       result.outputs.variation = fractionalDiff;
@@ -393882,13 +394354,13 @@ async function httpRequest({ config, step, openApiDefinitions = [] }) {
       });
       if (fractionalDiff > step.httpRequest.maxVariation) {
         if (step.httpRequest.overwrite == "aboveVariation") {
-          await import_node_fs17.default.promises.writeFile(filePath, JSON.stringify(response.data, null, 2));
+          await import_node_fs18.default.promises.writeFile(filePath, JSON.stringify(response.data, null, 2));
           descriptions.push(`Saved response to file.`);
         }
         descriptions.push(`The difference between the existing saved response and the new response (${fractionalDiff.toFixed(2)}) is greater than the max accepted variation (${step.httpRequest.maxVariation}).`);
       } else {
         if (step.httpRequest.overwrite == "true") {
-          import_node_fs17.default.writeFileSync(filePath, JSON.stringify(response.data, null, 2));
+          import_node_fs18.default.writeFileSync(filePath, JSON.stringify(response.data, null, 2));
           descriptions.push(`Saved response to file.`);
         }
       }
@@ -393901,8 +394373,8 @@ async function httpRequest({ config, step, openApiDefinitions = [] }) {
   result.description = descriptions.join(" ").trim();
   return result;
 }
-function fieldExistsAtPath(obj, path21) {
-  const segments = path21.match(/[^.[\]]+/g);
+function fieldExistsAtPath(obj, path22) {
+  const segments = path22.match(/[^.[\]]+/g);
   if (!segments) {
     return false;
   }
@@ -394071,8 +394543,8 @@ async function clickElement({ config, step, driver }) {
 // dist/core/tests/runCode.js
 init_validate();
 init_utils();
-var import_node_fs18 = __toESM(require("node:fs"), 1);
-var import_node_path18 = __toESM(require("node:path"), 1);
+var import_node_fs19 = __toESM(require("node:fs"), 1);
+var import_node_path19 = __toESM(require("node:path"), 1);
 var import_node_os8 = __toESM(require("node:os"), 1);
 function createTempScript(code, language) {
   let extension;
@@ -394093,9 +394565,9 @@ function createTempScript(code, language) {
       extension = "";
   }
   const tmpDir = import_node_os8.default.tmpdir();
-  const tmpFile = import_node_path18.default.join(tmpDir, `doc-detective-${Date.now()}${extension}`);
+  const tmpFile = import_node_path19.default.join(tmpDir, `doc-detective-${Date.now()}${extension}`);
   try {
-    import_node_fs18.default.writeFileSync(tmpFile, code);
+    import_node_fs19.default.writeFileSync(tmpFile, code);
   } catch (error) {
     throw new Error(`Failed to create temporary script: ${error.message}`);
   }
@@ -394176,7 +394648,7 @@ async function runCode({ config, step, processRegistry }) {
     if (typeof step.runCode.stdio !== "undefined")
       runShellOptions.stdio = step.runCode.stdio;
     if (typeof step.runCode.path !== "undefined") {
-      runShellOptions.path = step.runCode.directory ? import_node_path18.default.join(step.runCode.directory, step.runCode.path) : step.runCode.path;
+      runShellOptions.path = step.runCode.directory ? import_node_path19.default.join(step.runCode.directory, step.runCode.path) : step.runCode.path;
     }
     if (step.runCode.background) {
       runShellOptions.background = step.runCode.background;
@@ -394204,7 +394676,7 @@ async function runCode({ config, step, processRegistry }) {
   } finally {
     if (!deferTempCleanup) {
       try {
-        import_node_fs18.default.unlinkSync(scriptPath);
+        import_node_fs19.default.unlinkSync(scriptPath);
         log(config, "debug", `Removed temporary script: ${scriptPath}`);
       } catch (error) {
         log(config, "warning", `Failed to remove temporary script: ${scriptPath}`);
@@ -394218,7 +394690,7 @@ async function runCode({ config, step, processRegistry }) {
 init_validate();
 init_utils();
 var import_tree_kill2 = __toESM(require("tree-kill"), 1);
-var import_node_fs19 = __toESM(require("node:fs"), 1);
+var import_node_fs20 = __toESM(require("node:fs"), 1);
 function resolveSurfaceNames(ref) {
   const items = Array.isArray(ref) ? ref : [ref];
   const names = [];
@@ -394265,7 +394737,7 @@ async function closeSurface({ config, step, processRegistry }) {
     }
     if (entry.tempPath) {
       try {
-        import_node_fs19.default.unlinkSync(entry.tempPath);
+        import_node_fs20.default.unlinkSync(entry.tempPath);
       } catch {
       }
     }
@@ -394291,8 +394763,8 @@ async function closeSurface({ config, step, processRegistry }) {
 // dist/core/tests/runBrowserScript.js
 init_validate();
 init_utils();
-var import_node_fs20 = __toESM(require("node:fs"), 1);
-var import_node_path19 = __toESM(require("node:path"), 1);
+var import_node_fs21 = __toESM(require("node:fs"), 1);
+var import_node_path20 = __toESM(require("node:path"), 1);
 async function runBrowserScript({ config, step, driver }) {
   const result = {
     status: "PASS",
@@ -394358,16 +394830,16 @@ async function runBrowserScript({ config, step, driver }) {
   }
   if (step.runBrowserScript.path) {
     try {
-      const dir = import_node_path19.default.dirname(step.runBrowserScript.path);
-      if (!import_node_fs20.default.existsSync(dir)) {
-        import_node_fs20.default.mkdirSync(dir, { recursive: true });
+      const dir = import_node_path20.default.dirname(step.runBrowserScript.path);
+      if (!import_node_fs21.default.existsSync(dir)) {
+        import_node_fs21.default.mkdirSync(dir, { recursive: true });
       }
       const filePath = step.runBrowserScript.path;
       log(config, "debug", `Saving script result to file: ${filePath}`);
-      if (!import_node_fs20.default.existsSync(filePath)) {
-        import_node_fs20.default.writeFileSync(filePath, serialized);
+      if (!import_node_fs21.default.existsSync(filePath)) {
+        import_node_fs21.default.writeFileSync(filePath, serialized);
       } else {
-        const existingFile = import_node_fs20.default.readFileSync(filePath, "utf8");
+        const existingFile = import_node_fs21.default.readFileSync(filePath, "utf8");
         const fractionalDiff = calculateFractionalDifference(existingFile, serialized);
         log(config, "debug", `Fractional difference: ${fractionalDiff}`);
         result.outputs.variation = fractionalDiff;
@@ -394377,7 +394849,7 @@ async function runBrowserScript({ config, step, driver }) {
         });
         if (fractionalDiff > step.runBrowserScript.maxVariation) {
           if (step.runBrowserScript.overwrite == "aboveVariation" || step.runBrowserScript.overwrite == "true") {
-            import_node_fs20.default.writeFileSync(filePath, serialized);
+            import_node_fs21.default.writeFileSync(filePath, serialized);
             descriptions.push(`Saved output to file.`);
           } else {
             descriptions.push(`Didn't overwrite the existing file.`);
@@ -394385,7 +394857,7 @@ async function runBrowserScript({ config, step, driver }) {
           descriptions.push(`The difference between the existing output and the new output (${fractionalDiff.toFixed(2)}) is greater than the max accepted variation (${step.runBrowserScript.maxVariation}).`);
         } else {
           if (step.runBrowserScript.overwrite == "true") {
-            import_node_fs20.default.writeFileSync(filePath, serialized);
+            import_node_fs21.default.writeFileSync(filePath, serialized);
             descriptions.push(`Saved output to file.`);
           }
         }
@@ -394534,8 +395006,8 @@ async function dragAndDropElement({ config, step, driver }) {
 }
 
 // dist/core/tests.js
-var import_node_path20 = __toESM(require("node:path"), 1);
-var import_node_child_process7 = require("node:child_process");
+var import_node_path21 = __toESM(require("node:path"), 1);
+var import_node_child_process8 = require("node:child_process");
 var import_node_crypto7 = require("node:crypto");
 init_appium();
 init_config();
@@ -394688,7 +395160,7 @@ function getIntegrationConfig(config, sourceIntegration) {
 var import_node_http2 = __toESM(require("node:http"), 1);
 var import_node_https2 = __toESM(require("node:https"), 1);
 var import_node_url6 = require("node:url");
-var __dirname5 = import_node_path20.default.dirname((0, import_node_url6.fileURLToPath)(importMetaUrl));
+var __dirname5 = import_node_path21.default.dirname((0, import_node_url6.fileURLToPath)(importMetaUrl));
 var KNOWN_BROWSERS = ["firefox", "chrome", "safari", "webkit"];
 function combinationKey(context) {
   const rawName = context?.browser?.name;
@@ -394835,6 +395307,49 @@ function getDefaultBrowser({ runnerDetails }) {
   }
   return browser;
 }
+function normalizeBrowserName(name) {
+  return name === "webkit" ? "safari" : name ?? "";
+}
+function buildFallbackCandidates({ requestedName, explicit, policy, availableApps }) {
+  const available = new Set((availableApps || []).map((a) => a.name));
+  const requestedNorm = normalizeBrowserName(requestedName);
+  const candidates = [];
+  if (available.has(requestedNorm))
+    candidates.push(requestedName);
+  const fallbackAllowed = policy === "auto" || policy === "explicit" && !explicit;
+  if (fallbackAllowed) {
+    for (const name of ["firefox", "chrome", "safari"]) {
+      if (name === requestedNorm)
+        continue;
+      if (available.has(name))
+        candidates.push(name);
+    }
+  }
+  return candidates;
+}
+function resolveBrowserFallbackPolicy({ context, config }) {
+  return context?.browserFallback || config?.browserFallback || "auto";
+}
+function shouldRepairBeforeFallback({ candidateName, requestedName, installAttempts }) {
+  if (normalizeBrowserName(candidateName) !== normalizeBrowserName(requestedName)) {
+    return false;
+  }
+  if (requiredBrowserAssets(candidateName).length === 0)
+    return false;
+  return !installAttempts.has((candidateName ?? "<none>").toLowerCase());
+}
+function driverSkipDiagnostic({ requestedName, platform, platformMatches, attemptedFallback, lastError }) {
+  if (!platformMatches) {
+    return `Skipping context on '${platform}': this context targets a different platform.`;
+  }
+  const driverHint = normalizeBrowserName(requestedName) === "firefox" ? "geckodriver" : normalizeBrowserName(requestedName) === "chrome" ? "chromedriver" : normalizeBrowserName(requestedName) === "safari" ? "safaridriver" : "driver";
+  let msg = `Skipping context: could not start a browser session for '${requestedName}' on '${platform}'`;
+  msg += attemptedFallback ? `, and no other available browser could start either.` : ` and cross-browser fallback is disabled or unavailable.`;
+  if (lastError)
+    msg += ` Last error: ${lastError}`;
+  msg += ` A present-but-broken driver (for example a partially downloaded ${driverHint}) can cause this; reinstall the driver or its browser.`;
+  return msg;
+}
 async function setViewportSize(context, driver) {
   if (context.browser?.viewport?.width || context.browser?.viewport?.height) {
     const viewportSize = await driver.execute("return { width: window.innerWidth, height: window.innerHeight }", []);
@@ -394983,7 +395498,7 @@ async function runSpecs({ resolvedTests }) {
   const runDir = getRunOutputDir(config, {
     create: runArchivesArtifacts(config, specs)
   });
-  const runId = import_node_path20.default.basename(runDir).replace(/^run-/, "");
+  const runId = import_node_path21.default.basename(runDir).replace(/^run-/, "");
   const report = {
     runId,
     runDir,
@@ -395218,7 +395733,7 @@ async function runSpecs({ resolvedTests }) {
       }
       if (entry?.tempPath) {
         try {
-          import_node_fs21.default.unlinkSync(entry.tempPath);
+          import_node_fs22.default.unlinkSync(entry.tempPath);
         } catch {
         }
       }
@@ -395607,7 +396122,9 @@ async function warmUpContexts({ jobs, config, runnerDetails, appiumPool, install
         deps: {
           ensureBrowser: (asset, options) => ensureBrowserInstalled(asset, options),
           log
-        }
+        },
+        // Repair a present-but-broken driver, not just install-if-missing.
+        repair: true
       });
       if (firstAttempt && (outcome === "installed" || outcome === "failed")) {
         clearAppCache(config);
@@ -395775,7 +396292,7 @@ function buildAutoRecordStep({ config, spec, test, context }) {
     return null;
   const runDir = getRunOutputDir(config, { create: false });
   const fileName = `${capPathSegment(sanitizeFilesystemName(String(context.contextId ?? ""), "context"))}.mp4`;
-  const recordPath = import_node_path20.default.join(runDir, "recordings", capPathSegment(sanitizeFilesystemName(String(spec.specId ?? ""), "spec")), capPathSegment(sanitizeFilesystemName(String(test.testId ?? ""), "test")), fileName);
+  const recordPath = import_node_path21.default.join(runDir, "recordings", capPathSegment(sanitizeFilesystemName(String(spec.specId ?? ""), "spec")), capPathSegment(sanitizeFilesystemName(String(test.testId ?? ""), "test")), fileName);
   return {
     record: { path: recordPath, overwrite: "true", engine: "ffmpeg" },
     description: "Automatic full-context recording",
@@ -395793,7 +396310,7 @@ async function captureAutoScreenshot({ config, driver, spec, test, context, step
     const action = BROWSER_STEP_KEYS.find((key) => typeof step[key] !== "undefined") || "step";
     const sanitizedTestId = sanitizeFilesystemName(String(test.testId ?? ""), "test");
     const runDir = getRunOutputDir(config);
-    const dir = import_node_path20.default.join(runDir, "screenshots", capPathSegment(sanitizeFilesystemName(String(spec.specId ?? ""), "spec")), capPathSegment(sanitizedTestId), capPathSegment(sanitizeFilesystemName(String(context.contextId ?? ""), "context")));
+    const dir = import_node_path21.default.join(runDir, "screenshots", capPathSegment(sanitizeFilesystemName(String(spec.specId ?? ""), "spec")), capPathSegment(sanitizedTestId), capPathSegment(sanitizeFilesystemName(String(context.contextId ?? ""), "context")));
     const stepIdString = sanitizeFilesystemName(String(step.stepId ?? ""), "step");
     const stepRef = capPathSegment(stepIdString.startsWith(`${sanitizedTestId}~`) ? stepIdString.slice(sanitizedTestId.length + 1) : stepIdString);
     const pad = Math.max(2, String(stepCount).length);
@@ -395802,7 +396319,7 @@ async function captureAutoScreenshot({ config, driver, spec, test, context, step
       stepId: `${step.stepId}_auto`,
       description: "Automatic post-step screenshot",
       screenshot: {
-        path: import_node_path20.default.join(dir, fileName),
+        path: import_node_path21.default.join(dir, fileName),
         overwrite: "true"
       }
     };
@@ -395815,7 +396332,7 @@ async function captureAutoScreenshot({ config, driver, spec, test, context, step
       log(config, "warning", `Auto screenshot failed after step ${step.stepId}: ${captureResult.description}`);
       return null;
     }
-    return import_node_path20.default.relative(runDir, screenshotStep.screenshot.path).split(import_node_path20.default.sep).join("/");
+    return import_node_path21.default.relative(runDir, screenshotStep.screenshot.path).split(import_node_path21.default.sep).join("/");
   } catch (error) {
     log(config, "warning", `Auto screenshot failed after step ${step.stepId}: ${error?.message ?? error}`);
     return null;
@@ -395859,6 +396376,7 @@ async function runContext({ config, spec, test, context, runnerDetails, appiumPo
     platform
   });
   let freshInstallRedetected = false;
+  let freshInstallOutcome;
   if (!supportedContext && context.platform === platform && // Mirror isSupportedContext's own guard: isDriverRequired iterates
   // context.steps, so a malformed context without a steps array would
   // otherwise crash here instead of skipping cleanly.
@@ -395871,10 +396389,15 @@ async function runContext({ config, spec, test, context, runnerDetails, appiumPo
       deps: {
         ensureBrowser: (asset, options) => ensureBrowserInstalled(asset, options),
         log
-      }
+      },
+      // The browser is unavailable here — possibly because its driver is
+      // present-but-broken — so repair (force a clean driver reinstall +
+      // re-validation), not just install-if-missing.
+      repair: true
     });
     if (firstAttempt && (outcome === "installed" || outcome === "failed")) {
       freshInstallRedetected = true;
+      freshInstallOutcome = outcome;
       clearAppCache(config);
       availableApps = await getAvailableApps({ config });
       runnerDetails.availableApps = availableApps;
@@ -395885,9 +396408,35 @@ async function runContext({ config, spec, test, context, runnerDetails, appiumPo
       });
     }
   }
-  if (!supportedContext) {
-    const errorMessage = freshInstallRedetected ? `Skipping context '${context.browser?.name}' on '${context.platform}': the missing browser dependency was installed but still could not be detected.` : `Skipping context. The current system doesn't support this context: {"platform": "${context.platform}", "apps": ${JSON.stringify(context.apps)}}`;
-    clog(freshInstallRedetected ? "warning" : "info", errorMessage);
+  const platformMatches = context.platform === platform;
+  const requestedBrowserName = context.browser?.name;
+  const explicitlyRequested = context.browser?.explicit === true;
+  const fallbackPolicy = resolveBrowserFallbackPolicy({ context, config });
+  const driverRequired = isDriverRequired({ test: context });
+  const candidateEngines = platformMatches && driverRequired ? buildFallbackCandidates({
+    requestedName: requestedBrowserName,
+    explicit: explicitlyRequested,
+    policy: fallbackPolicy,
+    availableApps
+  }) : [];
+  if (driverRequired && candidateEngines.length === 0) {
+    const errorMessage = freshInstallRedetected ? freshInstallOutcome === "installed" ? `Skipping context '${requestedBrowserName}' on '${context.platform}': the missing browser dependency was installed but still could not be detected.` : `Skipping context '${requestedBrowserName}' on '${context.platform}': the on-demand install/repair of its browser dependency failed.` : driverSkipDiagnostic({
+      requestedName: requestedBrowserName ?? "<none>",
+      // driverSkipDiagnostic treats `platform` as the *current* runner
+      // platform (as in the !startedName path), so pass that — not the
+      // context's target platform — or the mismatch message mislabels it.
+      platform,
+      platformMatches,
+      attemptedFallback: false
+    });
+    clog(platformMatches ? "warning" : "info", errorMessage);
+    contextReport.result = "SKIPPED";
+    contextReport.resultDescription = errorMessage;
+    return contextReport;
+  }
+  if (!driverRequired && !platformMatches) {
+    const errorMessage = `Skipping context. The current system doesn't support this context: {"platform": "${context.platform}", "apps": ${JSON.stringify(context.apps)}}`;
+    clog("info", errorMessage);
     contextReport.result = "SKIPPED";
     contextReport.resultDescription = errorMessage;
     return contextReport;
@@ -395896,20 +396445,13 @@ async function runContext({ config, spec, test, context, runnerDetails, appiumPo
 ${JSON.stringify(context, null, 2)}`);
   let driver;
   let appiumPort;
-  const driverRequired = isDriverRequired({ test: context });
+  let fellBackNote = "";
+  let fellBackPinned = false;
   if (driverRequired && !appiumPool) {
     throw new Error("Driver requested but no Appium server pool was created; driverJobCount and isDriverRequired(context) disagreed; this is a bug.");
   }
-  const combo = combinationKey(context);
   try {
     if (driverRequired) {
-      if (warmUpDecision(warmUpResults.get(combo)) === "skip") {
-        const errorMessage = `Skipping context '${context.browser?.name}' on '${context.platform}': this context combination could not start a driver earlier in this run.`;
-        clog("warning", errorMessage);
-        contextReport.result = "SKIPPED";
-        contextReport.resultDescription = errorMessage;
-        return contextReport;
-      }
       appiumPort = await appiumPool.acquire();
       if (portToDisplay) {
         const display = portToDisplay.get(appiumPort);
@@ -395922,49 +396464,118 @@ ${JSON.stringify(context, null, 2)}`);
         captureSourceTitle: browserCaptureTitle(context.contextId),
         downloadDir: browserDownloadDir(context.contextId)
       };
-      let caps = getDriverCapabilities({
-        runnerDetails,
-        name: context.browser.name,
-        options: {
-          width: context.browser?.window?.width || 1200,
-          height: context.browser?.window?.height || 800,
-          headless: context.browser?.headless !== false,
-          ...recordOptions
-        }
-      });
-      clog("debug", "CAPABILITIES:");
-      clog("debug", caps);
-      try {
-        driver = await driverStart(caps, appiumPort, 4, { cacheDir: config?.cacheDir });
-      } catch (error) {
+      const startDriverForBrowser = async (browserName) => {
+        const wantHeadless = context.browser?.headless !== false;
+        const buildCaps = (headless) => getDriverCapabilities({
+          runnerDetails,
+          name: browserName,
+          options: {
+            width: context.browser?.window?.width || 1200,
+            height: context.browser?.window?.height || 800,
+            headless,
+            ...recordOptions
+          }
+        });
+        const startFailure = () => {
+          let error = `Failed to start context '${browserName}' on '${platform}'.`;
+          if (browserName === "safari" || browserName === "webkit") {
+            error += " Make sure you've run `safaridriver --enable` in a terminal and enabled 'Allow Remote Automation' in Safari's Develop menu.";
+          }
+          return { ok: false, error };
+        };
         try {
-          clog("warning", `Failed to start context '${context.browser?.name}' on '${platform}'. Retrying as headless.`);
-          context.browser.headless = true;
-          caps = getDriverCapabilities({
-            runnerDetails,
-            name: context.browser.name,
-            options: {
-              width: context.browser?.window?.width || 1200,
-              height: context.browser?.window?.height || 800,
-              headless: context.browser?.headless !== false,
-              ...recordOptions
-            }
+          const d = await driverStart(buildCaps(wantHeadless), appiumPort, 4, {
+            cacheDir: config?.cacheDir
+          });
+          return { ok: true, driver: d, headless: wantHeadless };
+        } catch {
+          if (wantHeadless)
+            return startFailure();
+          try {
+            clog("warning", `Failed to start context '${browserName}' on '${platform}'. Retrying as headless.`);
+            const d = await driverStart(buildCaps(true), appiumPort, 4, {
+              cacheDir: config?.cacheDir
+            });
+            return { ok: true, driver: d, headless: true };
+          } catch {
+            return startFailure();
+          }
+        }
+      };
+      let startedName;
+      let startedHeadless = false;
+      let lastError = "";
+      for (const candidateName of candidateEngines) {
+        const candidateCombo = combinationKey({
+          platform: context.platform,
+          browser: { name: candidateName }
+        });
+        if (warmUpDecision(warmUpResults.get(candidateCombo)) === "skip") {
+          lastError = `context combination '${candidateName}' on '${platform}' could not start a driver earlier in this run.`;
+          continue;
+        }
+        let res = await startDriverForBrowser(candidateName);
+        if (!res.ok && shouldRepairBeforeFallback({
+          candidateName,
+          requestedName: requestedBrowserName,
+          installAttempts
+        })) {
+          const outcome = await ensureContextBrowserInstalled({
+            browserName: candidateName,
+            config,
+            installAttempts,
+            deps: {
+              ensureBrowser: (asset, options) => ensureBrowserInstalled(asset, options),
+              log
+            },
+            repair: true
           });
-          driver = await driverStart(caps, appiumPort, 4, { cacheDir: config?.cacheDir });
-        } catch (error2) {
-          let errorMessage = `Failed to start context '${context.browser?.name}' on '${platform}'.`;
-          if (context.browser?.name === "safari" || context.browser?.name === "webkit")
-            errorMessage = errorMessage + " Make sure you've run `safaridriver --enable` in a terminal and enabled 'Allow Remote Automation' in Safari's Develop menu.";
-          clog("error", errorMessage);
-          if (!warmUpResults.has(combo))
-            warmUpResults.set(combo, "failed");
-          contextReport.result = "SKIPPED";
-          contextReport.resultDescription = errorMessage;
-          return contextReport;
+          if (outcome === "installed") {
+            clog("info", `Repaired '${candidateName}' driver after a start failure; retrying before falling back.`);
+            res = await startDriverForBrowser(candidateName);
+          }
         }
+        if (res.ok) {
+          driver = res.driver;
+          startedName = candidateName;
+          startedHeadless = res.headless;
+          if (!warmUpResults.has(candidateCombo))
+            warmUpResults.set(candidateCombo, "ok");
+          break;
+        }
+        clog("error", res.error);
+        if (!warmUpResults.has(candidateCombo))
+          warmUpResults.set(candidateCombo, "failed");
+        lastError = res.error;
+      }
+      if (!startedName) {
+        const errorMessage = driverSkipDiagnostic({
+          requestedName: requestedBrowserName ?? "<none>",
+          platform,
+          platformMatches: true,
+          attemptedFallback: candidateEngines.length > 1,
+          lastError
+        });
+        clog("error", errorMessage);
+        contextReport.result = "SKIPPED";
+        contextReport.resultDescription = errorMessage;
+        return contextReport;
+      }
+      if (startedHeadless) {
+        context.browser = { ...context.browser, headless: true };
+        contextReport.browser = context.browser;
+      }
+      if (normalizeBrowserName(startedName) !== normalizeBrowserName(requestedBrowserName)) {
+        fellBackNote = `${requestedBrowserName} unavailable; ran on ${startedName}.`;
+        fellBackPinned = explicitlyRequested;
+        context.browser = { ...context.browser, name: startedName };
+        contextReport.browser = context.browser;
+        contextReport.fallback = {
+          requested: requestedBrowserName,
+          used: startedName
+        };
+        clog("warning", fellBackNote);
       }
-      if (!warmUpResults.has(combo))
-        warmUpResults.set(combo, "ok");
       if (context.browser?.viewport?.width || context.browser?.viewport?.height) {
         await setViewportSize(context, driver);
       } else if (context.browser?.window?.width || context.browser?.window?.height) {
@@ -396214,6 +396825,12 @@ ${JSON.stringify(r, null, 2)}`);
     }
   }
   contextReport.result = rollUpResults(contextReport.steps);
+  if (fellBackNote) {
+    if (fellBackPinned && contextReport.result === "PASS") {
+      contextReport.result = "WARNING";
+    }
+    contextReport.resultDescription = contextReport.resultDescription ? `${fellBackNote} ${contextReport.resultDescription}` : fellBackNote;
+  }
   return contextReport;
 }
 async function stopAllRecordings({ config, context, driver, contextReport }) {
@@ -396381,9 +396998,9 @@ async function startAppiumServer(appiumEntry, config, display) {
   const port = await findFreePort();
   log(config, "debug", `Starting Appium on port ${port}`);
   const env = display ? { ...process.env, DISPLAY: display } : process.env;
-  const proc = (0, import_node_child_process7.spawn)(process.execPath, [appiumEntry, "-a", "127.0.0.1", "-p", String(port)], {
+  const proc = (0, import_node_child_process8.spawn)(process.execPath, [appiumEntry, "-a", "127.0.0.1", "-p", String(port)], {
     windowsHide: true,
-    cwd: import_node_path20.default.join(__dirname5, "../.."),
+    cwd: import_node_path21.default.join(__dirname5, "../.."),
     env
   });
   proc.on("error", (err) => {
@@ -396482,7 +397099,7 @@ async function ensureChromeAvailable(config, deps) {
   }
   return availableApps;
 }
-async function ensureContextBrowserInstalled({ browserName, config, installAttempts, deps }) {
+async function ensureContextBrowserInstalled({ browserName, config, installAttempts, deps, repair = false }) {
   const key = (browserName ?? "<none>").toLowerCase();
   const cached = installAttempts.get(key);
   if (cached)
@@ -396495,9 +397112,13 @@ async function ensureContextBrowserInstalled({ browserName, config, installAttem
   const ctx = { cacheDir: config?.cacheDir };
   const logger = (msg, level = "info") => deps.log?.(config, level === "warn" ? "warning" : level, msg);
   try {
-    deps.log?.(config, "info", `Browser '${browserName}' is not available; attempting on-demand install of: ${assets.join(", ")}.`);
+    deps.log?.(config, "info", `Browser '${browserName}' is not available; attempting on-demand ${repair ? "repair" : "install"} of: ${assets.join(", ")}.`);
     for (const asset of assets) {
-      await deps.ensureBrowser(asset, { ctx, deps: { logger } });
+      await deps.ensureBrowser(asset, {
+        ctx,
+        deps: { logger },
+        force: !!repair
+      });
     }
     installAttempts.set(key, "installed");
     return "installed";
@@ -396528,9 +397149,9 @@ async function getRunner(options = {}) {
   if (!appiumEntry) {
     throw new Error("appium is not installed. Run `doc-detective install runtime appium` to install it.");
   }
-  const appium = (0, import_node_child_process7.spawn)(process.execPath, [appiumEntry, "-a", "127.0.0.1", "-p", String(appiumPort)], {
+  const appium = (0, import_node_child_process8.spawn)(process.execPath, [appiumEntry, "-a", "127.0.0.1", "-p", String(appiumPort)], {
     windowsHide: true,
-    cwd: import_node_path20.default.join(__dirname5, "../..")
+    cwd: import_node_path21.default.join(__dirname5, "../..")
   });
   appium.on("error", (err) => {
     log(config, "warning", `Appium process error: ${err?.stack ?? err?.message ?? String(err)}`);